webpack 5.90.2 → 5.91.0

package/lib/optimize/ConcatenatedModule.js

@@ -37,7 +37,9 @@ const {
 	subtractRuntimeCondition
 } = require("../util/runtime");
 
+/** @typedef {import("eslint-scope").Reference} Reference */
 /** @typedef {import("eslint-scope").Scope} Scope */
+/** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
@@ -48,10 +50,13 @@ const {
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @template T @typedef {import("../InitFragment")<T>} InitFragment */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
@@ -60,14 +65,27 @@ const {
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("../javascript/JavascriptParser").Program} Program */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {typeof import("../util/Hash")} HashConstructor */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * @template T
+ * @typedef {import("../InitFragment")<T>} InitFragment
+ */
+
+/**
+ * @template T
+ * @typedef {import("../util/comparators").Comparator<T>} Comparator
+ */
+
 // fix eslint-scope to support class properties correctly
 // cspell:word Referencer
-const ReferencerClass = Referencer;
+const ReferencerClass = /** @type {any} */ (Referencer);
 if (!ReferencerClass.prototype.PropertyDefinition) {
 	ReferencerClass.prototype.PropertyDefinition =
 		ReferencerClass.prototype.Property;
@@ -107,24 +125,24 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {"concatenated"} type
  * @property {Module} module
  * @property {number} index
- * @property {Object} ast
+ * @property {Program | undefined} ast
  * @property {Source} internalSource
  * @property {ReplaceSource} source
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
- * @property {Iterable<string>} runtimeRequirements
+ * @property {ReadOnlyRuntimeRequirements} runtimeRequirements
  * @property {Scope} globalScope
  * @property {Scope} moduleScope
  * @property {Map<string, string>} internalNames
- * @property {Map<string, string>} exportMap
- * @property {Map<string, string>} rawExportMap
+ * @property {Map<string, string> | undefined} exportMap
+ * @property {Map<string, string> | undefined} rawExportMap
  * @property {string=} namespaceExportSymbol
- * @property {string} namespaceObjectName
+ * @property {string | undefined} namespaceObjectName
  * @property {boolean} interopNamespaceObjectUsed
- * @property {string} interopNamespaceObjectName
+ * @property {string | undefined} interopNamespaceObjectName
  * @property {boolean} interopNamespaceObject2Used
- * @property {string} interopNamespaceObject2Name
+ * @property {string | undefined} interopNamespaceObject2Name
  * @property {boolean} interopDefaultAccessUsed
- * @property {string} interopDefaultAccessName
+ * @property {string | undefined} interopDefaultAccessName
  */
 
 /**
@@ -149,6 +167,8 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {ConcatenatedModuleInfo | ExternalModuleInfo} target
  */
 
+/** @typedef {Set<string>} UsedNames */
+
 const RESERVED_NAMES = new Set(
 	[
 		// internal names (should always be renamed)
@@ -189,6 +209,12 @@ const RESERVED_NAMES = new Set(
 
 const createComparator = (property, comparator) => (a, b) =>
 	comparator(a[property], b[property]);
+
+/**
+ * @param {number} a a
+ * @param {number} b b
+ * @returns {0 | 1 | -1} result
+ */
 const compareNumbers = (a, b) => {
 	if (isNaN(a)) {
 		if (!isNaN(b)) {
@@ -207,6 +233,10 @@ const compareNumbers = (a, b) => {
 const bySourceOrder = createComparator("sourceOrder", compareNumbers);
 const byRangeStart = createComparator("rangeStart", compareNumbers);
 
+/**
+ * @param {Iterable<string>} iterable iterable object
+ * @returns {string} joined iterable object
+ */
 const joinIterableWithComma = iterable => {
 	// This is more performant than Array.from().join(", ")
 	// as it doesn't create an array
@@ -240,7 +270,7 @@ const joinIterableWithComma = iterable => {
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
  * @param {boolean} asCall asCall
- * @param {boolean} strictHarmonyModule strictHarmonyModule
+ * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
  * @param {Set<ExportInfo>} alreadyVisited alreadyVisited
  * @returns {Binding} the final variable
@@ -269,7 +299,7 @@ const getFinalBinding = (
 				info.interopNamespaceObject2Used = true;
 				return {
 					info,
-					rawName: info.interopNamespaceObject2Name,
+					rawName: /** @type {string} */ (info.interopNamespaceObject2Name),
 					ids: exportName,
 					exportName
 				};
@@ -277,7 +307,7 @@ const getFinalBinding = (
 				info.interopNamespaceObjectUsed = true;
 				return {
 					info,
-					rawName: info.interopNamespaceObjectName,
+					rawName: /** @type {string} */ (info.interopNamespaceObjectName),
 					ids: exportName,
 					exportName
 				};
@@ -365,7 +395,7 @@ const getFinalBinding = (
 				neededNamespaceObjects.add(info);
 				return {
 					info,
-					rawName: info.namespaceObjectName,
+					rawName: /** @type {string} */ (info.namespaceObjectName),
 					ids: exportName,
 					exportName
 				};
@@ -392,7 +422,7 @@ const getFinalBinding = (
 				neededNamespaceObjects.add(info);
 				return {
 					info,
-					rawName: info.namespaceObjectName,
+					rawName: /** @type {string} */ (info.namespaceObjectName),
 					ids: exportName,
 					exportName
 				};
@@ -444,7 +474,7 @@ const getFinalBinding = (
 				const refInfo = moduleToInfoMap.get(reexport.module);
 				return getFinalBinding(
 					moduleGraph,
-					refInfo,
+					/** @type {ModuleInfo} */ (refInfo),
 					reexport.export
 						? [...reexport.export, ...exportName.slice(1)]
 						: exportName.slice(1),
@@ -454,7 +484,8 @@ const getFinalBinding = (
 					runtimeTemplate,
 					neededNamespaceObjects,
 					asCall,
-					info.module.buildMeta.strictHarmonyModule,
+					/** @type {BuildMeta} */
+					(info.module.buildMeta).strictHarmonyModule,
 					asiSafe,
 					alreadyVisited
 				);
@@ -465,7 +496,7 @@ const getFinalBinding = (
 				);
 				return {
 					info,
-					rawName: info.namespaceObjectName,
+					rawName: /** @type {string} */ (info.namespaceObjectName),
 					ids: usedName,
 					exportName
 				};
@@ -507,8 +538,8 @@ const getFinalBinding = (
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
  * @param {boolean} asCall asCall
- * @param {boolean} callContext callContext
- * @param {boolean} strictHarmonyModule strictHarmonyModule
+ * @param {boolean | undefined} callContext callContext
+ * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
  * @returns {string} the final name
  */
@@ -575,6 +606,12 @@ const getFinalName = (
 	}
 };
 
+/**
+ * @param {Scope | null} s scope
+ * @param {UsedNames} nameSet name set
+ * @param {TODO} scopeSet1 scope set 1
+ * @param {TODO} scopeSet2 scope set 2
+ */
 const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
 	let scope = s;
 	while (scope) {
@@ -588,6 +625,10 @@ const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
 	}
 };
 
+/**
+ * @param {Variable} variable variable
+ * @returns {Reference[]} references
+ */
 const getAllReferences = variable => {
 	let set = variable.references;
 	// Look for inner scope variables too (like in class Foo { t() { Foo } })
@@ -603,6 +644,11 @@ const getAllReferences = variable => {
 	return set;
 };
 
+/**
+ * @param {TODO} ast ast
+ * @param {TODO} node node
+ * @returns {TODO} result
+ */
 const getPathInAst = (ast, node) => {
 	if (ast === node) {
 		return [];
@@ -710,7 +756,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
 		return TYPES;
@@ -771,11 +817,14 @@ class ConcatenatedModule extends Module {
 	 */
 	build(options, compilation, resolver, fs, callback) {
 		const { rootModule } = this;
+		const { moduleArgument, exportsArgument } =
+			/** @type {BuildInfo} */
+			(rootModule.buildInfo);
 		this.buildInfo = {
 			strict: true,
 			cacheable: true,
-			moduleArgument: rootModule.buildInfo.moduleArgument,
-			exportsArgument: rootModule.buildInfo.exportsArgument,
+			moduleArgument,
+			exportsArgument,
 			fileDependencies: new LazySet(),
 			contextDependencies: new LazySet(),
 			missingDependencies: new LazySet(),
@@ -788,7 +837,7 @@ class ConcatenatedModule extends Module {
 
 		for (const m of this._modules) {
 			// populate cacheable
-			if (!m.buildInfo.cacheable) {
+			if (!(/** @type {BuildInfo} */ (m.buildInfo).cacheable)) {
 				this.buildInfo.cacheable = false;
 			}
 
@@ -796,7 +845,9 @@ class ConcatenatedModule extends Module {
 			for (const d of m.dependencies.filter(
 				dep =>
 					!(dep instanceof HarmonyImportDependency) ||
-					!this._modules.has(compilation.moduleGraph.getModule(dep))
+					!this._modules.has(
+						/** @type {Module} */ (compilation.moduleGraph.getModule(dep))
+					)
 			)) {
 				this.dependencies.push(d);
 			}
@@ -821,11 +872,14 @@ class ConcatenatedModule extends Module {
 				}
 			}
 
+			const { assets, assetsInfo, topLevelDeclarations } =
+				/** @type {BuildInfo} */ (m.buildInfo);
+
 			// populate topLevelDeclarations
-			if (m.buildInfo.topLevelDeclarations) {
+			if (topLevelDeclarations) {
 				const topLevelDeclarations = this.buildInfo.topLevelDeclarations;
 				if (topLevelDeclarations !== undefined) {
-					for (const decl of m.buildInfo.topLevelDeclarations) {
+					for (const decl of topLevelDeclarations) {
 						topLevelDeclarations.add(decl);
 					}
 				}
@@ -834,17 +888,17 @@ class ConcatenatedModule extends Module {
 			}
 
 			// populate assets
-			if (m.buildInfo.assets) {
+			if (assets) {
 				if (this.buildInfo.assets === undefined) {
 					this.buildInfo.assets = Object.create(null);
 				}
-				Object.assign(this.buildInfo.assets, m.buildInfo.assets);
+				Object.assign(/** @type {BuildInfo} */ (this.buildInfo).assets, assets);
 			}
-			if (m.buildInfo.assetsInfo) {
+			if (assetsInfo) {
 				if (this.buildInfo.assetsInfo === undefined) {
 					this.buildInfo.assetsInfo = new Map();
 				}
-				for (const [key, value] of m.buildInfo.assetsInfo) {
+				for (const [key, value] of assetsInfo) {
 					this.buildInfo.assetsInfo.set(key, value);
 				}
 			}
@@ -1055,7 +1109,7 @@ class ConcatenatedModule extends Module {
 		hashFunction = "md4"
 	) {
 		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
-			rootModule.context,
+			/** @type {string} */ (rootModule.context),
 			associatedObjectForCache
 		);
 		let identifiers = [];
@@ -1138,12 +1192,12 @@ class ConcatenatedModule extends Module {
 		const topLevelDeclarations = new Set();
 
 		// List of additional names in scope for module references
-		/** @type {Map<string, { usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }>} */
+		/** @type {Map<string, { usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }>} */
 		const usedNamesInScopeInfo = new Map();
 		/**
 		 * @param {string} module module identifier
 		 * @param {string} id export id
-		 * @returns {{ usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }} info
+		 * @returns {{ usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }} info
 		 */
 		const getUsedNamesInScopeInfo = (module, id) => {
 			const key = `${module}-${id}`;
@@ -1173,6 +1227,10 @@ class ConcatenatedModule extends Module {
 				// We get ranges of all super class expressions to make
 				// renaming to work correctly
 				const superClassCache = new WeakMap();
+				/**
+				 * @param {Scope} scope scope
+				 * @returns {TODO} result
+				 */
 				const getSuperClassExpressions = scope => {
 					const cacheEntry = superClassCache.get(scope);
 					if (cacheEntry !== undefined) return cacheEntry;
@@ -1215,7 +1273,8 @@ class ConcatenatedModule extends Module {
 								runtimeTemplate,
 								neededNamespaceObjects,
 								false,
-								info.module.buildMeta.strictHarmonyModule,
+								/** @type {BuildMeta} */
+								(info.module.buildMeta).strictHarmonyModule,
 								true
 							);
 							if (!binding.ids) continue;
@@ -1226,8 +1285,10 @@ class ConcatenatedModule extends Module {
 								);
 							for (const expr of getSuperClassExpressions(reference.from)) {
 								if (
-									expr.range[0] <= reference.identifier.range[0] &&
-									expr.range[1] >= reference.identifier.range[1]
+									expr.range[0] <=
+										/** @type {Range} */ (reference.identifier.range)[0] &&
+									expr.range[1] >=
+										/** @type {Range} */ (reference.identifier.range)[1]
 								) {
 									for (const variable of expr.variables) {
 										usedNames.add(variable.name);
@@ -1286,7 +1347,7 @@ class ConcatenatedModule extends Module {
 								references.map(r => r.identifier).concat(variable.identifiers)
 							);
 							for (const identifier of allIdentifiers) {
-								const r = identifier.range;
+								const r = /** @type {Range} */ (identifier.range);
 								const path = getPathInAst(info.ast, identifier);
 								if (path && path.length > 1) {
 									const maybeProperty =
@@ -1324,7 +1385,9 @@ class ConcatenatedModule extends Module {
 						);
 						allUsedNames.add(namespaceObjectName);
 					}
-					info.namespaceObjectName = namespaceObjectName;
+					info.namespaceObjectName =
+						/** @type {string} */
+						(namespaceObjectName);
 					topLevelDeclarations.add(namespaceObjectName);
 					break;
 				}
@@ -1341,7 +1404,8 @@ class ConcatenatedModule extends Module {
 					break;
 				}
 			}
-			if (info.module.buildMeta.exportsType !== "namespace") {
+			const buildMeta = /** @type {BuildMeta} */ (info.module.buildMeta);
+			if (buildMeta.exportsType !== "namespace") {
 				const externalNameInterop = this.findNewName(
 					"namespaceObject",
 					allUsedNames,
@@ -1353,8 +1417,8 @@ class ConcatenatedModule extends Module {
 				topLevelDeclarations.add(externalNameInterop);
 			}
 			if (
-				info.module.buildMeta.exportsType === "default" &&
-				info.module.buildMeta.defaultObject !== "redirect"
+				buildMeta.exportsType === "default" &&
+				buildMeta.defaultObject !== "redirect"
 			) {
 				const externalNameInterop = this.findNewName(
 					"namespaceObject2",
@@ -1366,10 +1430,7 @@ class ConcatenatedModule extends Module {
 				info.interopNamespaceObject2Name = externalNameInterop;
 				topLevelDeclarations.add(externalNameInterop);
 			}
-			if (
-				info.module.buildMeta.exportsType === "dynamic" ||
-				!info.module.buildMeta.exportsType
-			) {
+			if (buildMeta.exportsType === "dynamic" || !buildMeta.exportsType) {
 				const externalNameInterop = this.findNewName(
 					"default",
 					allUsedNames,
@@ -1403,10 +1464,11 @@ class ConcatenatedModule extends Module {
 							neededNamespaceObjects,
 							match.call,
 							!match.directImport,
-							info.module.buildMeta.strictHarmonyModule,
+							/** @type {BuildMeta} */
+							(info.module.buildMeta).strictHarmonyModule,
 							match.asiSafe
 						);
-						const r = reference.identifier.range;
+						const r = /** @type {Range} */ (reference.identifier.range);
 						const source = info.source;
 						// range is extended by 2 chars to cover the appended "._"
 						source.replace(r[0], r[1] + 1, finalName);
@@ -1426,7 +1488,9 @@ class ConcatenatedModule extends Module {
 		const rootInfo = /** @type {ConcatenatedModuleInfo} */ (
 			moduleToInfoMap.get(this.rootModule)
 		);
-		const strictHarmonyModule = rootInfo.module.buildMeta.strictHarmonyModule;
+		const strictHarmonyModule =
+			/** @type {BuildMeta} */
+			(rootInfo.module.buildMeta).strictHarmonyModule;
 		const exportsInfo = moduleGraph.getExportsInfo(rootInfo.module);
 		for (const exportInfo of exportsInfo.orderedExports) {
 			const name = exportInfo.name;
@@ -1456,7 +1520,9 @@ class ConcatenatedModule extends Module {
 						exportInfo.isReexport() ? "reexport" : "binding"
 					} */ ${finalName}`;
 				} catch (e) {
-					e.message += `\nwhile generating the root export '${name}' (used name: '${used}')`;
+					/** @type {Error} */
+					(e).message +=
+						`\nwhile generating the root export '${name}' (used name: '${used}')`;
 					throw e;
 				}
 			});
@@ -1526,7 +1592,8 @@ class ConcatenatedModule extends Module {
 						neededNamespaceObjects,
 						false,
 						undefined,
-						info.module.buildMeta.strictHarmonyModule,
+						/** @type {BuildMeta} */
+						(info.module.buildMeta).strictHarmonyModule,
 						true
 					);
 					nsObj.push(
@@ -1697,7 +1764,9 @@ ${defineGetters}`
 					codeGenerationResults,
 					sourceTypes: TYPES
 				});
-				const source = codeGenResult.sources.get("javascript");
+				const source = /** @type {Source} */ (
+					codeGenResult.sources.get("javascript")
+				);
 				const data = codeGenResult.data;
 				const chunkInitFragments = data && data.get("chunkInitFragments");
 				const code = source.source().toString();
@@ -1729,7 +1798,7 @@ ${defineGetters}`
 					ignoreEval: true,
 					impliedStrict: true
 				});
-				const globalScope = scopeManager.acquire(ast);
+				const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
 				const moduleScope = globalScope.childScopes[0];
 				const resultSource = new ReplaceSource(source);
 				info.runtimeRequirements = codeGenResult.runtimeRequirements;
@@ -1740,7 +1809,9 @@ ${defineGetters}`
 				info.globalScope = globalScope;
 				info.moduleScope = moduleScope;
 			} catch (err) {
-				err.message += `\nwhile analyzing module ${m.identifier()} for concatenation`;
+				/** @type {Error} */
+				(err).message +=
+					`\nwhile analyzing module ${m.identifier()} for concatenation`;
 				throw err;
 			}
 		}
@@ -1808,7 +1879,10 @@ ${defineGetters}`
 							`Unsupported concatenation entry type ${info.type}`
 						);
 				}
-				map.set(item.module, item);
+				map.set(
+					/** @type {ModuleInfo} */ (item).module,
+					/** @type {ModuleInfo} */ (item)
+				);
 				return item;
 			} else {
 				/** @type {ReferenceToModuleInfo} */
@@ -1823,6 +1897,13 @@ ${defineGetters}`
 		return [list, map];
 	}
 
+	/**
+	 * @param {string} oldName old name
+	 * @param {UsedNames} usedNamed1 used named 1
+	 * @param {UsedNames} usedNamed2 used named 2
+	 * @param {string} extraInfo extra info
+	 * @returns {string} found new name
+	 */
 	findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 		let name = oldName;
 
@@ -1888,6 +1969,10 @@ ${defineGetters}`
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {ConcatenatedModule} ConcatenatedModule
+	 */
 	static deserialize(context) {
 		const obj = new ConcatenatedModule({
 			identifier: undefined,

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -56,7 +56,7 @@ class EnsureChunkConditionsPlugin {
 							// We reached the entrypoint: fail
 							if (chunkGroup.isInitial()) {
 								throw new Error(
-									"Cannot fullfil chunk condition of " + module.identifier()
+									"Cannot fulfil chunk condition of " + module.identifier()
 								);
 							}
 							// Try placing in all parents

package/lib/optimize/InnerGraph.js

@@ -9,6 +9,7 @@ const { UsageState } = require("../ExportsInfo");
 
 /** @typedef {import("estree").Node} AnyNode */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
@@ -295,7 +296,9 @@ exports.isDependencyUsedByExports = (
 ) => {
 	if (usedByExports === false) return false;
 	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule = moduleGraph.getParentModule(dependency);
+		const selfModule =
+			/** @type {Module} */
+			(moduleGraph.getParentModule(dependency));
 		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
 		let used = false;
 		for (const exportName of usedByExports) {
@@ -320,7 +323,9 @@ exports.getDependencyUsedByExportsCondition = (
 ) => {
 	if (usedByExports === false) return false;
 	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule = moduleGraph.getParentModule(dependency);
+		const selfModule =
+			/** @type {Module} */
+			(moduleGraph.getParentModule(dependency));
 		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
 		return (connections, runtime) => {
 			for (const exportName of usedByExports) {