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

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -34,41 +34,53 @@ const HarmonyLinkingError = require("./HarmonyLinkingError");
 const { ImportPhaseUtils } = require("./ImportPhase");
 const processExportInfo = require("./processExportInfo");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
-/** @typedef {import("../Dependency").LazyUntil} LazyUntil */
-/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ExportsInfo")} ExportsInfo */
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
-/** @typedef {import("../ExportsInfo").UsedName} UsedName */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("../Module").ExportsType} ExportsType */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
-/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/**
+ * @import {
+ * 	ExportsSpec,
+ * 	GetConditionFn,
+ * 	LazyUntil,
+ * 	RawReferencedExports,
+ * 	ReferencedExports,
+ * 	TRANSITIVE,
+ * 	ExportInfoName
+ * } from "../Dependency"
+ */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import ExportsInfo, { ExportInfo, UsedName } from "../ExportsInfo" */
+/** @import { GenerateContext } from "../Generator" */
+/**
+ * @import Module, {
+ * 	BuildMeta,
+ * 	RuntimeRequirements,
+ * 	ExportsType
+ * } from "../Module"
+ */
+/** @import ModuleGraph from "../ModuleGraph" */
+/**
+ * @import ModuleGraphConnection, {
+ * 	ConnectionState
+ * } from "../ModuleGraphConnection"
+ */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import WebpackError from "../errors/WebpackError" */
+/** @import { ImportAttributes } from "../javascript/JavascriptParser" */
 /** @typedef {[Ids, string | null, Set<string>, ReadonlyArray<HarmonyExportImportedSpecifierDependency> | null, ExportPresenceMode, HarmonyStarExportsList | null]} SerializedData */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<SerializedData>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<SerializedData>} ObjectSerializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[HarmonyExportImportedSpecifierDependency[]]>} StarListDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[HarmonyExportImportedSpecifierDependency[]]>} StarListSerializerContext */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./HarmonyImportDependency").Ids} Ids */
-/** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
-/** @typedef {import("./HarmonyExportInitFragment").ExportMap} ExportMap */
-/** @typedef {import("../dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
-/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import { Ids, ExportPresenceMode } from "./HarmonyImportDependency" */
+/** @import { ExportMap } from "./HarmonyExportInitFragment" */
+/** @import { ImportPhaseType } from "../dependencies/ImportPhase" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildMeta
+ * } from "../javascript/JavascriptModule"
+ */
+/** @import ConcatenationScope from "../ConcatenationScope" */
 
 /** @typedef {"missing" | "unused" | "empty-star" | "reexport-dynamic-default" | "reexport-named-default" | "reexport-namespace-object" | "reexport-fake-namespace-object" | "reexport-undefined" | "normal-reexport" | "dynamic-reexport"} ExportModeType */
 
