@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -14,9 +14,11 @@ const Template = require("../Template");
 const {
 	InlinedUsedName,
 	isExportInlined,
-	isInlineEnabled
+	isInlineEnabled,
+	isInlineExportsEnabled
 } = require("../optimize/InlineExports");
 const {
+	getKnownExportNames,
 	getMakeDeferredNamespaceModeFromExportsType
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
 const { countIterable } = require("../util/IterableHelpers");
@@ -29,6 +31,9 @@ const {
 	keyToRuntime
 } = require("../util/runtime");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
+
+const { ExportBindingType } = HarmonyExportInitFragment;
+
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 const HarmonyLinkingError = require("./HarmonyLinkingError");
 const { ImportPhaseUtils } = require("./ImportPhase");
@@ -44,7 +49,8 @@ const processExportInfo = require("./processExportInfo");
  * 	RawReferencedExports,
  * 	ReferencedExports,
  * 	TRANSITIVE,
- * 	ExportInfoName
+ * 	ExportInfoName,
+ * 	UpdateHashContext
  * } from "../Dependency"
  */
 /** @import { DependencyTemplateContext } from "../DependencyTemplate" */
@@ -58,6 +64,7 @@ const processExportInfo = require("./processExportInfo");
  * } from "../Module"
  */
 /** @import ModuleGraph from "../ModuleGraph" */
+/** @import Hash from "../util/Hash" */
 /**
  * @import ModuleGraphConnection, {
  * 	ConnectionState
@@ -135,6 +142,11 @@ class ExportMode {
 		/** @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;
@@ -232,12 +244,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,
@@ -248,6 +276,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];
@@ -265,24 +297,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 };
 };
 
 /**
@@ -396,6 +446,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)
@@ -653,6 +711,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;
@@ -772,6 +836,31 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		};
 	}
 
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const { chunkGraph, runtime } = context;
+		const moduleGraph = chunkGraph.moduleGraph;
+		if (!isInlineExportsEnabled(moduleGraph)) return;
+		const module = moduleGraph.getModule(this);
+		if (!module || !isInlineEnabled(module)) return;
+		const mode = this.getMode(moduleGraph, runtime);
+		if (mode.type !== "normal-reexport") return;
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		for (const item of /** @type {NormalReexportItem[]} */ (mode.items)) {
+			if (item.hidden || item.checked) continue;
+			const usedName = exportsInfo.getUsedName(item.ids, runtime);
+			if (usedName instanceof InlinedUsedName) {
+				hash.update(`${item.name}:${item.ids.join(".")}:`);
+				usedName.updateHash(hash);
+			}
+		}
+	}
+
 	/**
 	 * Gets module evaluation side effects state.
 	 * @param {ModuleGraph} moduleGraph the module graph
@@ -858,6 +947,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
@@ -1059,10 +1163,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`
+			)
+		];
 	}
 
 	/**
@@ -1072,10 +1220,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;
 	}
 
 	/**
@@ -1391,10 +1547,9 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 			}
 
 			case "reexport-fake-namespace-object":
-				// `${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.
+				// `${name}_namespace_cache` needs an identifier to suffix, and an in-scope
+				// target is an expression. The concatenation already memoizes the same
+				// object, its interop namespace taking the mode `fakeType` mirrors.
 				if (inScope) {
 					initFragments.push(
 						this.getReexportFragment(
@@ -1429,7 +1584,9 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				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),
@@ -1455,7 +1612,19 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				);
 				break;
 
-			case "reexport-namespace-object":
+			case "reexport-namespace-object": {
+				let value = namespaceImportVar;
+
+				// The re-exported binding is the namespace itself, so it has to be
+				// the same object every importer of that module is handed.
+				if (
+					importedModule.buildInfo &&
+					importedModule.buildInfo.specNamespaceObject
+				) {
+					runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+					value = `${RuntimeGlobals.specNamespaceObject}(${value})`;
+				}
+
 				initFragments.push(
 					this.getReexportFragment(
 						module,
@@ -1463,12 +1632,13 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 						moduleGraph
 							.getExportsInfo(module)
 							.getUsedName(/** @type {string} */ (mode.name), runtime),
-						namespaceImportVar,
+						value,
 						"",
 						runtimeRequirements
 					)
 				);
 				break;
+			}
 
 			case "normal-reexport": {
 				// loop-invariants hoisted out of the per-item loop below (a barrel
@@ -1603,7 +1773,10 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 
 		/** @type {ExportMap} */
 		const map = new Map();
-		map.set(key, `/* ${comment} */ ${returnValue}`);
+		map.set(key, {
+			value: `/* ${comment} */ ${returnValue}`,
+			type: ExportBindingType.Getter
+		});
 
 		return new HarmonyExportInitFragment(module.exportsArgument, map);
 	}
