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

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -12,8 +12,11 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const { InlinedUsedName } = require("../optimize/InlineExports");
 const makeSerializable = require("../util/makeSerializable");
 const { propertyAccess } = require("../util/property");
-const ExportBindingInitFragment = require("./ExportBindingInitFragment");
+
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
+
+const { ExportBindingType } = HarmonyExportInitFragment;
+
 const NullDependency = require("./NullDependency");
 
 const DEFAULT_EXPORT_NAME = "default";
@@ -26,8 +29,8 @@ const DEFAULT_EXPORT_NAME = "default";
 /** @import { InlinedValue } from "../optimize/InlineExports" */
 /** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {string | { id?: string | undefined, range: Range, prefix: string, suffix: string }} DeclarationId */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, Range, string, DeclarationId | undefined, boolean]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, Range, string, DeclarationId | undefined, boolean]>} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, Range, string, DeclarationId | undefined, boolean, boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, Range, string, DeclarationId | undefined, boolean, boolean]>} ObjectSerializerContext */
 /** @import { ExportMap } from "./HarmonyExportInitFragment" */
 /**
  * @import {
@@ -54,6 +57,8 @@ class HarmonyExportExpressionDependency extends NullDependency {
 		this.constValue = constValue;
 		/** @type {boolean} */
 		this.isAnonymousDefault = false;
+		/** @type {boolean} */
+		this.isAnonymousDefaultClass = false;
 	}
 
 	get type() {
@@ -126,6 +131,7 @@ class HarmonyExportExpressionDependency extends NullDependency {
 			.write(this.prefix)
 			.write(this.declarationId)
 			.write(this.isAnonymousDefault)
+			.write(this.isAnonymousDefaultClass)
 			.write(this.constValue);
 		super.serialize(context);
 	}
@@ -145,8 +151,10 @@ class HarmonyExportExpressionDependency extends NullDependency {
 		const c4 = c3.rest;
 		this.isAnonymousDefault = c4.read();
 		const c5 = c4.rest;
-		this.constValue = c5.read();
-		super.deserialize(c5.rest);
+		this.isAnonymousDefaultClass = c5.read();
+		const c6 = c5.rest;
+		this.constValue = c6.read();
+		super.deserialize(c6.rest);
 	}
 }
 
@@ -208,7 +216,10 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 			} else if (used) {
 				/** @type {ExportMap} */
 				const map = new Map();
-				map.set(used, `/* export default binding */ ${name}`);
+				map.set(used, {
+					value: `/* export default binding */ ${name}`,
+					type: ExportBindingType.Getter
+				});
 				initFragments.push(new HarmonyExportInitFragment(exportsName, map));
 			}
 
@@ -253,31 +264,19 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 						defaultIsUsed = true;
 						runtimeRequirements.add(RuntimeGlobals.exports);
 						// `export default <expr>` binds an immutable const declaration
-						const canUseValueBinding =
+						const valueFormat =
 							/** @type {import("../Module").BuildInfo} */ (module.buildInfo)
 								.isCircular === false;
-						if (canUseValueBinding) {
-							initFragments.push(
-								new ExportBindingInitFragment(
-									exportsName,
-									[
-										{
-											name: used,
-											value: `/* export default binding */ ${name}`,
-											bindingType: "value"
-										}
-									],
-									true
-								)
-							);
-						} else {
-							/** @type {ExportMap} */
-							const map = new Map();
-							map.set(used, name);
-							initFragments.push(
-								new HarmonyExportInitFragment(exportsName, map)
-							);
-						}
+
+						/** @type {ExportMap} */
+						const map = new Map();
+						map.set(used, {
+							value: name,
+							type: valueFormat
+								? ExportBindingType.Value
+								: ExportBindingType.Getter
+						});
+						initFragments.push(new HarmonyExportInitFragment(exportsName, map));
 					} else {
 						content = `/* unused harmony default export */ var ${name} = `;
 					}