@@ -83,7 +95,7 @@ class NormalReexportItem {
 	 * Creates an instance of NormalReexportItem.
 	 * @param {string} name export name
 	 * @param {Ids} ids reexported ids from other module
-	 * @param {ExportInfo} exportInfo export info from other module
+	 * @param {InstanceType<ExportInfo>} exportInfo export info from other module
 	 * @param {boolean} checked true, if it should be checked at runtime if this export exists
 	 * @param {boolean} hidden true, if it is hidden behind another active export in the same module
 	 */
@@ -92,7 +104,7 @@ class NormalReexportItem {
 		this.name = name;
 		/** @type {Ids} */
 		this.ids = ids;
-		/** @type {ExportInfo} */
+		/** @type {InstanceType<ExportInfo>} */
 		this.exportInfo = exportInfo;
 		/** @type {boolean} */
 		this.checked = checked;
@@ -120,9 +132,14 @@ class ExportMode {
 		// for "reexport-named-default" | "reexport-fake-namespace-object" | "reexport-namespace-object"
 		/** @type {string | null} */
 		this.name = null;
-		/** @type {ExportInfo | null} */
+		/** @type {InstanceType<ExportInfo> | null} */
 		this.partialNamespaceExportInfo = null;
 
+		// for "reexport-undefined": the name resolves through a circular
+		// reexport chain rather than being absent from a non-harmony module
+		/** @type {boolean} */
+		this.circular = false;
+
 		// for "dynamic-reexport":
 		/** @type {ExportModeIgnored | null} */
 		this.ignored = null;
@@ -163,7 +180,7 @@ const RETURNS_TRUE = () => true;
  * unrelated cycles in the graph that would otherwise loop forever inside
  * `_findTarget`.
  * @param {ModuleGraph} moduleGraph the module graph
- * @param {ExportInfo} exportInfo export info on the imported module
+ * @param {InstanceType<ExportInfo>} exportInfo export info on the imported module
  * @param {Module} parentModule the module that contains the star reexport
  * @returns {boolean} true when this export reexports back to the parent module under the same name
  */
@@ -194,7 +211,7 @@ const isStarReexportBackToParent = (moduleGraph, exportInfo, parentModule) => {
 	// Allocated lazily: a single-extra-hop chain that terminates (the common
 	// `barrel -> leaf local binding` case) returns before `next` is ever
 	// computed, so the visited set is pure waste there.
-	/** @type {Set<ExportInfo> | undefined} */
+	/** @type {Set<InstanceType<ExportInfo>> | undefined} */
 	let visited;
 	for (;;) {
 		const target = current.findTarget(moduleGraph, RETURNS_TRUE);
@@ -220,12 +237,28 @@ const isStarReexportBackToParent = (moduleGraph, exportInfo, parentModule) => {
 	}
 };
 
+/**
+ * Two `export *` sources are ambiguous for a name when they resolve to
+ * different bindings; a diamond re-export of the same binding is not.
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {InstanceType<ExportInfo>} previous export info of the star source that first provided the name
+ * @param {InstanceType<ExportInfo>} exportInfo export info of a later star source providing the same name
+ * @returns {boolean} true when the two sources provide different bindings
+ */
+const isAmbiguousWith = (moduleGraph, previous, exportInfo) => {
+	const previousBinding = previous.getTerminalBinding(moduleGraph);
+	if (!previousBinding) return false;
+	const binding = exportInfo.getTerminalBinding(moduleGraph);
+	if (!binding) return false;
+	return previousBinding !== binding;
+};
+
 /**
  * Determine export assignments.
  * @param {ModuleGraph} moduleGraph module graph
  * @param {HarmonyExportImportedSpecifierDependency[]} dependencies dependencies
  * @param {HarmonyExportImportedSpecifierDependency=} additionalDependency additional dependency
- * @returns {{ names: ExportInfoName[], dependencyIndices: DependencyIndices }} result
+ * @returns {{ names: ExportInfoName[], dependencyIndices: DependencyIndices, conflicting: Set<ExportInfoName> | undefined }} result
  */
 const determineExportAssignments = (
 	moduleGraph,
@@ -236,6 +269,10 @@ const determineExportAssignments = (
 	const names = new Set();
 	/** @type {DependencyIndices} */
 	const dependencyIndices = [];
+	/** @type {Map<ExportInfoName, InstanceType<ExportInfo>>} */
+	const firstProvider = new Map();
+	/** @type {Set<ExportInfoName> | undefined} */
+	let conflicting;
 
 	if (additionalDependency) {
 		dependencies = [...dependencies, additionalDependency];
@@ -253,24 +290,42 @@ const determineExportAssignments = (
 		if (otherImportedModule) {
 			const exportsInfo = moduleGraph.getExportsInfo(otherImportedModule);
 			for (const exportInfo of exportsInfo.exports) {
+				if (exportInfo.provided !== true || exportInfo.name === "default") {
+					continue;
+				}
+				if (names.has(exportInfo.name)) {
+					const previous =
+						/** @type {InstanceType<ExportInfo>} */
+						(firstProvider.get(exportInfo.name));
+					if (
+						isAmbiguousWith(moduleGraph, previous, exportInfo) &&
+						// A cyclic contribution resolves to nothing, so it never competes
+						// with the binding a sibling `export *` provides.
+						!(
+							parentModule &&
+							isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
+						)
+					) {
+						if (conflicting === undefined) conflicting = new Set();
+						conflicting.add(exportInfo.name);
+					}
+					continue;
+				}
 				if (
-					exportInfo.provided === true &&
-					exportInfo.name !== "default" &&
-					!names.has(exportInfo.name) &&
-					!(
-						parentModule &&
-						isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
-					)
+					parentModule &&
+					isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
 				) {
-					names.add(exportInfo.name);
-					dependencyIndices[i] = names.size;
+					continue;
 				}
+				names.add(exportInfo.name);
+				firstProvider.set(exportInfo.name, exportInfo);
+				dependencyIndices[i] = names.size;
 			}
 		}
 	}
 	dependencyIndices.push(names.size);
 
-	return { names: [...names], dependencyIndices };
+	return { names: [...names], dependencyIndices, conflicting };
 };
 
 /**
@@ -384,6 +439,14 @@ const getMode = (moduleGraph, dep, runtimeKey) => {
 					mode.name = name;
 					break;
 				default:
+					// forwarding to a circular chain would recurse until the stack
+					// blows, so the name resolves to undefined like a missing one
+					if (exportInfo.hasCircularTarget(moduleGraph)) {
+						mode = new ExportMode("reexport-undefined");
+						mode.name = name;
+						mode.circular = true;
+						break;
+					}
 					mode = new ExportMode("normal-reexport");
 					mode.items = [
 						new NormalReexportItem(name, ids, exportInfo, false, false)
@@ -641,6 +704,12 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		/** @type {IgnoredExports} */
 		const ignoredExports = new Set(this.activeExports);
 		ignoredExports.add("default");
+		// An ambiguous name resolves to no binding at all, so no `export *` in this
+		// module may contribute it — not even the first one.
+		const conflicting = this._getConflictingStarExportNames(moduleGraph);
+		if (conflicting !== undefined) {
+			for (const name of conflicting) ignoredExports.add(name);
+		}
 
 		/** @type {Hidden | undefined} */
 		let hiddenExports;
@@ -798,7 +867,9 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 					runtime,
 					referencedExports,
 					[],
-					/** @type {ExportInfo} */ (mode.partialNamespaceExportInfo)
+					/** @type {InstanceType<ExportInfo>} */ (
+						mode.partialNamespaceExportInfo
+					)
 				);
 				return referencedExports;
 			}
@@ -814,7 +885,9 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 					runtime,
 					referencedExports,
 					[],
-					/** @type {ExportInfo} */ (mode.partialNamespaceExportInfo),
+					/** @type {InstanceType<ExportInfo>} */ (
+						mode.partialNamespaceExportInfo
+					),
 					mode.type === "reexport-fake-namespace-object"
 				);
 				return referencedExports;
@@ -842,6 +915,21 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		}
 	}
 
+	/**
+	 * Names this module's `export *` sources provide with conflicting bindings.
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {Set<ExportInfoName> | undefined} ambiguous names, or nothing when there are none
+	 */
+	_getConflictingStarExportNames(moduleGraph) {
+		// Every `export *` carries the module's full star list; a lone one has
+		// nothing to be ambiguous with, so skip the walk.
+		if (!this.allStarExports) return;
+		const { dependencies } = this.allStarExports;
+		if (dependencies.length < 2) return;
+		return moduleGraph.cached(determineExportAssignments, dependencies)
+			.conflicting;
+	}
+
 	/**
 	 * Discover active exports from other star exports.
 	 * @param {ModuleGraph} moduleGraph the module graph
@@ -1043,10 +1131,54 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 */
 	getWarnings(moduleGraph) {
 		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		const circular =
+			this._getCircularReexportPresenceLevel() === ExportPresenceModes.WARN
+				? this._getCircularReexportErrors(moduleGraph)
+				: undefined;
 		if (exportsPresence === ExportPresenceModes.WARN) {
-			return this._getErrors(moduleGraph);
+			const errors = this._getErrors(moduleGraph);
+			if (!circular) return errors;
+			return errors ? [...errors, ...circular] : circular;
 		}
-		return null;
+		return circular;
+	}
+
+	/**
+	 * Reporting level for a circular reexport chain. It skips the promotion to
+	 * an error that AUTO gives a strict harmony module — a cycle warns by
+	 * default — but an explicit setting still says whether and how to report.
+	 * @returns {ExportPresenceMode} effective mode
+	 */
+	_getCircularReexportPresenceLevel() {
+		return this.exportPresenceMode === ExportPresenceModes.AUTO
+			? ExportPresenceModes.WARN
+			: this.exportPresenceMode;
+	}
+
+	/**
+	 * Returns errors for a name resolving through a circular reexport chain.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	_getCircularReexportErrors(moduleGraph) {
+		const ids = this.getIds(moduleGraph);
+		if (ids.length === 0 || !this.name) return;
+		const parentModule = /** @type {Module} */ (
+			moduleGraph.getParentModule(this)
+		);
+		const exportInfo = moduleGraph
+			.getExportsInfo(parentModule)
+			.getReadOnlyExportInfo(this.name);
+		if (!exportInfo.hasCircularTarget(moduleGraph)) return;
+		return [
+			new HarmonyLinkingError(
+				`export '${ids.join(".")}' (reexported as '${
+					this.name
+				}') is part of a circular reexport chain in '${
+					this.userRequest
+				}' and is undefined`
+			)
+		];
 	}
 
 	/**
@@ -1056,10 +1188,18 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 */
 	getErrors(moduleGraph) {
 		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.ERROR) {
-			return this._getErrors(moduleGraph);
+		const errors =
+			exportsPresence === ExportPresenceModes.ERROR
+				? this._getErrors(moduleGraph)
+				: null;
+		if (
+			this._getCircularReexportPresenceLevel() !== ExportPresenceModes.ERROR
+		) {
+			return errors;
 		}
-		return null;
+		const circular = this._getCircularReexportErrors(moduleGraph);
+		if (!circular) return errors;
+		return errors ? [...errors, ...circular] : circular;
 	}
 
 	/**
@@ -1212,7 +1352,8 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 
 		const mode = dep.getMode(moduleGraph, runtime);
 
-		if (concatenationScope) {
+		// a wrapped module has no shared-scope symbols to redirect reexports to
+		if (concatenationScope && !concatenationScope.isWrapped()) {
 			switch (mode.type) {
 				case "reexport-undefined":
 					concatenationScope.registerRawExport(
@@ -1224,7 +1365,15 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 		}
 
 		if (mode.type !== "unused" && mode.type !== "empty-star") {
-			super.apply(dependency, source, templateContext);
+			const importedModule = moduleGraph.getModule(dep);
+			// an in-scope target has no standalone module left to import from
+			if (
+				concatenationScope === undefined ||
+				importedModule === null ||
+				!concatenationScope.isModuleInScope(importedModule)
+			) {
+				super.apply(dependency, source, templateContext);
+			}
 
 			this._addExportFragments(
 				templateContext.initFragments,
@@ -1235,7 +1384,8 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				templateContext.chunkGraph,
 				runtime,
 				templateContext.runtimeTemplate,
-				templateContext.runtimeRequirements
+				templateContext.runtimeRequirements,
+				concatenationScope
 			);
 		}
 	}
@@ -1251,6 +1401,7 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
 	 * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+	 * @param {ConcatenationScope=} concatenationScope concatenation scope of a wrapped module
 	 * @returns {void}
 	 */
 	_addExportFragments(
@@ -1262,10 +1413,28 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 		chunkGraph,
 		runtime,
 		runtimeTemplate,
-		runtimeRequirements
+		runtimeRequirements,
+		concatenationScope
 	) {
 		const importedModule = /** @type {Module} */ (moduleGraph.getModule(dep));
-		const importVar = dep.getImportVar(moduleGraph);
+		// an in-scope target has no import statement, read it through a reference
+		const inScope =
+			concatenationScope !== undefined &&
+			concatenationScope.isModuleInScope(importedModule);
+		const importVar = inScope
+			? /** @type {ConcatenationScope} */ (
+					concatenationScope
+				).createModuleReference(importedModule, { asiSafe: true })
+			: dep.getImportVar(moduleGraph);
+		// whole-namespace modes need the original export names, not mangled ones
+		const namespaceImportVar = inScope
+			? /** @type {ConcatenationScope} */ (
+					concatenationScope
+				).createModuleReference(importedModule, {
+					asiSafe: true,
+					mangleableNamespace: true
+				})
+			: importVar;
 		const isDeferred =
 			ImportPhaseUtils.isDefer(dep.phase) &&
 			!(/** @type {BuildMeta} */ (importedModule.buildMeta).async);
@@ -1282,7 +1451,7 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 					moduleGraph
 						.getExportsInfo(module)
 						.getUsedName(mode.name ? mode.name : [], runtime),
-					importVar,
+					namespaceImportVar,
 					importedModule.getExportsType(
 						moduleGraph,
 						module.buildMeta &&
@@ -1318,7 +1487,18 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				);
 				break;
 
-			case "reexport-dynamic-default":
+			case "reexport-dynamic-default": {
+				// `${importVar}_default` names the interop variable that the import
+				// statement declares. An in-scope target has no import statement, so
+				// reference its default export and let the concatenation resolve it.
+				const defaultAccess = inScope
+					? /** @type {ConcatenationScope} */ (
+							concatenationScope
+						).createModuleReference(importedModule, {
+							ids: ["default"],
+							asiSafe: true
+						})
+					: importVar;
 				initFragments.push(
 					this.getReexportFragment(
 						module,
@@ -1326,32 +1506,56 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 						moduleGraph
 							.getExportsInfo(module)
 							.getUsedName(/** @type {string} */ (mode.name), runtime),
-						importVar,
-						null,
+						defaultAccess,
+						inScope ? "" : null,
 						runtimeRequirements
 					)
 				);
 				break;
+			}
 
 			case "reexport-fake-namespace-object":
-				initFragments.push(
-					...this.getReexportFakeNamespaceObjectFragments(
-						module,
-						moduleGraph
-							.getExportsInfo(module)
-							.getUsedName(/** @type {string} */ (mode.name), runtime),
-						importVar,
-						mode.fakeType,
-						runtimeRequirements
-					)
-				);
+				// `${name}_namespace_cache` needs an identifier to suffix, but an
+				// in-scope target is an expression. The concatenation already builds
+				// the same object, memoized: its interop namespace picks the mode from
+				// the exports type, which is what `fakeType` mirrors.
+				if (inScope) {
+					initFragments.push(
+						this.getReexportFragment(
+							module,
+							"reexport fake namespace object from non-harmony",
+							moduleGraph
+								.getExportsInfo(module)
+								.getUsedName(/** @type {string} */ (mode.name), runtime),
+							/** @type {ConcatenationScope} */ (
+								concatenationScope
+							).createModuleReference(importedModule, { asiSafe: true }),
+							"",
+							runtimeRequirements
+						)
+					);
+				} else {
+					initFragments.push(
+						...this.getReexportFakeNamespaceObjectFragments(
+							module,
+							moduleGraph
+								.getExportsInfo(module)
+								.getUsedName(/** @type {string} */ (mode.name), runtime),
+							namespaceImportVar,
+							mode.fakeType,
+							runtimeRequirements
+						)
+					);
+				}
 				break;
 
 			case "reexport-undefined":
 				initFragments.push(
 					this.getReexportFragment(
 						module,
-						"reexport non-default export from non-harmony",
+						mode.circular
+							? "reexport circular"
+							: "reexport non-default export from non-harmony",
 						moduleGraph
 							.getExportsInfo(module)
 							.getUsedName(/** @type {string} */ (mode.name), runtime),
@@ -1385,7 +1589,7 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 						moduleGraph
 							.getExportsInfo(module)
 							.getUsedName(/** @type {string} */ (mode.name), runtime),
-						importVar,
+						namespaceImportVar,
 						"",
 						runtimeRequirements
 					)
@@ -1456,7 +1660,7 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 					: /** @type {ExportModeIgnored} */ (mode.ignored);
 				let content =
 					"/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};\n" +
-					`/* harmony reexport (unknown) */ for(${runtimeTemplate.renderConst()} __WEBPACK_IMPORT_KEY__ in ${importVar}) `;
+					`/* harmony reexport (unknown) */ for(${runtimeTemplate.renderConst()} __WEBPACK_IMPORT_KEY__ in ${namespaceImportVar}) `;
 
 				// Filter out exports which are defined by other exports
 				// and filter out default export because it cannot be reexported with *
@@ -1474,8 +1678,8 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				content +=
 					runtimeTemplate.supportsArrowFunction() &&
 					runtimeTemplate.supportsConst()
-						? `() => ${importVar}[__WEBPACK_IMPORT_KEY__]`
-						: `function(key) { return ${importVar}[key]; }.bind(0, __WEBPACK_IMPORT_KEY__)`;
+						? `() => ${namespaceImportVar}[__WEBPACK_IMPORT_KEY__]`
+						: `function(key) { return ${namespaceImportVar}[key]; }.bind(0, __WEBPACK_IMPORT_KEY__)`;
 
 				runtimeRequirements.add(RuntimeGlobals.exports);
 				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
@@ -1723,6 +1927,8 @@ makeSerializable(
 	"HarmonyStarExportsList"
 );
 
+HarmonyExportImportedSpecifierDependency.HarmonyStarExportsList =
+	HarmonyStarExportsList;
+HarmonyExportImportedSpecifierDependency.idsSymbol = idsSymbol;
+
 module.exports = HarmonyExportImportedSpecifierDependency;
-module.exports.HarmonyStarExportsList = HarmonyStarExportsList;
-module.exports.idsSymbol = idsSymbol;

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -10,9 +10,9 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const { first } = require("../util/SetHelpers");
 const { propertyName } = require("../util/property");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../ExportsInfo").UsedName} UsedName */
+/** @import { Source } from "webpack-sources" */
+/** @import { GenerateContext } from "../Generator" */
+/** @import { UsedName } from "../ExportsInfo" */
 
 /**
  * Join iterable with comma.
@@ -37,6 +37,7 @@ const joinIterableWithComma = (iterable) => {
 
 /** @typedef {Map<UsedName, string>} ExportMap */
 /** @typedef {Set<string>} UnusedExports */
+/** @import { OnDemandGeneration } from "./ExportBindingInitFragment" */
 
 /** @type {ExportMap} */
 const EMPTY_MAP = new Map();
@@ -53,11 +54,13 @@ class HarmonyExportInitFragment extends InitFragment {
 	 * @param {string} exportsArgument the exports identifier
 	 * @param {ExportMap} exportMap mapping from used name to exposed variable name
 	 * @param {UnusedExports} unusedExports list of unused export names
+	 * @param {OnDemandGeneration=} onDemand offered the call instead of emitting it
 	 */
 	constructor(
 		exportsArgument,
 		exportMap = EMPTY_MAP,
-		unusedExports = EMPTY_SET
+		unusedExports = EMPTY_SET,
+		onDemand = undefined
 	) {
 		super(undefined, InitFragment.STAGE_HARMONY_EXPORTS, 1, "harmony-exports");
 		/** @type {string} */
@@ -66,6 +69,8 @@ class HarmonyExportInitFragment extends InitFragment {
 		this.exportMap = exportMap;
 		/** @type {UnusedExports} */
 		this.unusedExports = unusedExports;
+		/** @type {OnDemandGeneration | undefined} */
+		this.onDemand = onDemand;
 	}
 
 	/**
@@ -114,7 +119,8 @@ class HarmonyExportInitFragment extends InitFragment {
 		return new HarmonyExportInitFragment(
 			this.exportsArgument,
 			exportMap,
-			unusedExports
+			unusedExports,
+			this.onDemand
 		);
 	}
 
@@ -151,7 +157,8 @@ class HarmonyExportInitFragment extends InitFragment {
 		return new HarmonyExportInitFragment(
 			this.exportsArgument,
 			exportMap,
-			unusedExports
+			unusedExports,
+			this.onDemand || other.onDemand
 		);
 	}
 
@@ -184,6 +191,8 @@ class HarmonyExportInitFragment extends InitFragment {
 					)}: ${runtimeTemplate.returningFunction(value)}`
 				);
 			}
+			// Requested even when the call is taken over below: whoever took it may still
+			// emit it, and by then the requirement set is closed.
 			runtimeRequirements.add(RuntimeGlobals.exports);
 			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 			definePart = `/* harmony export */ ${
@@ -191,6 +200,9 @@ class HarmonyExportInitFragment extends InitFragment {
 			}(${this.exportsArgument}, {${definitions.join(
 				","
 			)}\n/* harmony export */ });\n`;
+			if (this.onDemand !== undefined && this.onDemand(definePart, false)) {
+				definePart = "";
+			}
 		}
 		return `${definePart}${unusedPart}`;
 	}