webpack 5.108.3 → 5.109.0

package/lib/dependencies/CreateRequireParserPlugin.js

@@ -98,7 +98,7 @@ class CreateRequireParserPlugin {
 				"undefined",
 				/** @type {Range} */ (expr.range)
 			);
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.loc = parser.getLocation(expr);
 			parser.state.module.addPresentationalDependency(dep);
 			return false;
 		};
@@ -161,7 +161,7 @@ class CreateRequireParserPlugin {
 				const err = new WebpackError(
 					"module.createRequire supports only one argument."
 				);
-				err.loc = /** @type {DependencyLocation} */ (expr.loc);
+				err.loc = parser.getLocation(expr);
 				parser.state.module.addWarning(err);
 				return;
 			}
@@ -171,7 +171,7 @@ class CreateRequireParserPlugin {
 				const err = new WebpackError(
 					"module.createRequire failed parsing argument."
 				);
-				err.loc = /** @type {DependencyLocation} */ (arg.loc);
+				err.loc = parser.getLocation(arg);
 				parser.state.module.addWarning(err);
 				return;
 			}
@@ -249,7 +249,7 @@ class CreateRequireParserPlugin {
 						: "",
 					/** @type {Range} */ (statement.range)
 				);
-				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+				clearDep.loc = parser.getLocation(statement);
 				parser.state.module.addPresentationalDependency(clearDep);
 				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
 				return true;
@@ -342,7 +342,7 @@ class CreateRequireParserPlugin {
 					"/* createRequire */ undefined",
 					/** @type {Range} */ (expr.range)
 				);
-				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				clearDep.loc = parser.getLocation(expr);
 				parser.state.module.addPresentationalDependency(clearDep);
 				return true;
 			});
@@ -353,7 +353,7 @@ class CreateRequireParserPlugin {
 					"/* createRequire() */ undefined",
 					/** @type {Range} */ (expr.range)
 				);
-				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				clearDep.loc = parser.getLocation(expr);
 				parser.state.module.addPresentationalDependency(clearDep);
 				return true;
 			});

package/lib/dependencies/CssIcssExportDependency.js

@@ -245,7 +245,10 @@ const computeInterpolatedIdentifier = (
  * @property {boolean} interpolate whether the value needs interpolation
  * @property {ExportMode} exportMode export mode
  * @property {ExportType} exportType export type
- * @property {DependencyLocation=} loc per-export source location (for export source maps)
+ * @property {number} locStartLine per-export source start line (1-based; flat numbers instead of a nested `DependencyLocation` — entries are per-export hot allocations)
+ * @property {number} locStartColumn per-export source start column
+ * @property {number} locEndLine per-export source end line
+ * @property {number} locEndColumn per-export source end column
  * @property {string[]=} _conventionNames memoized convention names for `name`
  * @property {string[]=} _valueConventionNames memoized convention names for `value`
  */
@@ -289,6 +292,28 @@ class CssIcssExportDependency extends NullDependency {
 		this.entries = entries;
 		/** @type {undefined | string} */
 		this._hashUpdate = undefined;
+		/** @type {undefined | Map<string, CssExportEntry[]>} lazily-built `name -> entries` index, reused across every importer's codegen */
+		this._entriesByName = undefined;
+	}
+
+	/**
+	 * The `entries` grouped by export name, built once and reused. `entries` is
+	 * immutable after construction/deserialization, so this stays valid for the
+	 * dependency's lifetime (the composes/`@value` target of many importers).
+	 * @returns {Map<string, CssExportEntry[]>} entries grouped by export name
+	 */
+	getEntriesByName() {
+		if (this._entriesByName === undefined) {
+			/** @type {Map<string, CssExportEntry[]>} */
+			const map = new Map();
+			for (const e of this.entries) {
+				const list = map.get(e.name);
+				if (list) list.push(e);
+				else map.set(e.name, [e]);
+			}
+			this._entriesByName = map;
+		}
+		return this._entriesByName;
 	}
 
 	get type() {
@@ -412,8 +437,14 @@ class CssIcssExportDependency extends NullDependency {
 				);
 				error.module = module;
 				// Per-entry loc so Compilation attributes the warning precisely
-				// (it can't use the consolidated dependency's single loc).
-				if (entry.loc) error.loc = entry.loc;
+				// (it can't use the consolidated dependency's single loc). Built
+				// on demand — entries carry flat numbers, not location objects.
+				if (entry.locStartLine > 0) {
+					error.loc = {
+						start: { line: entry.locStartLine, column: entry.locStartColumn },
+						end: { line: entry.locEndLine, column: entry.locEndColumn }
+					};
+				}
 				if (warnings === null) warnings = [];
 				warnings.push(error);
 			}
@@ -464,7 +495,10 @@ class CssIcssExportDependency extends NullDependency {
 			write(entry.interpolate);
 			write(entry.exportMode);
 			write(entry.exportType);
-			write(entry.loc);
+			write(entry.locStartLine);
+			write(entry.locStartColumn);
+			write(entry.locEndLine);
+			write(entry.locEndColumn);
 		}
 		super.serialize(context);
 	}