@@ -294,10 +293,9 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 				} else if (used) {
 					defaultIsUsed = true;
 					runtimeRequirements.add(RuntimeGlobals.exports);
-					// This is a little bit incorrect as TDZ is not correct, but we can't use const.
-					// No local `__WEBPACK_DEFAULT_EXPORT__` binding is created in this path,
-					// so the anonymous-default `.name` fix-up below must reference the actual
-					// assignment target instead. See issue #20793.
+					// The TDZ is not reproduced here, `const` being unavailable. No local
+					// binding is created either, so the anonymous-default `.name` fix-up
+					// below names the assignment target instead. See issue #20793.
 					name = `${exportsName}${propertyAccess(
 						typeof used === "string" ? [used] : used
 					)}`;
@@ -308,6 +306,22 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 			}
 
 			if (dep.range) {
+				// `export default class {}` names the class "default", and a static
+				// initializer reads that name before any later fix-up could run, so
+				// the class is created as a property of that name instead.
+				if (dep.isAnonymousDefaultClass) {
+					source.replace(
+						dep.rangeStatement[0],
+						dep.range[0] - 1,
+						`${content}{ ${DEFAULT_EXPORT_NAME}: (${dep.prefix}`
+					);
+					source.replace(
+						dep.range[1],
+						dep.rangeStatement[1] - 0.5,
+						`) }.${DEFAULT_EXPORT_NAME};`
+					);
+					return;
+				}
 				source.replace(
 					dep.rangeStatement[0],
 					dep.range[0] - 1,

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
@@ -829,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
@@ -1515,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(
@@ -1581,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,
@@ -1589,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
@@ -1729,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);
 	}
@@ -1756,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(
@@ -1800,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;

package/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -8,9 +8,10 @@
 const Dependency = require("../Dependency");
 const { InlinedUsedName } = require("../optimize/InlineExports");
 const makeSerializable = require("../util/makeSerializable");
-const memoize = require("../util/memoize");
-const ExportBindingInitFragment = require("./ExportBindingInitFragment");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
+
+const { ExportBindingType } = HarmonyExportInitFragment;
+
 const NullDependency = require("./NullDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
@@ -28,11 +29,6 @@ const NullDependency = require("./NullDependency");
  * } from "../javascript/JavascriptModule"
  */
 
-// Required here rather than at the top: the plugin reaches back into the dependencies.
-const getJavascriptModulesPlugin = memoize(() =>
-	require("../javascript/JavascriptModulesPlugin")
-);
-
 class HarmonyExportSpecifierDependency extends NullDependency {
 	/**
 	 * Creates an instance of HarmonyExportSpecifierDependency.
@@ -147,14 +143,7 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 	apply(
 		dependency,
 		source,
-		{
-			module,
-			moduleGraph,
-			initFragments,
-			runtime,
-			runtimeTemplate,
-			concatenationScope
-		}
+		{ module, moduleGraph, initFragments, runtime, concatenationScope }
 	) {
 		const dep = /** @type {HarmonyExportSpecifierDependency} */ (dependency);
 		// a wrapped module's bindings stay inside the wrapper, not in the shared scope
@@ -180,54 +169,32 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 			return;
 		}
 
-		const canUseValueBinding =
+		const valueFormat =
 			dep.constValue !== undefined &&
 			/** @type {import("../Module").BuildInfo} */ (module.buildInfo)
 				.isCircular === false;
 
-		// A library exporting the same bindings natively reads none of them back off the
-		// exports object, so it takes the call over and emits it only where wrapped.
-		const hooks = getJavascriptModulesPlugin().getCompilationHooks(
-			runtimeTemplate.compilation
+		const meta = moduleGraph.getMetaIfExisting(module);
+
+		const onDemand =
+			!concatenationScope &&
+			meta !== undefined &&
+			meta.onDemandExports === true;
+
+		/** @type {ExportMap} */
+		const map = new Map();
+		map.set(used, {
+			value: `/* binding */ ${dep.id}`,
+			type: valueFormat ? ExportBindingType.Value : ExportBindingType.Getter
+		});
+		initFragments.push(
+			new HarmonyExportInitFragment(
+				module.exportsArgument,
+				map,
+				undefined,
+				onDemand
+			)
 		);
-		const onDemand = hooks.onDemandExportsGeneration.isUsed()
-			? (/** @type {string} */ definition, /** @type {boolean} */ placeAtEnd) =>
-					hooks.onDemandExportsGeneration.call(
-						module,
-						runtime,
-						definition,
-						placeAtEnd
-					) === true
-			: undefined;
-
-		if (canUseValueBinding) {
-			initFragments.push(
-				new ExportBindingInitFragment(
-					module.exportsArgument,
-					[
-						{
-							name: used,
-							value: `/* binding */ ${dep.id}`,
-							bindingType: "value"
-						}
-					],
-					true,
-					onDemand
-				)
-			);
-		} else {
-			/** @type {ExportMap} */
-			const map = new Map();
-			map.set(used, `/* binding */ ${dep.id}`);
-			initFragments.push(
-				new HarmonyExportInitFragment(
-					module.exportsArgument,
-					map,
-					undefined,
-					onDemand
-				)
-			);
-		}
 	}
 };