webpack 5.107.2 → 5.108.0

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -22,6 +22,7 @@ const {
 } = require("../util/runtime");
 const ConcatenatedModule = require("./ConcatenatedModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
@@ -30,6 +31,26 @@ const ConcatenatedModule = require("./ConcatenatedModule");
 
 /** @typedef {Module | ((requestShortener: RequestShortener) => string)} Problem */
 
+/**
+ * Merged runtime of all chunks a module is in, memoized for the whole pass.
+ * Safe: the chunk graph is not mutated while configurations are built.
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Map<Module, RuntimeSpec>} cache memoization cache
+ * @param {Module} module the module
+ * @returns {RuntimeSpec} the merged runtime
+ */
+const getMergedModuleRuntime = (chunkGraph, cache, module) => {
+	const cached = cache.get(module);
+	if (cached !== undefined || cache.has(module)) return cached;
+	/** @type {RuntimeSpec} */
+	let runtime;
+	for (const r of chunkGraph.getModuleRuntimes(module)) {
+		runtime = mergeRuntimeOwned(runtime, r);
+	}
+	cache.set(module, runtime);
+	return runtime;
+};
+
 /**
  * Defines the statistics type used by this module.
  * @typedef {object} Statistics
@@ -285,17 +306,20 @@ class ModuleConcatenationPlugin {
 					const concatConfigurations = [];
 					/** @type {Set<Module>} */
 					const usedAsInner = new Set();
+					// module -> merged runtime of its chunks, shared across all roots
+					/** @type {Map<Module, RuntimeSpec>} */
+					const moduleRuntimeCache = new Map();
 					for (const currentRoot of relevantModules) {
 						// when used by another configuration as inner:
 						// the other configuration is better and we can skip this one
 						// TODO reconsider that when it's only used in a different runtime
 						if (usedAsInner.has(currentRoot)) continue;
 
-						/** @type {RuntimeSpec} */
-						let chunkRuntime;
-						for (const r of chunkGraph.getModuleRuntimes(currentRoot)) {
-							chunkRuntime = mergeRuntimeOwned(chunkRuntime, r);
-						}
+						const chunkRuntime = getMergedModuleRuntime(
+							chunkGraph,
+							moduleRuntimeCache,
+							currentRoot
+						);
 						const exportsInfo = moduleGraph.getExportsInfo(currentRoot);
 						const filteredRuntime = filterRuntime(chunkRuntime, (r) =>
 							exportsInfo.isModuleUsed(r)
@@ -307,10 +331,12 @@ class ModuleConcatenationPlugin {
 									? undefined
 									: filteredRuntime;
 
-						// create a configuration with the root
+						// create a configuration with the root; cache the root's chunks once
+						// so every candidate check reuses them instead of re-materializing
 						const currentConfiguration = new ConcatConfiguration(
 							currentRoot,
-							activeRuntime
+							activeRuntime,
+							[...chunkGraph.getModuleChunksIterable(currentRoot)]
 						);
 
 						// cache failures to add modules
@@ -342,6 +368,7 @@ class ModuleConcatenationPlugin {
 								possibleInners,
 								impCandidates,
 								failureCache,
+								moduleRuntimeCache,
 								chunkGraph,
 								true,
 								stats
@@ -387,10 +414,10 @@ class ModuleConcatenationPlugin {
 					logger.debug(
 						`${statsCandidates} candidates were considered for adding (${stats.cached} cached failure, ${stats.alreadyInConfig} already in config, ${stats.invalidModule} invalid module, ${stats.incorrectChunks} incorrect chunks, ${stats.incorrectDependency} incorrect dependency, ${stats.incorrectChunksOfImporter} incorrect chunks of importer, ${stats.incorrectModuleDependency} incorrect module dependency, ${stats.incorrectRuntimeCondition} incorrect runtime condition, ${stats.importerFailed} importer failed, ${stats.added} added)`
 					);
-					// HACK: Sort configurations by length and start with the longest one
-					// to get the biggest groups possible. Used modules are marked with usedModules
-					// TODO: Allow to reuse existing configuration while trying to add dependencies.
-					// This would improve performance. O(n^2) -> O(n)
+					// Create the largest configurations first: if a root also ended up inside
+					// a bigger configuration, the bigger one wins (smaller skipped below).
+					// Configurations can't be reused across roots: a module shared by several
+					// chunks is concatenated into each consumer (module duplication).
 					logger.time("sort concat configurations");
 					concatConfigurations.sort((a, b) => b.modules.size - a.modules.size);
 					logger.timeEnd("sort concat configurations");
@@ -403,8 +430,8 @@ class ModuleConcatenationPlugin {
 						(concatConfiguration, callback) => {
 							const rootModule = concatConfiguration.rootModule;
 
-							// Avoid overlapping configurations
-							// TODO: remove this when todo above is fixed
+							// Root already concatenated into a larger configuration: skip.
+							// (Inner modules may still be shared, e.g. duplicated across entries.)
 							if (usedModules.has(rootModule)) return callback();
 							const modules = concatConfiguration.getModules();
 							for (const m of modules) {
@@ -586,6 +613,7 @@ class ModuleConcatenationPlugin {
 	 * @param {Set<Module>} possibleModules modules that are candidates
 	 * @param {Set<Module>} candidates list of potential candidates (will be added to)
 	 * @param {Map<Module, Problem>} failureCache cache for problematic modules to be more performant
+	 * @param {Map<Module, RuntimeSpec>} moduleRuntimeCache memoized merged runtime per module, shared across roots
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {boolean} avoidMutateOnFailure avoid mutating the config when adding fails
 	 * @param {Statistics} statistics gathering metrics
@@ -600,6 +628,7 @@ class ModuleConcatenationPlugin {
 		possibleModules,
 		candidates,
 		failureCache,
+		moduleRuntimeCache,
 		chunkGraph,
 		avoidMutateOnFailure,
 		statistics
@@ -624,9 +653,9 @@ class ModuleConcatenationPlugin {
 		}
 
 		// Module must be in the correct chunks
-		const missingChunks = [
-			...chunkGraph.getModuleChunksIterable(config.rootModule)
-		].filter((chunk) => !chunkGraph.isModuleInChunk(module, chunk));
+		const missingChunks = config.rootChunks.filter(
+			(chunk) => !chunkGraph.isModuleInChunk(module, chunk)
+		);
 		if (missingChunks.length > 0) {
 			/**
 			 * Returns problem description.
@@ -707,11 +736,11 @@ class ModuleConcatenationPlugin {
 				if (chunkGraph.getNumberOfModuleChunks(originModule) === 0) continue;
 
 				// We don't care for connections from other runtimes
-				/** @type {RuntimeSpec} */
-				let originRuntime;
-				for (const r of chunkGraph.getModuleRuntimes(originModule)) {
-					originRuntime = mergeRuntimeOwned(originRuntime, r);
-				}
+				const originRuntime = getMergedModuleRuntime(
+					chunkGraph,
+					moduleRuntimeCache,
+					originModule
+				);
 
 				if (!intersectRuntime(runtime, originRuntime)) continue;
 
@@ -729,9 +758,7 @@ class ModuleConcatenationPlugin {
 
 		// Module must be in the same chunks like the referencing module
 		const otherChunkModules = incomingModules.filter((originModule) => {
-			for (const chunk of chunkGraph.getModuleChunksIterable(
-				config.rootModule
-			)) {
+			for (const chunk of config.rootChunks) {
 				if (!chunkGraph.isModuleInChunk(originModule, chunk)) {
 					return true;
 				}
@@ -881,6 +908,7 @@ class ModuleConcatenationPlugin {
 				possibleModules,
 				candidates,
 				failureCache,
+				moduleRuntimeCache,
 				chunkGraph,
 				false,
 				statistics
@@ -909,12 +937,15 @@ class ConcatConfiguration {
 	 * Creates an instance of ConcatConfiguration.
 	 * @param {Module} rootModule the root module
 	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Chunk[]} rootChunks the chunks the root module is in
 	 */
-	constructor(rootModule, runtime) {
+	constructor(rootModule, runtime, rootChunks) {
 		/** @type {Module} */
 		this.rootModule = rootModule;
 		/** @type {RuntimeSpec} */
 		this.runtime = runtime;
+		/** @type {Chunk[]} the root's chunks, reused for every candidate's chunk check */
+		this.rootChunks = rootChunks;
 		/** @type {Set<Module>} */
 		this.modules = new Set();
 		this.modules.add(rootModule);

package/lib/optimize/RealContentHashPlugin.js

@@ -241,12 +241,21 @@ class RealContentHashPlugin {
 					const assetsWithInfo = [];
 					/** @type {Map<string, [AssetInfoForRealContentHash]>} */
 					const hashToAssets = new Map();
+					// Inline `[contenthash:<digest>]` digest per hash, so the recomputed
+					// real hash is re-encoded in it instead of `output.hashDigest`.
+					/** @type {Map<string, string>} */
+					const hashToDigest = new Map();
 					for (const { source, info, name } of assets) {
 						const cachedSource = toCachedSource(source);
 						const content = /** @type {string} */ (cachedSource.source());
 						/** @type {Hashes} */
 						const hashes = new Set();
 						addToList(info.contenthash, hashes);
+						if (info.contenthashDigest) {
+							for (const hash of Object.keys(info.contenthashDigest)) {
+								hashToDigest.set(hash, info.contenthashDigest[hash]);
+							}
+						}
 						/** @type {AssetInfoForRealContentHash} */
 						const data = {
 							name,
@@ -519,7 +528,11 @@ ${referencingAssets
 							for (const chunks of uniqueChunkArrays) {
 								for (const c of chunks) hash.update(c);
 							}
-							const digest = hash.digest(this._hashDigest);
+							const digest = hash.digest(
+								/** @type {HashDigest} */ (
+									hashToDigest.get(oldHash) || this._hashDigest
+								)
+							);
 							newHash = digest.slice(0, oldHash.length);
 						}
 						hashToNewHash.set(oldHash, newHash);

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const glob2regexp = require("glob-to-regexp");
+const glob2regexp = require("watchpack").util.globToRegExp;
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
@@ -25,10 +25,16 @@ const { CompilerHintNotationRegExp } = require("../util/magicComment");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("../ExportsInfo").TargetItemWithConnection} TargetItemWithConnection */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 
 /**
  * Defines the export in module type used by this module.
@@ -57,9 +63,8 @@ const globToRegexp = (glob, cache) => {
 	if (!glob.includes("/")) {
 		glob = `**/${glob}`;
 	}
-	const baseRegexp = glob2regexp(glob, { globstar: true, extended: true });
-	const regexpSource = baseRegexp.source;
-	const regexp = new RegExp(`^(\\./)?${regexpSource.slice(1)}`);
+	const regexpSource = glob2regexp(glob);
+	const regexp = new RegExp(`^(\\./)?${regexpSource}$`);
 	cache.set(glob, regexp);
 	return regexp;
 };
@@ -84,6 +89,39 @@ const hasNoSideEffectsNotation = (parser, start, end) => {
 
 const PLUGIN_NAME = "SideEffectsFlagPlugin";
 
+const notSideEffectsTag = Symbol("NoSideEffects");
+
+/** @type {(target: { module: Module }) => boolean} */
+const RETURNS_FALSE = () => false;
+
+/**
+ * Detects if the module is "pure single-star passthrough": one whose entire export
+ * surface is exactly one `export * from "x"` (no named/local/default-bearing
+ * exports, no second star). For such a module `export * from "passthrough"` is
+ * equivalent to `export * from "x"`, so the passthrough can be skipped.
+ * @param {Module} module the candidate passthrough module
+ * @returns {boolean} true when the module is a pure single-star passthrough
+ */
+const moduleHasSingleStarReexport = (module) => {
+	/** @type {HarmonyExportImportedSpecifierDependency | undefined} */
+	let starReexportDep;
+	for (const dep of module.dependencies) {
+		if (!(dep instanceof HarmonyExportImportedSpecifierDependency)) continue;
+		// a named re-export (`export { x } from` / `export * as ns from`) means
+		// the module owns names a star into its source wouldn't reproduce
+		if (dep.name !== null) return false;
+		// any named/local export populates the shared activeExports set
+		if (dep.activeExports.size !== 0) return false;
+		// more than one `export *` can't be collapsed to a single source
+		if (dep.allStarExports && dep.allStarExports.dependencies.length !== 1) {
+			return false;
+		}
+		starReexportDep = dep;
+	}
+	if (starReexportDep === undefined) return false;
+	return true;
+};
+
 class SideEffectsFlagPlugin {
 	/**
 	 * Creates an instance of SideEffectsFlagPlugin.
@@ -282,24 +320,51 @@ class SideEffectsFlagPlugin {
 
 					/**
 					 * @param {JavascriptParser} parser the parser
+					 * @param {JavascriptParserOptions} parserOptions the parser options
 					 * @returns {void}
 					 */
-					const applyNoSideEffectsNotationHandler = (parser) => {
-						/** @type {Set<string>} */
-						let noSideEffectsFnNames;
+					const applyNoSideEffectsNotationHandler = (parser, parserOptions) => {
+						/** @type {Set<string> | undefined} */
+						let pureFunctions;
+
+						const pureFunctionsFromOption =
+							parserOptions &&
+							Array.isArray(parserOptions.pureFunctions) &&
+							parserOptions.pureFunctions.length > 0
+								? new Set(parserOptions.pureFunctions)
+								: undefined;
 
 						parser.hooks.program.tap(PLUGIN_NAME, () => {
-							noSideEffectsFnNames = new Set();
+							pureFunctions = undefined;
 						});
 
+						/**
+						 * @param {string} name function name
+						 */
+						const markPure = (name) => {
+							if (pureFunctions === undefined) pureFunctions = new Set();
+							else if (pureFunctions.has(name)) return;
+							parser.tagVariable(name, notSideEffectsTag, {});
+							pureFunctions.add(name);
+						};
+
 						// Detect on function declarations
 						// Covers:
 						// 	1. function foo
 						//  2. export function foo
 						//  3. export default function foo
+						// 	4. export default function / export default () => {} (anonymous)
 						parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
 							if (parser.scope.topLevelScope !== true) return;
-							if (statement.type !== "FunctionDeclaration" || !statement.id) {
+							if (statement.type !== "FunctionDeclaration") {
+								return;
+							}
+							const name = statement.id ? statement.id.name : "default";
+							if (
+								pureFunctionsFromOption &&
+								pureFunctionsFromOption.has(name)
+							) {
+								markPure(name);
 								return;
 							}
 							const commentsStart = parser.prevStatement
@@ -312,14 +377,22 @@ class SideEffectsFlagPlugin {
 									/** @type {Range} */ (statement.range)[0]
 								)
 							) {
-								noSideEffectsFnNames.add(statement.id.name);
+								markPure(name);
 							}
 						});
 
 						// Detect on variable declarations with function init
 						parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
 							if (parser.scope.topLevelScope !== true) return;
-							if (!decl.init || decl.id.type !== "Identifier") return;
+							if (decl.id.type !== "Identifier") return;
+							if (
+								pureFunctionsFromOption &&
+								pureFunctionsFromOption.has(decl.id.name)
+							) {
+								markPure(decl.id.name);
+								return;
+							}
+							if (!decl.init) return;
 							if (!decl.init.type.endsWith("FunctionExpression")) return;
 
 							let hasAnnotation = false;
@@ -343,25 +416,60 @@ class SideEffectsFlagPlugin {
 								);
 							}
 							if (hasAnnotation) {
-								noSideEffectsFnNames.add(decl.id.name);
+								markPure(decl.id.name);
 							}
 						});
 
-						// Mark calls to annotated functions as pure
+						if (pureFunctionsFromOption) {
+							parser.hooks.blockPreStatement.tap(PLUGIN_NAME, (statement) => {
+								if (parser.scope.topLevelScope !== true) return;
+								if (
+									statement.type === "ExportDefaultDeclaration" &&
+									pureFunctionsFromOption.has("default")
+								) {
+									const decl = statement.declaration;
+									if (
+										decl.type === "ArrowFunctionExpression" ||
+										decl.type === "FunctionExpression"
+									) {
+										markPure("default");
+									}
+								}
+							});
+						}
+
 						parser.hooks.isPure
 							.for("CallExpression")
 							.tap(PLUGIN_NAME, (expression, commentsStartPos) => {
 								const expr = /** @type {CallExpression} */ (expression);
 								if (expr.callee.type !== "Identifier") return;
-								if (!noSideEffectsFnNames.has(expr.callee.name)) return;
+								if (!parser.getTagData(expr.callee.name, notSideEffectsTag)) {
+									return;
+								}
 								commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
-								for (const arg of expr.arguments) {
-									if (arg.type === "SpreadElement") return;
-									if (!parser.isPure(arg, commentsStartPos)) return;
+								return expr.arguments.every((arg) => {
+									if (arg.type === "SpreadElement") return false;
+									const pure = parser.isPure(arg, commentsStartPos);
 									commentsStartPos = /** @type {Range} */ (arg.range)[1];
-								}
-								return true;
+									return pure;
+								});
 							});
+
+						parser.hooks.finish.tap(PLUGIN_NAME, () => {
+							if (pureFunctions === undefined || pureFunctions.size === 0) {
+								return;
+							}
+							const buildInfo = /** @type {JavascriptModuleBuildInfo} */ (
+								parser.state.module.buildInfo
+							);
+							if (buildInfo.pureFunctions) {
+								for (const fn of pureFunctions) {
+									buildInfo.pureFunctions.add(fn);
+								}
+							} else {
+								buildInfo.pureFunctions = pureFunctions;
+							}
+						});
 					};
 
 					for (const key of [
@@ -371,8 +479,8 @@ class SideEffectsFlagPlugin {
 					]) {
 						normalModuleFactory.hooks.parser
 							.for(key)
-							.tap(PLUGIN_NAME, (parser) => {
-								applyNoSideEffectsNotationHandler(parser);
+							.tap(PLUGIN_NAME, (parser, parserOptions) => {
+								applyNoSideEffectsNotationHandler(parser, parserOptions);
 								applySideEffectsStmtHandler(parser);
 							});
 					}
@@ -392,6 +500,31 @@ class SideEffectsFlagPlugin {
 						/** @type {Set<Module>} */
 						const optimizedModules = new Set();
 
+						// Re-export resolution is idempotent within a pass, so cache it
+						// per export info: a shared barrel imported by many modules
+						// resolves each name once instead of once per consumer.
+						/** @type {Map<ExportInfo, TargetItemWithConnection | null>} */
+						const reexportTargetCache = new Map();
+
+						// Dependencies don't change within the pass, so the passthrough
+						// check is cached per module across all moveTarget filter calls.
+						/** @type {Map<Module, boolean>} */
+						const singleStarReexportCache = new Map();
+
+						/**
+						 * Cached variant of moduleHasSingleStarReexport.
+						 * @param {Module} module the candidate passthrough module
+						 * @returns {boolean} true when the module is a pure single-star passthrough
+						 */
+						const hasSingleStarReexport = (module) => {
+							let result = singleStarReexportCache.get(module);
+							if (result === undefined) {
+								result = moduleHasSingleStarReexport(module);
+								singleStarReexportCache.set(module, result);
+							}
+							return result;
+						};
+
 						/**
 						 * Optimize incoming connections.
 						 * @param {Module} module module
@@ -417,56 +550,93 @@ class SideEffectsFlagPlugin {
 										if (connection.originModule !== null) {
 											optimizeIncomingConnections(connection.originModule);
 										}
-										// TODO improve for export *
-										if (isReexport && dep.name) {
-											const exportInfo = moduleGraph.getExportInfo(
-												/** @type {Module} */ (connection.originModule),
-												dep.name
-											);
-											exportInfo.moveTarget(
-												moduleGraph,
-												({ module }) =>
-													module.getSideEffectsConnectionState(moduleGraph) ===
-													false,
-												({
-													module: newModule,
-													export: exportName,
-													connection: targetConnection
-												}) => {
-													moduleGraph.updateModule(dep, newModule);
-													moduleGraph.updateParent(
-														dep,
-														targetConnection,
+
+										if (isReexport) {
+											if (!dep.name && !hasSingleStarReexport(module)) continue;
+
+											const infos = dep.name
+												? // Named re-exports resolve their single target here;
+													// e.g. `export * as foo from "mod"` / `export { dep as name } from "mod"`
+													[
+														moduleGraph.getExportInfo(
+															/** @type {Module} */ (connection.originModule),
+															dep.name
+														)
+													]
+												: moduleGraph.getExportsInfo(
 														/** @type {Module} */ (connection.originModule)
-													);
-													moduleGraph.addExplanation(
-														dep,
-														"(skipped side-effect-free modules)"
-													);
-													const ids = dep.getIds(moduleGraph);
-													dep.setIds(
-														moduleGraph,
-														exportName
-															? [...exportName, ...ids.slice(1)]
-															: ids.slice(1)
-													);
-													return /** @type {ModuleGraphConnection} */ (
-														moduleGraph.getConnection(dep)
-													);
+													).exports;
+
+											for (const exportInfo of infos) {
+												const immediate = exportInfo.getTarget(
+													moduleGraph,
+													RETURNS_FALSE
+												);
+												if (
+													immediate === undefined ||
+													immediate.connection.dependency !== dep
+												) {
+													continue;
 												}
-											);
+
+												exportInfo.moveTarget(
+													moduleGraph,
+													({ module }) =>
+														module.getSideEffectsConnectionState(
+															moduleGraph
+														) === false &&
+														(Boolean(dep.name) ||
+															hasSingleStarReexport(
+																/** @type {Module} */ (module)
+															)),
+													({
+														module: newModule,
+														export: exportName,
+														connection: targetConnection
+													}) => {
+														moduleGraph.updateModule(dep, newModule);
+														moduleGraph.updateParent(
+															dep,
+															targetConnection,
+															/** @type {Module} */ (connection.originModule)
+														);
+														moduleGraph.addExplanation(
+															dep,
+															"(skipped side-effect-free modules)"
+														);
+														const ids = dep.getIds(moduleGraph);
+														if (ids.length) {
+															dep.setIds(
+																moduleGraph,
+																exportName
+																	? [...exportName, ...ids.slice(1)]
+																	: ids.slice(1)
+															);
+														}
+														return /** @type {ModuleGraphConnection} */ (
+															moduleGraph.getConnection(dep)
+														);
+													}
+												);
+											}
 											continue;
 										}
-										// TODO improve for nested imports
+
 										const ids = dep.getIds(moduleGraph);
 										if (ids.length > 0) {
 											const exportInfo = exportsInfo.getExportInfo(ids[0]);
-											const target = exportInfo.getTarget(
-												moduleGraph,
-												({ module }) =>
-													module.getSideEffectsConnectionState(moduleGraph) ===
-													false
-											);
+											let target = reexportTargetCache.get(exportInfo);
+											if (target === undefined) {
+												target =
+													exportInfo.getTarget(
+														moduleGraph,
+														({ module }) =>
+															module.getSideEffectsConnectionState(
+																moduleGraph
+															) === false
+													) || null;
+												reexportTargetCache.set(exportInfo, target);
+											}
 											if (!target) continue;
 
 											moduleGraph.updateModule(dep, target.module);