@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/dependencies/ExportBindingInitFragment.js

@@ -0,0 +1,164 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const InitFragment = require("../InitFragment");
+const RuntimeGlobals = require("../RuntimeGlobals");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../ExportsInfo").UsedName} UsedName */
+
+/**
+ * @typedef {object} ExportBinding
+ * @property {UsedName} name the used export name
+ * @property {string} value the variable expression
+ * @property {"getter" | "value"=} bindingType "value" for value binding, defaults to "getter"
+ */
+
+/**
+ * Init fragment for const export bindings.
+ * Generates a flat-array __webpack_require__.d() call.
+ * Getter bindings: "key", () => expr (2 items).
+ * Value bindings: "key", 0, expr (3 items, 0 is sentinel).
+ *
+ * Uses a separate key ("harmony-export-bindings") from HarmonyExportInitFragment
+ * so the two fragment types do not merge and cannot interfere with each
+ * other's placement (top vs bottom).
+ * @extends {InitFragment<GenerateContext>} Context
+ */
+class ExportBindingInitFragment extends InitFragment {
+	/**
+	 * @param {string} exportsArgument the exports identifier
+	 * @param {ExportBinding[]} bindings list of export bindings
+	 * @param {boolean=} placeAtEnd when true, place the d() call at the end of the module
+	 */
+	constructor(exportsArgument, bindings, placeAtEnd = false) {
+		super(
+			undefined,
+			InitFragment.STAGE_HARMONY_EXPORTS,
+			1,
+			"harmony-export-bindings"
+		);
+		/** @type {string} */
+		this.exportsArgument = exportsArgument;
+		/** @type {ExportBinding[]} */
+		this.bindings = bindings;
+		/** @type {boolean} */
+		this.placeAtEnd = placeAtEnd;
+	}
+
+	/**
+	 * @param {ExportBindingInitFragment[]} fragments all fragments to merge
+	 * @returns {ExportBindingInitFragment} merged fragment
+	 */
+	mergeAll(fragments) {
+		/** @type {ExportBinding[]} */
+		const bindings = [];
+		/** @type {Set<string>} */
+		const seenNames = new Set();
+		let placeAtEnd = false;
+
+		for (const fragment of fragments) {
+			for (const binding of fragment.bindings) {
+				const key = /** @type {string} */ (binding.name);
+				if (!seenNames.has(key)) {
+					seenNames.add(key);
+					bindings.push(binding);
+				}
+			}
+			if (fragment.placeAtEnd) placeAtEnd = true;
+		}
+		return new ExportBindingInitFragment(
+			this.exportsArgument,
+			bindings,
+			placeAtEnd
+		);
+	}
+
+	/**
+	 * @param {ExportBindingInitFragment} other other
+	 * @returns {ExportBindingInitFragment} merged result
+	 */
+	merge(other) {
+		/** @type {ExportBinding[]} */
+		const bindings = [];
+		/** @type {Set<string>} */
+		const seenNames = new Set();
+		for (const binding of other.bindings) {
+			const key = /** @type {string} */ (binding.name);
+			seenNames.add(key);
+			bindings.push(binding);
+		}
+		for (const binding of this.bindings) {
+			const key = /** @type {string} */ (binding.name);
+			if (!seenNames.has(key)) {
+				seenNames.add(key);
+				bindings.push(binding);
+			}
+		}
+		return new ExportBindingInitFragment(
+			this.exportsArgument,
+			bindings,
+			this.placeAtEnd || other.placeAtEnd
+		);
+	}
+
+	/**
+	 * @param {GenerateContext} context context
+	 * @returns {string} the d() call or empty string
+	 */
+	_generateDefinition({ runtimeTemplate, runtimeRequirements }) {
+		if (this.bindings.length === 0) return "";
+
+		const sorted = [...this.bindings].sort((a, b) =>
+			/** @type {string} */ (a.name) < /** @type {string} */ (b.name) ? -1 : 1
+		);
+
+		/** @type {string[]} */
+		const items = [];
+		for (const binding of sorted) {
+			const key = JSON.stringify(/** @type {string} */ (binding.name));
+			if (binding.bindingType === "value") {
+				items.push(`\n/* harmony export */   ${key}, 0, ${binding.value}`);
+			} else {
+				items.push(
+					`\n/* harmony export */   ${key}, ${runtimeTemplate.returningFunction(binding.value)}`
+				);
+			}
+		}
+
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+		return `/* harmony export */ ${RuntimeGlobals.definePropertyGetters}(${
+			this.exportsArgument
+		}, [${items.join(",")}\n/* harmony export */ ]);\n`;
+	}
+
+	/**
+	 * Returns the source code that will be included as initialization code.
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included as initialization code
+	 */
+	getContent(context) {
+		if (this.placeAtEnd) return undefined;
+		return this._generateDefinition(context);
+	}
+
+	/**
+	 * Returns the source code that will be included at the end of the module.
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included at the end of the module
+	 */
+	getEndContent(context) {
+		if (!this.placeAtEnd) return undefined;
+		const definePart = this._generateDefinition(context);
+		if (!definePart) return undefined;
+		return `\n${definePart}`;
+	}
+}
+
+module.exports = ExportBindingInitFragment;