@@ -1630,12 +1803,12 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 
 		/** @type {ExportMap} */
 		const map = new Map();
-		map.set(
-			key,
-			`/* reexport fake namespace object from non-harmony */ ${name}_namespace_cache || (${name}_namespace_cache = ${
+		map.set(key, {
+			value: `/* reexport fake namespace object from non-harmony */ ${name}_namespace_cache || (${name}_namespace_cache = ${
 				RuntimeGlobals.createFakeNamespaceObject
-			}(${name}${fakeType ? `, ${fakeType}` : ""}))`
-		);
+			}(${name}${fakeType ? `, ${fakeType}` : ""}))`,
+			type: ExportBindingType.Getter
+		});
 
 		return [
 			new InitFragment(
@@ -1674,10 +1847,20 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 		const map = new Map();
 		const moduleId = JSON.stringify(chunkGraph.getModuleId(module));
 		const mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);
-		map.set(
-			key,
-			`/* reexport deferred namespace object */ ${name}_deferred_namespace_cache || (${name}_deferred_namespace_cache = ${RuntimeGlobals.makeDeferredNamespaceObject}(${moduleId}, ${mode}))`
+		const names = getKnownExportNames(
+			chunkGraph.moduleGraph,
+			module,
+			exportsType
+		);
+		runtimeRequirements.add(
+			names
+				? RuntimeGlobals.hasSealedDeferredNamespace
+				: RuntimeGlobals.hasSynthesizedDeferredNamespace
 		);
+		map.set(key, {
+			value: `/* reexport deferred namespace object */ ${name}_deferred_namespace_cache || (${name}_deferred_namespace_cache = ${RuntimeGlobals.makeDeferredNamespaceObject}(${moduleId}, ${mode}${names ? `, ${JSON.stringify(names)}` : ""}))`,
+			type: ExportBindingType.Getter
+		});
 
 		return [
 			new InitFragment(

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -35,9 +35,13 @@ const joinIterableWithComma = (iterable) => {
 	return str;
 };
 
-/** @typedef {Map<UsedName, string>} ExportMap */
+const ExportBindingType = Object.freeze({
+	Getter: 0b00,
+	Value: 0b01
+});
+
+/** @typedef {Map<UsedName, { value: string, type: typeof ExportBindingType.Getter | typeof ExportBindingType.Value }>} ExportMap */
 /** @typedef {Set<string>} UnusedExports */
-/** @import { OnDemandGeneration } from "./ExportBindingInitFragment" */
 
 /** @type {ExportMap} */
 const EMPTY_MAP = new Map();
@@ -54,13 +58,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
+	 * @param {boolean} onDemand leave the call out of the source and hand it over in the code generation data (see `KnownMeta.onDemandExports`)
 	 */
 	constructor(
 		exportsArgument,
 		exportMap = EMPTY_MAP,
 		unusedExports = EMPTY_SET,
-		onDemand = undefined
+		onDemand = false
 	) {
 		super(undefined, InitFragment.STAGE_HARMONY_EXPORTS, 1, "harmony-exports");
 		/** @type {string} */
@@ -69,8 +73,51 @@ class HarmonyExportInitFragment extends InitFragment {
 		this.exportMap = exportMap;
 		/** @type {UnusedExports} */
 		this.unusedExports = unusedExports;
-		/** @type {OnDemandGeneration | undefined} */
+		/** @type {boolean} */
 		this.onDemand = onDemand;
+
+		this._generated = false;
+		this._defsValue = undefined;
+		this._defsGetter = undefined;
+	}
+
+	/**
+	 * Returns the source code that will be included as initialization code.
+	 * @param {GenerateContext} context context
+	 * @returns {void}
+	 */
+	_generate({ runtimeTemplate }) {
+		if (this._generated) return;
+		this._generated = true;
+
+		if (this.exportMap.size > 0) {
+			/** @type {string[]} */
+			const _defsValue = [];
+			const _defsGetter = [];
+			const orderedExportMap =
+				this.exportMap.size > 1
+					? [...this.exportMap].sort(([a], [b]) => (a < b ? -1 : 1))
+					: this.exportMap;
+			for (const [key, { value, type }] of orderedExportMap) {
+				switch (type) {
+					case ExportBindingType.Getter:
+						_defsGetter.push(
+							`\n/* harmony export */   ${propertyName(
+								/** @type {string} */ (key)
+							)}: ${runtimeTemplate.returningFunction(value)}`
+						);
+						break;
+
+					case ExportBindingType.Value:
+						_defsValue.push(
+							`\n/* harmony export */   ${JSON.stringify(key)}, 0, ${value}`
+						);
+				}
+			}
+
+			this._defsGetter = _defsGetter;
+			this._defsValue = _defsValue;
+		}
 	}
 
 	/**
@@ -85,12 +132,15 @@ class HarmonyExportInitFragment extends InitFragment {
 		/** @type {undefined | UnusedExports} */
 		let unusedExports;
 		let unusedExportsOwned = false;
+		/** @type {boolean} */
+		let onDemand = false;
 
 		for (const fragment of fragments) {
 			if (fragment.exportMap.size !== 0) {
 				if (exportMap === undefined) {
 					exportMap = fragment.exportMap;
 					exportMapOwned = false;
+					onDemand = fragment.onDemand;
 				} else {
 					if (!exportMapOwned) {
 						exportMap = new Map(exportMap);
@@ -98,6 +148,7 @@ class HarmonyExportInitFragment extends InitFragment {
 					}
 					for (const [key, value] of fragment.exportMap) {
 						if (!exportMap.has(key)) exportMap.set(key, value);
+						onDemand = onDemand || fragment.onDemand;
 					}
 				}
 			}
@@ -120,7 +171,7 @@ class HarmonyExportInitFragment extends InitFragment {
 			this.exportsArgument,
 			exportMap,
 			unusedExports,
-			this.onDemand
+			onDemand
 		);
 	}
 
@@ -167,7 +218,10 @@ class HarmonyExportInitFragment extends InitFragment {
 	 * @param {GenerateContext} context context
 	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
-	getContent({ runtimeTemplate, runtimeRequirements }) {
+	getContent(context) {
+		this._generate(context);
+
+		const { runtimeRequirements, getData } = context;
 		const unusedPart =
 			this.unusedExports.size > 1
 				? `/* unused harmony exports ${joinIterableWithComma(
@@ -177,35 +231,68 @@ class HarmonyExportInitFragment extends InitFragment {
 					? `/* unused harmony export ${first(this.unusedExports)} */\n`
 					: "";
 		let definePart = "";
-		if (this.exportMap.size > 0) {
-			/** @type {string[]} */
-			const definitions = [];
-			const orderedExportMap =
-				this.exportMap.size > 1
-					? [...this.exportMap].sort(([a], [b]) => (a < b ? -1 : 1))
-					: this.exportMap;
-			for (const [key, value] of orderedExportMap) {
-				definitions.push(
-					`\n/* harmony export */   ${propertyName(
-						/** @type {string} */ (key)
-					)}: ${runtimeTemplate.returningFunction(value)}`
-				);
-			}
+
+		if (this._defsGetter && this._defsGetter.length) {
 			// 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 */ ${
 				RuntimeGlobals.definePropertyGetters
-			}(${this.exportsArgument}, {${definitions.join(
+			}(${this.exportsArgument}, {${this._defsGetter.join(
 				","
 			)}\n/* harmony export */ });\n`;
-			if (this.onDemand !== undefined && this.onDemand(definePart, false)) {
+			if (this.onDemand && getData !== undefined) {
+				const data = getData();
+				const before = data.get("exportsSource");
+				data.set(
+					"exportsSource",
+					before ? `${before}${definePart}` : definePart
+				);
 				definePart = "";
 			}
 		}
+
 		return `${definePart}${unusedPart}`;
 	}
+
+	/**
+	 * 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({ runtimeRequirements, getData }) {
+		let definePart = "";
+
+		if (this._defsValue && this._defsValue.length) {
+			// 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);
+			// Only this fragment emits the array form, so the runtime helper drops the
+			// branch reading it unless this asks for it.
+			runtimeRequirements.add(RuntimeGlobals.definePropertyGettersFromArray);
+			definePart = `/* harmony export */ ${
+				RuntimeGlobals.definePropertyGetters
+			}(${this.exportsArgument}, [${this._defsValue.join(",")}\n/* harmony export */ ]);\n`;
+
+			if (this.onDemand && getData !== undefined) {
+				const data = getData();
+				const before = data.get("exportsBindingSource");
+				data.set(
+					"exportsBindingSource",
+					before ? `${before}${definePart}` : definePart
+				);
+				definePart = "";
+			} else {
+				definePart = `\n${definePart}`;
+			}
+		}
+
+		return definePart;
+	}
 }
 
 module.exports = HarmonyExportInitFragment;
+
+HarmonyExportInitFragment.ExportBindingType = ExportBindingType;