webpack 5.97.1 → 5.104.1

package/lib/ExportsInfo.js

@@ -5,12 +5,16 @@
 
 "use strict";
 
+const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
 const { equals } = require("./util/ArrayHelpers");
 const SortableSet = require("./util/SortableSet");
 const makeSerializable = require("./util/makeSerializable");
 const { forEachRuntime } = require("./util/runtime");
 
+/** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./Dependency").ExportsSpecExcludeExports} ExportsSpecExcludeExports */
+/** @typedef {import("./dependencies/HarmonyImportDependency")} HarmonyImportDependency */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
@@ -21,6 +25,32 @@ const { forEachRuntime } = require("./util/runtime");
 /** @typedef {typeof UsageState.OnlyPropertiesUsed | typeof UsageState.NoInfo | typeof UsageState.Unknown | typeof UsageState.Used} RuntimeUsageStateType */
 /** @typedef {typeof UsageState.Unused | RuntimeUsageStateType} UsageStateType */
 
+/** @typedef {string} ExportInfoName */
+
+/** @typedef {Map<string, RuntimeUsageStateType>} UsedInRuntime */
+/** @typedef {{ module: Module, export: ExportInfoName[], deferred: boolean }} TargetItemWithoutConnection */
+/** @typedef {{ module: Module, connection: ModuleGraphConnection, export: ExportInfoName[] | undefined }} TargetItemWithConnection */
+/** @typedef {(target: TargetItemWithConnection) => boolean} ResolveTargetFilter */
+/** @typedef {(module: Module) => boolean} ValidTargetModuleFilter */
+/** @typedef {{ connection: ModuleGraphConnection, export: ExportInfoName[], priority: number }} TargetItem */
+/** @typedef {Map<Dependency | undefined, TargetItem>} Target */
+
+/** @typedef {string | null} ExportInfoUsedName */
+/** @typedef {boolean | null} ExportInfoProvided */
+
+/** @typedef {Map<ExportInfoName, ExportInfo>} Exports */
+/** @typedef {string | string[] | false} UsedName */
+/** @typedef {Set<ExportInfo>} AlreadyVisitedExportInfo */
+
+/**
+ * @typedef {object} RestoreProvidedDataExports
+ * @property {ExportInfoName} name
+ * @property {ExportInfo["provided"]} provided
+ * @property {ExportInfo["canMangleProvide"]} canMangleProvide
+ * @property {ExportInfo["terminalBinding"]} terminalBinding
+ * @property {RestoreProvidedData | undefined} exportsInfo
+ */
+
 const UsageState = Object.freeze({
 	Unused: /** @type {0} */ (0),
 	OnlyPropertiesUsed: /** @type {1} */ (1),
@@ -34,6 +64,12 @@ const RETURNS_TRUE = () => true;
 const CIRCULAR = Symbol("circular target");
 
 class RestoreProvidedData {
+	/**
+	 * @param {RestoreProvidedDataExports[]} exports exports
+	 * @param {ExportInfo["provided"]} otherProvided other provided
+	 * @param {ExportInfo["canMangleProvide"]} otherCanMangleProvide other can mangle provide
+	 * @param {ExportInfo["terminalBinding"]} otherTerminalBinding other terminal binding
+	 */
 	constructor(
 		exports,
 		otherProvided,
@@ -71,9 +107,6 @@ makeSerializable(
 	"RestoreProvidedData"
 );
 
-/** @typedef {Map<string, ExportInfo>} Exports */
-/** @typedef {string | string[] | false} UsedName */
-
 class ExportsInfo {
 	constructor() {
 		/** @type {Exports} */
@@ -124,8 +157,9 @@ class ExportsInfo {
 			this._sortExports();
 		}
 		if (this._redirectTo !== undefined) {
+			/** @type {Exports} */
 			const map = new Map(
-				Array.from(this._redirectTo.orderedExports, item => [item.name, item])
+				Array.from(this._redirectTo.orderedExports, (item) => [item.name, item])
 			);
 			for (const [key, value] of this._exports) {
 				map.set(key, value);
@@ -142,8 +176,9 @@ class ExportsInfo {
 	 * @returns {ExportInfo} the export info of unlisted exports
 	 */
 	get otherExportsInfo() {
-		if (this._redirectTo !== undefined)
+		if (this._redirectTo !== undefined) {
 			return this._redirectTo.otherExportsInfo;
+		}
 		return this._otherExportsInfo;
 	}
 
@@ -153,6 +188,7 @@ class ExportsInfo {
 	 */
 	_sortExportsMap(exports) {
 		if (exports.size > 1) {
+			/** @type {ExportInfoName[]} */
 			const namesInOrder = [];
 			for (const entry of exports.values()) {
 				namesInOrder.push(entry.name);
@@ -222,7 +258,7 @@ class ExportsInfo {
 	}
 
 	/**
-	 * @param {string} name export name
+	 * @param {ExportInfoName} name export name
 	 * @returns {ExportInfo} export info for this name
 	 */
 	getOwnExportInfo(name) {
@@ -235,14 +271,15 @@ class ExportsInfo {
 	}
 
 	/**
-	 * @param {string} name export name
+	 * @param {ExportInfoName} name export name
 	 * @returns {ExportInfo} export info for this name
 	 */
 	getExportInfo(name) {
 		const info = this._exports.get(name);
 		if (info !== undefined) return info;
-		if (this._redirectTo !== undefined)
+		if (this._redirectTo !== undefined) {
 			return this._redirectTo.getExportInfo(name);
+		}
 		const newInfo = new ExportInfo(name, this._otherExportsInfo);
 		this._exports.set(name, newInfo);
 		this._exportsAreOrdered = false;
@@ -250,19 +287,20 @@ class ExportsInfo {
 	}
 
 	/**
-	 * @param {string} name export name
+	 * @param {ExportInfoName} name export name
 	 * @returns {ExportInfo} export info for this name
 	 */
 	getReadOnlyExportInfo(name) {
 		const info = this._exports.get(name);
 		if (info !== undefined) return info;
-		if (this._redirectTo !== undefined)
+		if (this._redirectTo !== undefined) {
 			return this._redirectTo.getReadOnlyExportInfo(name);
+		}
 		return this._otherExportsInfo;
 	}
 
 	/**
-	 * @param {string[]} name export name
+	 * @param {ExportInfoName[]} name export name
 	 * @returns {ExportInfo | undefined} export info for this name
 	 */
 	getReadOnlyExportInfoRecursive(name) {
@@ -273,7 +311,7 @@ class ExportsInfo {
 	}
 
 	/**
-	 * @param {string[]=} name the export name
+	 * @param {ExportInfoName[]=} name the export name
 	 * @returns {ExportsInfo | undefined} the nested exports info
 	 */
 	getNestedExportsInfo(name) {
@@ -287,8 +325,8 @@ class ExportsInfo {
 
 	/**
 	 * @param {boolean=} canMangle true, if exports can still be mangled (defaults to false)
-	 * @param {Set<string>=} excludeExports list of unaffected exports
-	 * @param {any=} targetKey use this as key for the target
+	 * @param {ExportsSpecExcludeExports=} excludeExports list of unaffected exports
+	 * @param {Dependency=} targetKey use this as key for the target
 	 * @param {ModuleGraphConnection=} targetModule set this module as target
 	 * @param {number=} priority priority
 	 * @returns {boolean} true, if this call changed something
@@ -320,7 +358,8 @@ class ExportsInfo {
 			if (targetKey) {
 				exportInfo.setTarget(
 					targetKey,
-					/** @type {ModuleGraphConnection} */ (targetModule),
+					/** @type {ModuleGraphConnection} */
+					(targetModule),
 					[exportInfo.name],
 					-1
 				);
@@ -380,7 +419,7 @@ class ExportsInfo {
 		} else {
 			if (
 				this._otherExportsInfo.setUsedConditionally(
-					used => used < UsageState.Unknown,
+					(used) => used < UsageState.Unknown,
 					UsageState.Unknown,
 					runtime
 				)
@@ -443,7 +482,7 @@ class ExportsInfo {
 	 */
 	setUsedForSideEffectsOnly(runtime) {
 		return this._sideEffectsOnlyInfo.setUsedConditionally(
-			used => used === UsageState.Unused,
+			(used) => used === UsageState.Unused,
 			UsageState.Used,
 			runtime
 		);
@@ -475,27 +514,27 @@ class ExportsInfo {
 	 */
 	isModuleUsed(runtime) {
 		if (this.isUsed(runtime)) return true;
-		if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused)
+		if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused) {
 			return true;
+		}
 		return false;
 	}
 
 	/**
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {SortableSet<string> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
+	 * @returns {SortableSet<ExportInfoName> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
 	 */
 	getUsedExports(runtime) {
-		// eslint-disable-next-line no-constant-binary-expression
-		if (!this._redirectTo !== undefined) {
-			switch (this._otherExportsInfo.getUsed(runtime)) {
-				case UsageState.NoInfo:
-					return null;
-				case UsageState.Unknown:
-				case UsageState.OnlyPropertiesUsed:
-				case UsageState.Used:
-					return true;
-			}
+		switch (this._otherExportsInfo.getUsed(runtime)) {
+			case UsageState.NoInfo:
+				return null;
+			case UsageState.Unknown:
+			case UsageState.OnlyPropertiesUsed:
+			case UsageState.Used:
+				return true;
 		}
+
+		/** @type {ExportInfoName[]} */
 		const array = [];
 		if (!this._exportsAreOrdered) this._sortExports();
 		for (const exportInfo of this._exports.values()) {
@@ -527,24 +566,23 @@ class ExportsInfo {
 					return false;
 			}
 		}
-		return /** @type {SortableSet<string>} */ (new SortableSet(array));
+		return /** @type {SortableSet<ExportInfoName>} */ (new SortableSet(array));
 	}
 
 	/**
-	 * @returns {null | true | string[]} list of exports when known
+	 * @returns {null | true | ExportInfoName[]} list of exports when known
 	 */
 	getProvidedExports() {
-		// eslint-disable-next-line no-constant-binary-expression
-		if (!this._redirectTo !== undefined) {
-			switch (this._otherExportsInfo.provided) {
-				case undefined:
-					return null;
-				case null:
-					return true;
-				case true:
-					return true;
-			}
+		switch (this._otherExportsInfo.provided) {
+			case undefined:
+				return null;
+			case null:
+				return true;
+			case true:
+				return true;
 		}
+
+		/** @type {ExportInfoName[]} */
 		const array = [];
 		if (!this._exportsAreOrdered) this._sortExports();
 		for (const exportInfo of this._exports.values()) {
@@ -597,7 +635,7 @@ class ExportsInfo {
 	}
 
 	/**
-	 * @param {string | string[]} name the name of the export
+	 * @param {ExportInfoName | ExportInfoName[]} name the name of the export
 	 * @returns {boolean | undefined | null} if the export is provided
 	 */
 	isExportProvided(name) {
@@ -651,14 +689,15 @@ class ExportsInfo {
 			return false;
 		}
 		for (const exportInfo of this.ownedExports) {
-			if (exportInfo.getUsed(runtimeA) !== exportInfo.getUsed(runtimeB))
+			if (exportInfo.getUsed(runtimeA) !== exportInfo.getUsed(runtimeB)) {
 				return false;
+			}
 		}
 		return true;
 	}
 
 	/**
-	 * @param {string | string[]} name export name
+	 * @param {ExportInfoName | ExportInfoName[]} name export name
 	 * @param {RuntimeSpec} runtime check usage for this runtime only
 	 * @returns {UsageStateType} usage status
 	 */
@@ -676,7 +715,7 @@ class ExportsInfo {
 	}
 
 	/**
-	 * @param {string | string[]} name the export name
+	 * @param {ExportInfoName | ExportInfoName[]} name the export name
 	 * @param {RuntimeSpec} runtime check usage for this runtime only
 	 * @returns {UsedName} the used name
 	 */
@@ -691,7 +730,7 @@ class ExportsInfo {
 			const x = info.getUsedName(name[0], runtime);
 			if (x === false) return false;
 			const arr =
-				/** @type {string[]} */
+				/** @type {ExportInfoName[]} */
 				(x === name[0] && name.length === 1 ? name : [x]);
 			if (name.length === 1) {
 				return arr;
@@ -702,9 +741,9 @@ class ExportsInfo {
 			) {
 				const nested = info.exportsInfo.getUsedName(name.slice(1), runtime);
 				if (!nested) return false;
-				return arr.concat(nested);
+				return [...arr, ...(Array.isArray(nested) ? nested : [nested])];
 			}
-			return arr.concat(name.slice(1));
+			return [...arr, ...name.slice(1)];
 		}
 		const info = this.getReadOnlyExportInfo(name);
 		const usedName = info.getUsedName(name, runtime);
@@ -748,6 +787,7 @@ class ExportsInfo {
 		const otherProvided = this._otherExportsInfo.provided;
 		const otherCanMangleProvide = this._otherExportsInfo.canMangleProvide;
 		const otherTerminalBinding = this._otherExportsInfo.terminalBinding;
+		/** @type {RestoreProvidedDataExports[]} */
 		const exports = [];
 		for (const exportInfo of this.orderedExports) {
 			if (
@@ -777,7 +817,7 @@ class ExportsInfo {
 	}
 
 	/**
-	 * @param {{ otherProvided: any, otherCanMangleProvide: any, otherTerminalBinding: any, exports: any }} data data
+	 * @param {RestoreProvidedData} data data
 	 */
 	restoreProvided({
 		otherProvided,
@@ -809,21 +849,17 @@ class ExportsInfo {
 	}
 }
 
-/** @typedef {{ module: Module, export: string[] }} TargetItemWithoutConnection */
-/** @typedef {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }} TargetItem */
-/** @typedef {Map<any, { connection: ModuleGraphConnection | null, export: string[], priority: number }>} Target */
-
 class ExportInfo {
 	/**
-	 * @param {string} name the original name of the export
+	 * @param {ExportInfoName | null} name the original name of the export
 	 * @param {ExportInfo=} initFrom init values from this ExportInfo
 	 */
 	constructor(name, initFrom) {
-		/** @type {string} */
-		this.name = name;
+		/** @type {ExportInfoName} */
+		this.name = /** @type {ExportInfoName} */ (name);
 		/**
 		 * @private
-		 * @type {string | null}
+		 * @type {ExportInfoUsedName}
 		 */
 		this._usedName = initFrom ? initFrom._usedName : null;
 		/**
@@ -833,7 +869,7 @@ class ExportInfo {
 		this._globalUsed = initFrom ? initFrom._globalUsed : undefined;
 		/**
 		 * @private
-		 * @type {Map<string, RuntimeUsageStateType>}
+		 * @type {UsedInRuntime | undefined}
 		 */
 		this._usedInRuntime =
 			initFrom && initFrom._usedInRuntime
@@ -851,7 +887,7 @@ class ExportInfo {
 		 * false: it is not provided
 		 * null: only the runtime knows if it is provided
 		 * undefined: it was not determined if it is provided
-		 * @type {boolean | null | undefined}
+		 * @type {ExportInfoProvided | undefined}
 		 */
 		this.provided = initFrom ? initFrom.provided : undefined;
 		/**
@@ -896,7 +932,7 @@ class ExportInfo {
 	// TODO webpack 5 remove
 	/**
 	 * @private
-	 * @param {*} v v
+	 * @param {EXPECTED_ANY} v v
 	 */
 	set used(v) {
 		throw new Error("REMOVED");
@@ -911,7 +947,7 @@ class ExportInfo {
 	// TODO webpack 5 remove
 	/**
 	 * @private
-	 * @param {*} v v
+	 * @param {EXPECTED_ANY} v v
 	 */
 	set usedName(v) {
 		throw new Error("REMOVED");
@@ -952,7 +988,7 @@ class ExportInfo {
 		let changed = false;
 		if (
 			this.setUsedConditionally(
-				used => used < UsageState.Unknown,
+				(used) => used < UsageState.Unknown,
 				UsageState.Unknown,
 				runtime
 			)
@@ -996,7 +1032,7 @@ class ExportInfo {
 	}
 
 	/**
-	 * @param {function(UsageStateType): boolean} condition compare with old value
+	 * @param {(condition: UsageStateType) => boolean} condition compare with old value
 	 * @param {UsageStateType} newValue set when condition is true
 	 * @param {RuntimeSpec} runtime only apply to this runtime
 	 * @returns {boolean} true when something has changed
@@ -1014,24 +1050,28 @@ class ExportInfo {
 		} else if (this._usedInRuntime === undefined) {
 			if (newValue !== UsageState.Unused && condition(UsageState.Unused)) {
 				this._usedInRuntime = new Map();
-				forEachRuntime(runtime, runtime =>
-					this._usedInRuntime.set(/** @type {string} */ (runtime), newValue)
+				forEachRuntime(runtime, (runtime) =>
+					/** @type {UsedInRuntime} */
+					(this._usedInRuntime).set(/** @type {string} */ (runtime), newValue)
 				);
 				return true;
 			}
 		} else {
 			let changed = false;
-			forEachRuntime(runtime, _runtime => {
-				const runtime = /** @type {string} */ (_runtime);
+			forEachRuntime(runtime, (runtime_) => {
+				const runtime = /** @type {string} */ (runtime_);
+				const usedInRuntime =
+					/** @type {UsedInRuntime} */
+					(this._usedInRuntime);
 				let oldValue =
 					/** @type {UsageStateType} */
-					(this._usedInRuntime.get(runtime));
+					(usedInRuntime.get(runtime));
 				if (oldValue === undefined) oldValue = UsageState.Unused;
 				if (newValue !== oldValue && condition(oldValue)) {
 					if (newValue === UsageState.Unused) {
-						this._usedInRuntime.delete(runtime);
+						usedInRuntime.delete(runtime);
 					} else {
-						this._usedInRuntime.set(runtime, newValue);
+						usedInRuntime.set(runtime, newValue);
 					}
 					changed = true;
 				}
@@ -1058,24 +1098,28 @@ class ExportInfo {
 		} else if (this._usedInRuntime === undefined) {
 			if (newValue !== UsageState.Unused) {
 				this._usedInRuntime = new Map();
-				forEachRuntime(runtime, runtime =>
-					this._usedInRuntime.set(/** @type {string} */ (runtime), newValue)
+				forEachRuntime(runtime, (runtime) =>
+					/** @type {UsedInRuntime} */
+					(this._usedInRuntime).set(/** @type {string} */ (runtime), newValue)
 				);
 				return true;
 			}
 		} else {
 			let changed = false;
-			forEachRuntime(runtime, _runtime => {
+			forEachRuntime(runtime, (_runtime) => {
 				const runtime = /** @type {string} */ (_runtime);
+				const usedInRuntime =
+					/** @type {UsedInRuntime} */
+					(this._usedInRuntime);
 				let oldValue =
 					/** @type {UsageStateType} */
-					(this._usedInRuntime.get(runtime));
+					(usedInRuntime.get(runtime));
 				if (oldValue === undefined) oldValue = UsageState.Unused;
 				if (newValue !== oldValue) {
 					if (newValue === UsageState.Unused) {
-						this._usedInRuntime.delete(runtime);
+						usedInRuntime.delete(runtime);
 					} else {
-						this._usedInRuntime.set(runtime, newValue);
+						usedInRuntime.set(runtime, newValue);
 					}
 					changed = true;
 				}
@@ -1089,7 +1133,7 @@ class ExportInfo {
 	}
 
 	/**
-	 * @param {any} key the key
+	 * @param {Dependency} key the key
 	 * @returns {boolean} true, if something has changed
 	 */
 	unsetTarget(key) {
@@ -1102,9 +1146,9 @@ class ExportInfo {
 	}
 
 	/**
-	 * @param {any} key the key
+	 * @param {Dependency} key the key
 	 * @param {ModuleGraphConnection} connection the target module if a single one
-	 * @param {(string[] | null)=} exportName the exported name
+	 * @param {ExportInfoName[] | null=} exportName the exported name
 	 * @param {number=} priority priority
 	 * @returns {boolean} true, if something has changed
 	 */
@@ -1114,7 +1158,7 @@ class ExportInfo {
 			this._target = new Map();
 			this._target.set(key, {
 				connection,
-				export: /** @type {string[]} */ (exportName),
+				export: /** @type {ExportInfoName[]} */ (exportName),
 				priority
 			});
 			return true;
@@ -1124,7 +1168,7 @@ class ExportInfo {
 			if (oldTarget === null && !connection) return false;
 			this._target.set(key, {
 				connection,
-				export: /** @type {string[]} */ (exportName),
+				export: /** @type {ExportInfoName[]} */ (exportName),
 				priority
 			});
 			this._maxTarget = undefined;
@@ -1138,7 +1182,7 @@ class ExportInfo {
 				: oldTarget.export)
 		) {
 			oldTarget.connection = connection;
-			oldTarget.export = /** @type {string[]} */ (exportName);
+			oldTarget.export = /** @type {ExportInfoName[]} */ (exportName);
 			oldTarget.priority = priority;
 			this._maxTarget = undefined;
 			return true;
@@ -1202,8 +1246,9 @@ class ExportInfo {
 					}
 				} else if (
 					runtime !== undefined &&
-					Array.from(runtime).every(
-						runtime => !this._usedInRuntime.has(runtime)
+					[...runtime].every(
+						(runtime) =>
+							!(/** @type {UsedInRuntime} */ (this._usedInRuntime).has(runtime))
 					)
 				) {
 					return false;
@@ -1232,7 +1277,7 @@ class ExportInfo {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(TargetItem): boolean} resolveTargetFilter filter function to further resolve target
+	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
 	 * @returns {ExportInfo | ExportsInfo | undefined} the terminal binding export(s) info if known
 	 */
 	getTerminalBinding(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
@@ -1250,8 +1295,9 @@ class ExportInfo {
 
 	_getMaxTarget() {
 		if (this._maxTarget !== undefined) return this._maxTarget;
-		if (/** @type {Target} */ (this._target).size <= 1)
+		if (/** @type {Target} */ (this._target).size <= 1) {
 			return (this._maxTarget = this._target);
+		}
 		let maxPriority = -Infinity;
 		let minPriority = Infinity;
 		for (const { priority } of /** @type {Target} */ (this._target).values()) {
@@ -1262,6 +1308,7 @@ class ExportInfo {
 		if (maxPriority === minPriority) return (this._maxTarget = this._target);
 
 		// This is an edge case
+		/** @type {Target} */
 		const map = new Map();
 		for (const [key, value] of /** @type {Target} */ (this._target)) {
 			if (maxPriority === value.priority) {
@@ -1274,7 +1321,7 @@ class ExportInfo {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
+	 * @param {ValidTargetModuleFilter} validTargetModuleFilter a valid target module
 	 * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
 	findTarget(moduleGraph, validTargetModuleFilter) {
@@ -1283,8 +1330,8 @@ class ExportInfo {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
-	 * @param {Set<ExportInfo>} alreadyVisited set of already visited export info to avoid circular references
+	 * @param {ValidTargetModuleFilter} validTargetModuleFilter a valid target module
+	 * @param {AlreadyVisitedExportInfo} alreadyVisited set of already visited export info to avoid circular references
 	 * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
 	_findTarget(moduleGraph, validTargetModuleFilter, alreadyVisited) {
@@ -1296,7 +1343,15 @@ class ExportInfo {
 		/** @type {TargetItemWithoutConnection} */
 		let target = {
 			module: rawTarget.connection.module,
-			export: rawTarget.export
+			export: rawTarget.export,
+			deferred: Boolean(
+				rawTarget.connection.dependency &&
+				ImportPhaseUtils.isDefer(
+					/** @type {HarmonyImportDependency} */ (
+						rawTarget.connection.dependency
+					).phase
+				)
+			)
 		};
 		for (;;) {
 			if (validTargetModuleFilter(target.module)) return target;
@@ -1315,8 +1370,9 @@ class ExportInfo {
 				target = {
 					module: newTarget.module,
 					export: newTarget.export
-						? newTarget.export.concat(target.export.slice(1))
-						: target.export.slice(1)
+						? [...newTarget.export, ...target.export.slice(1)]
+						: target.export.slice(1),
+					deferred: newTarget.deferred
 				};
 			}
 		}
@@ -1324,8 +1380,8 @@ class ExportInfo {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(TargetItem): boolean} resolveTargetFilter filter function to further resolve target
-	 * @returns {TargetItem | undefined} the target
+	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
+	 * @returns {TargetItemWithConnection | undefined} the target
 	 */
 	getTarget(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
 		const result = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
@@ -1335,15 +1391,15 @@ class ExportInfo {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(TargetItem): boolean} resolveTargetFilter filter function to further resolve target
-	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
-	 * @returns {TargetItem | CIRCULAR | undefined} the target
+	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
+	 * @param {AlreadyVisitedExportInfo | undefined} alreadyVisited set of already visited export info to avoid circular references
+	 * @returns {TargetItemWithConnection | CIRCULAR | undefined} the target
 	 */
 	_getTarget(moduleGraph, resolveTargetFilter, alreadyVisited) {
 		/**
-		 * @param {TargetItem | null} inputTarget unresolved target
-		 * @param {Set<ExportInfo>} alreadyVisited set of already visited export info to avoid circular references
-		 * @returns {TargetItem | CIRCULAR | null} resolved target
+		 * @param {TargetItem | undefined | null} inputTarget unresolved target
+		 * @param {AlreadyVisitedExportInfo} alreadyVisited set of already visited export info to avoid circular references
+		 * @returns {TargetItemWithConnection | CIRCULAR | null} resolved target
 		 */
 		const resolveTarget = (inputTarget, alreadyVisited) => {
 			if (!inputTarget) return null;
@@ -1354,7 +1410,7 @@ class ExportInfo {
 					export: undefined
 				};
 			}
-			/** @type {TargetItem} */
+			/** @type {TargetItemWithConnection} */
 			let target = {
 				module: inputTarget.connection.module,
 				connection: inputTarget.connection,
@@ -1365,7 +1421,7 @@ class ExportInfo {
 			for (;;) {
 				const exportsInfo = moduleGraph.getExportsInfo(target.module);
 				const exportInfo = exportsInfo.getExportInfo(
-					/** @type {NonNullable<TargetItem["export"]>} */
+					/** @type {NonNullable<TargetItemWithConnection["export"]>} */
 					(target.export)[0]
 				);
 				if (!exportInfo) return target;
@@ -1378,7 +1434,7 @@ class ExportInfo {
 				if (newTarget === CIRCULAR) return CIRCULAR;
 				if (!newTarget) return target;
 				if (
-					/** @type {NonNullable<TargetItem["export"]>} */
+					/** @type {NonNullable<TargetItemWithConnection["export"]>} */
 					(target.export).length === 1
 				) {
 					target = newTarget;
@@ -1388,11 +1444,12 @@ class ExportInfo {
 						module: newTarget.module,
 						connection: newTarget.connection,
 						export: newTarget.export
-							? newTarget.export.concat(
-									/** @type {NonNullable<TargetItem["export"]>} */
+							? [
+									...newTarget.export,
+									.../** @type {NonNullable<TargetItemWithConnection["export"]>} */
 									(target.export).slice(1)
-								)
-							: /** @type {NonNullable<TargetItem["export"]>} */
+								]
+							: /** @type {NonNullable<TargetItemWithConnection["export"]>} */
 								(target.export).slice(1)
 					};
 				}
@@ -1423,8 +1480,9 @@ class ExportInfo {
 			if (
 				target.export &&
 				!equals(/** @type {ArrayLike<string>} */ (t.export), target.export)
-			)
+			) {
 				return;
+			}
 			result = values.next();
 		}
 		return target;
@@ -1433,17 +1491,20 @@ class ExportInfo {
 	/**
 	 * Move the target forward as long resolveTargetFilter is fulfilled
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(TargetItem): boolean} resolveTargetFilter filter function to further resolve target
-	 * @param {function(TargetItem): ModuleGraphConnection=} updateOriginalConnection updates the original connection instead of using the target connection
-	 * @returns {TargetItem | undefined} the resolved target when moved
+	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
+	 * @param {(target: TargetItemWithConnection) => ModuleGraphConnection=} updateOriginalConnection updates the original connection instead of using the target connection
+	 * @returns {TargetItemWithConnection | undefined} the resolved target when moved
 	 */
 	moveTarget(moduleGraph, resolveTargetFilter, updateOriginalConnection) {
 		const target = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
 		if (target === CIRCULAR) return;
 		if (!target) return;
 		const originalTarget =
-			/** @type {Target} */
-			(this._getMaxTarget()).values().next().value;
+			/** @type {TargetItem} */
+			(
+				/** @type {Target} */
+				(this._getMaxTarget()).values().next().value
+			);
 		if (
 			originalTarget.connection === target.connection &&
 			originalTarget.export === target.export
@@ -1457,7 +1518,9 @@ class ExportInfo {
 			connection: updateOriginalConnection
 				? updateOriginalConnection(target)
 				: target.connection,
-			export: /** @type {NonNullable<TargetItem["export"]>} */ (target.export),
+			export: /** @type {NonNullable<TargetItemWithConnection["export"]>} */ (
+				target.export
+			),
 			priority: 0
 		});
 		return target;
@@ -1467,8 +1530,9 @@ class ExportInfo {
 	 * @returns {ExportsInfo} an exports info
 	 */
 	createNestedExportsInfo() {
-		if (this.exportsInfoOwned)
+		if (this.exportsInfoOwned) {
 			return /** @type {ExportsInfo} */ (this.exportsInfo);
+		}
 		this.exportsInfoOwned = true;
 		const oldExportsInfo = this.exportsInfo;
 		this.exportsInfo = new ExportsInfo();
@@ -1621,4 +1685,5 @@ class ExportInfo {
 
 module.exports = ExportsInfo;
 module.exports.ExportInfo = ExportInfo;
+module.exports.RestoreProvidedData = RestoreProvidedData;
 module.exports.UsageState = UsageState;