package/lib/dependencies/ExportsInfoDependency.js

@@ -16,16 +16,18 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, ExportInfoName[] | null, string | null]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, ExportInfoName[] | null, string | null]>} ObjectSerializerContext */
 
 /**
+ * Defines the sortable set type used by this module.
  * @template T
  * @typedef {import("../util/SortableSet")<T>} SortableSet
  */
 
 /**
+ * Returns value of the property.
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {Module} module the module
  * @param {ExportInfoName[] | null} exportName_ name of the export if any
@@ -89,6 +91,7 @@ const getProperty = (moduleGraph, module, exportName_, property, runtime) => {
 
 class ExportsInfoDependency extends NullDependency {
 	/**
+	 * Creates an instance of ExportsInfoDependency.
 	 * @param {Range} range range
 	 * @param {ExportInfoName[] | null} exportName export name
 	 * @param {string | null} property property
@@ -96,32 +99,34 @@ class ExportsInfoDependency extends NullDependency {
 	constructor(range, exportName, property) {
 		super();
 		this.range = range;
+		/** @type {string[] | null} */
 		this.exportName = exportName;
+		/** @type {string | null} */
 		this.property = property;
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.exportName);
-		write(this.property);
+		context.write(this.range).write(this.exportName).write(this.property);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 * @returns {ExportsInfoDependency} ExportsInfoDependency
 	 */
 	static deserialize(context) {
-		const obj = new ExportsInfoDependency(
-			context.read(),
-			context.read(),
-			context.read()
-		);
-		obj.deserialize(context);
+		const range = context.read();
+		const c1 = context.rest;
+		const exportName = c1.read();
+		const c2 = c1.rest;
+		const property = c2.read();
+		const obj = new ExportsInfoDependency(range, exportName, property);
+		obj.deserialize(c2.rest);
 		return obj;
 	}
 }
@@ -135,6 +140,7 @@ ExportsInfoDependency.Template = class ExportsInfoDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object

package/lib/dependencies/ExternalModuleDependency.js