@@ -486,58 +520,139 @@ class CssIcssExportDependency extends NullDependency {
 				interpolate: /** @type {boolean} */ (read()),
 				exportMode: /** @type {ExportMode} */ (read()),
 				exportType: /** @type {ExportType} */ (read()),
-				loc: /** @type {DependencyLocation=} */ (read())
+				locStartLine: /** @type {number} */ (read()),
+				locStartColumn: /** @type {number} */ (read()),
+				locEndLine: /** @type {number} */ (read()),
+				locEndColumn: /** @type {number} */ (read())
 			});
 		}
 		this.entries = entries;
 		this._hashUpdate = undefined;
+		this._entriesByName = undefined;
 		super.deserialize(context);
 	}
 }
 
 /**
- * Get (or lazily build into `indexCache`) a name -> entries index for `dep`,
- * so composes resolution does a Map lookup instead of scanning all entries per
- * reference. The cache is owned by one `apply` call and GC'd with it.
- * @param {Map<CssIcssExportDependency, Map<string, CssExportEntry[]>>} indexCache transient cache
- * @param {CssIcssExportDependency} dep export dependency
- * @returns {Map<string, CssExportEntry[]>} entries grouped by name
+ * @typedef {object} ResolutionCache
+ * @property {Map<CssModule, Map<string, CssExportEntry[]>>} exports module -> (export name -> entries) across all its export deps
+ * @property {Map<CssIcssImportDependency, CssModule | null>} targets import dep -> resolved target module
+ */
+
+/**
+ * Creates the transient per-`apply` cache shared by `resolve` and
+ * `resolveReferences`. It is GC'd when the codegen call returns and is never
+ * retained on the dependency.
+ * @returns {ResolutionCache} empty resolution cache
+ */
+const createResolutionCache = () => ({
+	exports: new Map(),
+	targets: new Map()
+});
+
+/**
+ * Shared read-only index for modules that own no export dep.
+ * @type {Map<string, CssExportEntry[]>}
+ */
+const EMPTY_INDEX = new Map();
+
+/**
+ * Per-module `local name -> import deps` index, keyed by module and validated by
+ * `buildInfo` identity (a fresh object per build). `apply` runs once per source
+ * type (CSS and JS), so this survives both passes — the index is built once per
+ * build instead of once per `apply`. Weakly held, so it never keeps a module
+ * alive.
+ * @type {WeakMap<CssModule, { buildInfo: unknown, index: Map<string, CssIcssImportDependency[]> }>}
+ */
+const moduleImportIndexes = new WeakMap();
+
+/**
+ * Get (or lazily resolve) the target module of an `@value`/composes import dep.
+ * The same import dep is followed by many entries within one codegen, so the
+ * `moduleGraph.getModule` lookup is memoized per dep.
+ * @param {ResolutionCache} cache resolution cache
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {CssIcssImportDependency} importDep import dependency
+ * @returns {CssModule | null} resolved target module, or `null` if none
+ */
+const getTargetModule = (cache, moduleGraph, importDep) => {
+	let module = cache.targets.get(importDep);
+	if (module === undefined) {
+		module = /** @type {CssModule | null} */ (moduleGraph.getModule(importDep));
+		cache.targets.set(importDep, module);
+	}
+	return module;
+};
+
+/**
+ * Get (or lazily build) the `name -> entries` index for `module`. There is one
+ * consolidated `CssIcssExportDependency` per module, and its own index is cached
+ * on the dep — so a module composed/imported by many others builds its index
+ * once per build rather than once per importer, and resolution does a single Map
+ * lookup instead of re-scanning `module.dependencies` per reference.
+ * @param {ResolutionCache} cache resolution cache
+ * @param {CssModule} module css module
+ * @returns {Map<string, CssExportEntry[]>} entries grouped by export name
  */