@@ -14,11 +14,12 @@ const ExternalModuleInitFragment = require("./ExternalModuleInitFragment");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../dependencies/ExternalModuleInitFragment").ArrayImportSpecifiers} ArrayImportSpecifiers */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<(string | ArrayImportSpecifiers | undefined)[]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<(string | ArrayImportSpecifiers | undefined)[]>} ObjectSerializerContext */
 
 class ExternalModuleDependency extends CachedConstDependency {
 	/**
+	 * Creates an instance of ExternalModuleDependency.
 	 * @param {string} module module
 	 * @param {ArrayImportSpecifiers} importSpecifiers import specifiers
 	 * @param {string | undefined} defaultImport default import
@@ -38,12 +39,16 @@ class ExternalModuleDependency extends CachedConstDependency {
 	) {
 		super(expression, range, identifier, place);
 
+		/** @type {string} */
 		this.importedModule = module;
+		/** @type {ArrayImportSpecifiers} */
 		this.specifiers = importSpecifiers;
+		/** @type {string | undefined} */
 		this.default = defaultImport;
 	}
 
 	/**
+	 * Create hash update.
 	 * @returns {string} hash update
 	 */
 	_createHashUpdate() {
@@ -53,6 +58,7 @@ class ExternalModuleDependency extends CachedConstDependency {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
@@ -64,14 +70,15 @@ class ExternalModuleDependency extends CachedConstDependency {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
 		super.deserialize(context);
 		const { read } = context;
-		this.importedModule = read();
-		this.specifiers = read();
-		this.default = read();
+		this.importedModule = /** @type {string} */ (read());
+		this.specifiers = /** @type {ArrayImportSpecifiers} */ (read());
+		this.default = /** @type {string | undefined} */ (read());
 	}
 }
 
@@ -84,6 +91,7 @@ ExternalModuleDependency.Template = class ExternalModuleDependencyTemplate exten
 	CachedConstDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object

package/lib/dependencies/ExternalModuleInitFragment.js

@@ -10,11 +10,11 @@ const makeSerializable = require("../util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {{ name: string, value?: string }[]} ArrayImportSpecifiers */
 /** @typedef {Set<string>} ImportSpecifier */
 /** @typedef {Map<string, ImportSpecifier>} ImportSpecifiers */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<(string | ArrayImportSpecifiers | ImportSpecifiers | undefined)[]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<(string | ArrayImportSpecifiers | ImportSpecifiers | undefined)[]>} ObjectSerializerContext */
 
 /**
  * @extends {InitFragment<GenerateContext>}
@@ -32,6 +32,7 @@ class ExternalModuleInitFragment extends InitFragment {
 			0,
 			`external module imports|${importedModule}|${defaultImport || "null"}`
 		);
+		/** @type {string} */
 		this.importedModule = importedModule;
 		if (Array.isArray(specifiers)) {
 			/** @type {ImportSpecifiers} */
@@ -48,6 +49,7 @@ class ExternalModuleInitFragment extends InitFragment {
 		} else {
 			this.specifiers = specifiers;
 		}
+		/** @type {string | undefined} */
 		this.defaultImport = defaultImport;
 	}
 
@@ -75,6 +77,7 @@ class ExternalModuleInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Returns the source code that will be included as initialization code.
 	 * @param {GenerateContext} context context
 	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
@@ -107,6 +110,7 @@ class ExternalModuleInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
@@ -118,14 +122,15 @@ class ExternalModuleInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
 		super.deserialize(context);
 		const { read } = context;
-		this.importedModule = read();
-		this.specifiers = read();
-		this.defaultImport = read();
+		this.importedModule = /** @type {string} */ (read());
+		this.specifiers = /** @type {ImportSpecifiers} */ (read());
+		this.defaultImport = /** @type {string | undefined} */ (read());
 	}
 }
 

package/lib/dependencies/ExternalModuleInitFragmentDependency.js

@@ -15,52 +15,59 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../dependencies/ExternalModuleInitFragment").ArrayImportSpecifiers} ArrayImportSpecifiers */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, ArrayImportSpecifiers, string | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, ArrayImportSpecifiers, string | undefined]>} ObjectSerializerContext */
 
 class ExternalModuleInitFragmentDependency extends NullDependency {
 	/**
+	 * Creates an instance of ExternalModuleInitFragmentDependency.
 	 * @param {string} module module
 	 * @param {ArrayImportSpecifiers} importSpecifiers import specifiers
 	 * @param {string | undefined} defaultImport default import
 	 */
 	constructor(module, importSpecifiers, defaultImport) {
 		super();
+		/** @type {string} */
 		this.importedModule = module;
+		/** @type {ArrayImportSpecifiers} */
 		this.specifiers = importSpecifiers;
+		/** @type {string | undefined} */
 		this.default = defaultImport;
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.importedModule);
-		write(this.specifiers);
-		write(this.default);
+		context
+			.write(this.importedModule)
+			.write(this.specifiers)
+			.write(this.default);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.importedModule = read();
-		this.specifiers = read();
-		this.default = read();
+		this.importedModule = context.read();
+		const c1 = context.rest;
+		this.specifiers = c1.read();
+		this.default = c1.rest.read();
 	}
 }
 
 makeSerializable(
 	ExternalModuleInitFragmentDependency,
-	"webpack/lib/dependencies/ExternalModuleConstDependency"
+	"webpack/lib/dependencies/ExternalModuleInitFragmentDependency"
 );
 
-ExternalModuleInitFragmentDependency.Template = class ExternalModuleConstDependencyTemplate extends (
+ExternalModuleInitFragmentDependency.Template = class ExternalModuleInitFragmentDependencyTemplate extends (
 	DependencyTemplate
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -16,14 +16,13 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").ModuleId} ModuleId */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, HarmonyAcceptImportDependency[], boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, HarmonyAcceptImportDependency[], boolean]>} ObjectSerializerContext */
 
 class HarmonyAcceptDependency extends NullDependency {
 	/**
+	 * Creates an instance of HarmonyAcceptDependency.
 	 * @param {Range} range expression range
 	 * @param {HarmonyAcceptImportDependency[]} dependencies import dependencies
 	 * @param {boolean} hasCallback true, if the range wraps an existing callback
@@ -31,7 +30,9 @@ class HarmonyAcceptDependency extends NullDependency {
 	constructor(range, dependencies, hasCallback) {
 		super();
 		this.range = range;
+		/** @type {HarmonyAcceptImportDependency[]} */
 		this.dependencies = dependencies;
+		/** @type {boolean} */
 		this.hasCallback = hasCallback;
 	}
 
@@ -40,25 +41,25 @@ class HarmonyAcceptDependency extends NullDependency {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.dependencies);
-		write(this.hasCallback);
+		context.write(this.range).write(this.dependencies).write(this.hasCallback);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.dependencies = read();
-		this.hasCallback = read();
-		super.deserialize(context);
+		this.range = context.read();
+		const c1 = context.rest;
+		this.dependencies = c1.read();
+		const c2 = c1.rest;
+		this.hasCallback = c2.read();
+		super.deserialize(c2.rest);
 	}
 }
 
@@ -71,6 +72,7 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 	NullDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object
@@ -88,23 +90,19 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 		} = templateContext;
 
 		/**
-		 * @param {Dependency} dependency the dependency to get module id for
-		 * @returns {ModuleId | null} the module id or null if not found
-		 */
-		const getDependencyModuleId = (dependency) =>
-			chunkGraph.getModuleId(
-				/** @type {Module} */ (moduleGraph.getModule(dependency))
-			);
-
-		/**
+		 * Checks whether this harmony accept dependency is related harmony import dependency.
 		 * @param {Dependency} a the first dependency
 		 * @param {Dependency} b the second dependency
 		 * @returns {boolean} true if the dependencies are related
 		 */
-		const isRelatedHarmonyImportDependency = (a, b) =>
-			a !== b &&
-			b instanceof HarmonyImportDependency &&
-			getDependencyModuleId(a) === getDependencyModuleId(b);
+		const isRelatedHarmonyImportDependency = (a, b) => {
+			if (a === b || !(b instanceof HarmonyImportDependency)) return false;
+			// Compare modules by reference: an unresolved import (ignored/failed, or a
+			// deferred lazy-barrel re-export) has no module, and a module not in any
+			// chunk has a null id — so comparing ids would crash or miss real matches.
+			const moduleA = moduleGraph.getModule(a);
+			return moduleA !== null && moduleA === moduleGraph.getModule(b);
+		};
 
 		/**
 		 * HarmonyAcceptImportDependency lacks a lot of information, such as the defer property.

package/lib/dependencies/HarmonyAcceptImportDependency.js

@@ -12,10 +12,12 @@ const NullDependency = require("./NullDependency");
 
 class HarmonyAcceptImportDependency extends HarmonyImportDependency {
 	/**
+	 * Creates an instance of HarmonyAcceptImportDependency.
 	 * @param {string} request the request string
 	 */
 	constructor(request) {
 		super(request, Infinity, ImportPhase.Evaluation);
+		/** @type {boolean} */
 		this.weak = true;
 	}
 

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");
 
@@ -31,6 +32,7 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 	NullDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object
@@ -70,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});`
+					)
+				);
+			}
 		}
 	}
 };