-const indexEntries = (indexCache, dep) => {
-	let map = indexCache.get(dep);
+const getExportIndex = (cache, module) => {
+	let map = cache.exports.get(module);
 	if (map === undefined) {
-		map = new Map();
-		for (const e of dep.entries) {
-			const list = map.get(e.name);
-			if (list) list.push(e);
-			else map.set(e.name, [e]);
+		map = EMPTY_INDEX;
+		for (const dep of module.dependencies) {
+			if (dep instanceof CssIcssExportDependency) {
+				map = dep.getEntriesByName();
+				break;
+			}
 		}
-		indexCache.set(dep, map);
+		cache.exports.set(module, map);
 	}
 	return map;
 };
 
+/**
+ * Get (or lazily build) the `local name -> import deps` index for `module`, so
+ * `findImportDep` is a Map lookup instead of a linear scan of every dependency.
+ * Cached per build on the module (validated by `buildInfo` identity) so both the
+ * CSS and JS codegen passes reuse one scan of `module.dependencies`.
+ * @param {CssModule} module css module
+ * @returns {Map<string, CssIcssImportDependency[]>} import deps grouped by local name
+ */
+const getImportIndex = (module) => {
+	const buildInfo = module.buildInfo;
+	const cached = moduleImportIndexes.get(module);
+	if (cached !== undefined && cached.buildInfo === buildInfo) {
+		return cached.index;
+	}
+	/** @type {Map<string, CssIcssImportDependency[]>} */
+	const index = new Map();
+	for (const d of module.dependencies) {
+		if (!(d instanceof CssIcssImportDependency)) continue;
+		const list = index.get(d.localName);
+		if (list) list.push(d);
+		else index.set(d.localName, [d]);
+	}
+	moduleImportIndexes.set(module, { buildInfo, index });
+	return index;
+};
+
 /**
  * Finds the active `CssIcssImportDependency` for a given local name. When a
  * `request` is provided the lookup also requires the import dependency's
  * `request` to match, so references between two `@value foo from "..."`
  * declarations resolve through the import in scope at the reference site.
- * @param {Iterable<Dependency>} dependencies module dependencies to search
+ * @param {CssModule} module module owning the dependencies to search
  * @param {string} localName local name
  * @param {string=} request user request of the `@value` import to match
  * @returns {CssIcssImportDependency | undefined} matching import dep, if any
  */
-const findImportDep = (dependencies, localName, request) => {
-	/** @type {CssIcssImportDependency | undefined} */
-	let firstMatch;
-	for (const d of dependencies) {
-		if (d instanceof CssIcssImportDependency && d.localName === localName) {
-			if (request === undefined) return d;
-			if (d.request === request) return d;
-			if (firstMatch === undefined) firstMatch = d;
-		}
-	}
-	return firstMatch;
+const findImportDep = (module, localName, request) => {
+	const list = getImportIndex(module).get(localName);
+	if (list === undefined) return undefined;
+	// Import deps keep dependency order, so `list[0]` is the first match (the
+	// legacy `firstMatch` fallback when no request-specific match exists).
+	if (request === undefined) return list[0];
+	for (const d of list) if (d.request === request) return d;
+	return list[0];
 };
 
 CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends (
@@ -552,7 +667,7 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @param {string | undefined} request user request of the `@value` import
 	 * @param {Set<CssExportEntry>=} seen cycle guard
-	 * @param {Map<CssIcssExportDependency, Map<string, CssExportEntry[]>>=} indexCache transient per-codegen name index (shared with `resolveReferences` within one `apply`)
+	 * @param {ResolutionCache=} cache transient per-codegen index (shared with `resolveReferences` within one `apply`)
 	 * @returns {string | undefined} found reference
 	 */
 	static resolve(
@@ -561,29 +676,21 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 		templateContext,
 		request,
 		seen = new Set(),
-		indexCache = new Map()
+		cache = createResolutionCache()
 	) {
 		const { moduleGraph } = templateContext;
 		const importDep = findImportDep(
-			templateContext.module.dependencies,
+			/** @type {CssModule} */ (templateContext.module),
 			localName,
 			request
 		);
 		if (!importDep) return undefined;
 
-		const module = /** @type {CssModule} */ (moduleGraph.getModule(importDep));
+		const module = getTargetModule(cache, moduleGraph, importDep);
 		if (!module) return undefined;
 
-		/** @type {CssExportEntry | undefined} */
-		let exportEntry;
-		for (const dep of module.dependencies) {
-			if (!(dep instanceof CssIcssExportDependency)) continue;
-			const matches = indexEntries(indexCache, dep).get(importName);
-			if (matches) {
-				exportEntry = matches[0];
-				break;
-			}
-		}
+		const matches = getExportIndex(cache, module).get(importName);
+		const exportEntry = matches && matches[0];
 		if (!exportEntry) return undefined;
 		if (seen.has(exportEntry)) return undefined;
 		seen.add(exportEntry);
@@ -597,7 +704,7 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 				{ ...templateContext, module },
 				value[2],
 				seen,
-				indexCache
+				cache
 			);
 		}
 
@@ -616,10 +723,10 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 	 * @param {CssExportEntry} entry composes entry
 	 * @param {DependencyTemplateContext} templateContext template context
 	 * @param {Set<CssExportEntry>} seen cycle guard
-	 * @param {Map<CssIcssExportDependency, Map<string, CssExportEntry[]>>} indexCache transient per-codegen name index, discarded after the module's `apply` (so it isn't retained on the dependency)
+	 * @param {ResolutionCache} cache transient per-codegen index, discarded after the module's `apply` (so it isn't retained on the dependency)
 	 * @returns {string[]} final names
 	 */
-	static resolveReferences(entry, templateContext, seen, indexCache) {
+	static resolveReferences(entry, templateContext, seen, cache) {
 		/** @type {string[]} */
 		const references = [];
 
@@ -628,24 +735,24 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 
 		if (Array.isArray(entry.value)) {
 			const importDep = findImportDep(
-				templateContext.module.dependencies,
+				/** @type {CssModule} */ (templateContext.module),
 				entry.value[0],
 				entry.value[2]
 			);
 			if (!importDep) return references;
 
-			const module =
-				/** @type {CssModule} */
-				(templateContext.moduleGraph.getModule(importDep));
+			const module = getTargetModule(
+				cache,
+				templateContext.moduleGraph,
+				importDep
+			);
 			if (!module) return references;
 
 			// Same overridden context and target name for every matched entry — build once, not per entry.
 			const subContext = { ...templateContext, module };
 			const name = /** @type {string[]} */ (entry.value)[1];
-			for (const dep of module.dependencies) {
-				if (!(dep instanceof CssIcssExportDependency)) continue;
-				const matches = indexEntries(indexCache, dep).get(name);
-				if (!matches) continue;
+			const matches = getExportIndex(cache, module).get(name);
+			if (matches) {
 				for (const d of matches) {
 					if (Array.isArray(d.value)) {
 						references.push(
@@ -653,7 +760,7 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 								d,
 								subContext,
 								seen,
-								indexCache
+								cache
 							)
 						);
 					} else {
@@ -676,12 +783,11 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 				)
 			);
 
-			for (const dep of templateContext.module.dependencies) {
-				if (!(dep instanceof CssIcssExportDependency)) continue;
-				const matches = indexEntries(indexCache, dep).get(
-					/** @type {string} */ (entry.value)
-				);
-				if (!matches) continue;
+			const matches = getExportIndex(
+				cache,
+				/** @type {CssModule} */ (templateContext.module)
+			).get(/** @type {string} */ (entry.value));
+			if (matches) {
 				for (const d of matches) {
 					if (d.exportType !== EXPORT_TYPE.COMPOSES) continue;
 					if (Array.isArray(d.value)) {
@@ -690,7 +796,7 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 								d,
 								templateContext,
 								seen,
-								indexCache
+								cache
 							)
 						);
 					} else {
@@ -746,9 +852,9 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 		// All entries belong to this one module, so resolve its ExportsInfo once
 		// instead of re-resolving `module -> exportsInfo` per export name.
 		const exportsInfo = isJs ? moduleGraph.getExportsInfo(module) : undefined;
-		// Transient name index for composes resolution within this module's codegen; GC'd when apply returns (never retained on the dependency).
-		/** @type {Map<CssIcssExportDependency, Map<string, CssExportEntry[]>>} */
-		const indexCache = new Map();
+		// Transient per-module indexes for composes resolution within this
+		// module's codegen; GC'd when apply returns (never retained on the dependency).
+		const cache = createResolutionCache();
 
 		for (const entry of dep.entries) {
 			if (!entry.range && !isJs) continue;
@@ -761,7 +867,7 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 					entry,
 					templateContext,
 					new Set(),
-					indexCache
+					cache
 				).join(" ");
 			} else if (isReference) {
 				const resolved = CssIcssExportDependencyTemplate.resolve(
@@ -770,7 +876,7 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 					templateContext,
 					/** @type {string[]} */ (entry.value)[2],
 					new Set(),
-					indexCache
+					cache
 				);
 				value = resolved || /** @type {string[]} */ (entry.value)[0];
 			} else {
@@ -794,36 +900,33 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 				/** @type {Set<string>} */
 				const allNames = new Set();
 				for (const name of names) {
-					const usedName = /** @type {NonNullable<typeof exportsInfo>} */ (
-						exportsInfo
-					)
-						.getExportInfo(name)
-						.getUsedName(name, runtime);
-					if (usedName) allNames.add(/** @type {string} */ (usedName));
+					if (
+						/** @type {NonNullable<typeof exportsInfo>} */ (exportsInfo)
+							.getExportInfo(name)
+							.getUsedName(name, runtime)
+					) {
+						allNames.add(name);
+					}
 				}
-				for (const name of names) allNames.add(name);
 				const unescaped = getCssTokens().unescapeIdentifier(
 					value,
 					templateContext.runtimeTemplate.compilation.compiler.root
 				);
 
-				const depLocStart =
-					entry.loc &&
-					/** @type {{ start?: { line: number, column: number } }} */ (
-						entry.loc
-					).start;
+				const depLocLine = entry.locStartLine;
+				const depLocColumn = entry.locStartColumn;
 				for (const used of allNames) {
 					if (entry.exportMode === EXPORT_MODE.ONCE) {
 						if (cssData.exports.has(used)) continue;
 						cssData.exports.set(used, unescaped);
 						if (
-							depLocStart &&
+							depLocLine > 0 &&
 							cssData.exportLocs &&
 							!cssData.exportLocs.has(used)
 						) {
 							cssData.exportLocs.set(used, {
-								line: depLocStart.line,
-								column: depLocStart.column
+								line: depLocLine,
+								column: depLocColumn
 							});
 						}
 					} else {
@@ -836,13 +939,13 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 							`${originalValue ? `${originalValue}${unescaped ? " " : ""}` : ""}${unescaped}`
 						);
 						if (
-							depLocStart &&
+							depLocLine > 0 &&
 							cssData.exportLocs &&
 							!cssData.exportLocs.has(used)
 						) {
 							cssData.exportLocs.set(used, {
-								line: depLocStart.line,
-								column: depLocStart.column
+								line: depLocLine,
+								column: depLocColumn
 							});
 						}
 					}

package/lib/dependencies/CssUrlDependency.js

@@ -21,8 +21,8 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<["string" | "url" | "src"]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<["string" | "url" | "src"]>} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<["string" | "url" | "src", true | undefined, true | undefined, ("high" | "low" | "auto" | undefined), string | undefined, string | undefined, string | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<["string" | "url" | "src", true | undefined, true | undefined, ("high" | "low" | "auto" | undefined), string | undefined, string | undefined, string | undefined]>} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
@@ -42,6 +42,18 @@ class CssUrlDependency extends ModuleDependency {
 		super(request);
 		this.range = range;
 		this.urlType = urlType;
+		/** @type {true | undefined} */
+		this.prefetch = undefined;
+		/** @type {true | undefined} */
+		this.preload = undefined;
+		/** @type {"low" | "high" | "auto" | undefined} */
+		this.fetchPriority = undefined;
+		/** @type {string | undefined} */
+		this.asAttribute = undefined;
+		/** @type {string | undefined} */
+		this.typeAttribute = undefined;
+		/** @type {string | undefined} */
+		this.mediaAttribute = undefined;
 	}
 
 	get type() {
@@ -89,7 +101,14 @@ class CssUrlDependency extends ModuleDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		context.write(this.urlType);
+		context
+			.write(this.urlType)
+			.write(this.prefetch)
+			.write(this.preload)
+			.write(this.fetchPriority)
+			.write(this.asAttribute)
+			.write(this.typeAttribute)
+			.write(this.mediaAttribute);
 		super.serialize(context);
 	}
 
@@ -99,7 +118,19 @@ class CssUrlDependency extends ModuleDependency {
 	 */
 	deserialize(context) {
 		this.urlType = context.read();
-		super.deserialize(context.rest);
+		const c1 = context.rest;
+		this.prefetch = c1.read();
+		const c2 = c1.rest;
+		this.preload = c2.read();
+		const c3 = c2.rest;
+		this.fetchPriority = c3.read();
+		const c4 = c3.rest;
+		this.asAttribute = c4.read();
+		const c5 = c4.rest;
+		this.typeAttribute = c5.read();
+		const c6 = c5.rest;
+		this.mediaAttribute = c6.read();
+		super.deserialize(c6.rest);
 	}
 }
 

package/lib/dependencies/ExternalModuleInitFragmentDependency.js

@@ -60,10 +60,10 @@ class ExternalModuleInitFragmentDependency extends NullDependency {
 
 makeSerializable(
 	ExternalModuleInitFragmentDependency,
-	"webpack/lib/dependencies/ExternalModuleConstDependency"
+	"webpack/lib/dependencies/ExternalModuleInitFragmentDependency"
 );
 
-ExternalModuleInitFragmentDependency.Template = class ExternalModuleConstDependencyTemplate extends (
+ExternalModuleInitFragmentDependency.Template = class ExternalModuleInitFragmentDependencyTemplate extends (
 	DependencyTemplate
 ) {
 	/**

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -8,6 +8,7 @@
 const { UsageState } = require("../ExportsInfo");
 const InitFragment = require("../InitFragment");
 const RuntimeGlobals = require("../RuntimeGlobals");
+const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
 const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
@@ -71,20 +72,37 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 		}
 		if (moduleGraph.isAsync(module)) {
 			runtimeRequirements.add(RuntimeGlobals.module);
-			runtimeRequirements.add(RuntimeGlobals.asyncModule);
-			initFragments.push(
-				new InitFragment(
-					runtimeTemplate.supportsArrowFunction()
-						? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {\n`
-						: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
-					InitFragment.STAGE_ASYNC_BOUNDARY,
-					0,
-					undefined,
-					`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${
-						/** @type {BuildMeta} */ (module.buildMeta).async ? ", 1" : ""
-					});`
-				)
-			);
+			const hasAwait = /** @type {BuildMeta} */ (module.buildMeta).async
+				? ", 1"
+				: "";
+			// Target has no `async`/`await` but has generators: drive the body as a
+			// generator so `await` becomes `yield`, keeping the module in a single
+			// scope (unlike a `.then` callback) without transpiling to a state machine.
+			if (isGeneratorLowered(module, moduleGraph, runtimeTemplate)) {
+				runtimeRequirements.add(RuntimeGlobals.asyncModuleGenerator);
+				initFragments.push(
+					new InitFragment(
+						`${RuntimeGlobals.asyncModule}(${module.moduleArgument}, ${RuntimeGlobals.asyncModuleGenerator}(function* (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
+						InitFragment.STAGE_ASYNC_BOUNDARY,
+						0,
+						undefined,
+						`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } })${hasAwait});`
+					)
+				);
+			} else {
+				runtimeRequirements.add(RuntimeGlobals.asyncModule);
+				initFragments.push(
+					new InitFragment(
+						runtimeTemplate.supportsArrowFunction()
+							? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {\n`
+							: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
+						InitFragment.STAGE_ASYNC_BOUNDARY,
+						0,
+						undefined,
+						`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${hasAwait});`
+					)
+				);
+			}
 		}
 	}
 };