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

package/lib/ExternalModuleFactoryPlugin.js

@@ -16,20 +16,28 @@ const ImportDependency = require("./dependencies/ImportDependency");
 const { coreModules } = require("./node/nodeBuiltins");
 const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge");
 
-/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("../declarations/WebpackOptions").ExternalsType} ExternalsType */
-/** @typedef {import("../declarations/WebpackOptions").ExternalItem} ExternalItem */
-/** @typedef {import("../declarations/WebpackOptions").ExternalItemValue} ExternalItemValue */
-/** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectKnown} ExternalItemObjectKnown */
-/** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectUnknown} ExternalItemObjectUnknown */
-/** @typedef {import("../declarations/WebpackOptions").ExternalItemInterop} ExternalItemInterop */
-/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./ExternalModule").DependencyMeta} DependencyMeta */
-/** @typedef {import("./ModuleFactory").IssuerLayer} IssuerLayer */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @import { ResolveContext } from "enhanced-resolve" */
+/**
+ * @import {
+ * 	ResolveOptions,
+ * 	ExternalsType,
+ * 	ExternalItem,
+ * 	ExternalItemValue,
+ * 	ExternalItemObjectKnown,
+ * 	ExternalItemObjectUnknown,
+ * 	ExternalItemInterop,
+ * 	Externals
+ * } from "../declarations/WebpackOptions"
+ */
+/** @import Dependency from "./Dependency" */
+/** @import { DependencyMeta, ExternalModuleRequest } from "./ExternalModule" */
+/**
+ * @import {
+ * 	IssuerLayer,
+ * 	ModuleFactoryCreateDataContextInfo
+ * } from "./ModuleFactory"
+ */
+/** @import NormalModuleFactory from "./NormalModuleFactory" */
 
 /** @typedef {((context: string, request: string, callback: (err?: Error | null, result?: string | false, resolveRequest?: import("enhanced-resolve").ResolveRequest) => void) => void)} ExternalItemFunctionDataGetResolveCallbackResult */
 /** @typedef {((context: string, request: string) => Promise<string>)} ExternalItemFunctionDataGetResolveResult */
@@ -43,6 +51,7 @@ const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge");
  * @property {string} dependencyType the category of the referencing dependency
  * @property {ExternalItemFunctionDataGetResolve} getResolve get a resolve function with the current resolver options
  * @property {string} request the request as written by the user in the require/import expression/statement
+ * @property {string} originalRequest same as `request`, except for an element of a context module (a request containing an expression), where it is the request as written by the user instead of the one relative to the resolved context directory
  */
 
 /** @typedef {((data: ExternalItemFunctionData, callback: (err?: (Error | null), result?: ExternalItemValue) => void) => void)} ExternalItemFunctionCallback */
@@ -115,7 +124,12 @@ const resolveLayer = (obj, layer) => {
 	return result;
 };
 
-/** @typedef {string | string[] | boolean | Record<string, string | string[]>} ExternalValue */
+// the keys `ExternalItemValueWithOptions` allows, mirroring the schema
+const OPTIONS_FORM_KEYS = new Set(["external", "sideEffects"]);
+
+/** @typedef {string | string[] | boolean | Record<string, string | string[]>} ExternalTargetValue */
+/** @typedef {{ external: ExternalTargetValue, sideEffects?: boolean }} ExternalValueWithOptions */
+/** @typedef {ExternalTargetValue | ExternalValueWithOptions} ExternalValue */
 
 const PLUGIN_NAME = "ExternalModuleFactoryPlugin";
 
@@ -145,6 +159,14 @@ class ExternalModuleFactoryPlugin {
 				const contextInfo = data.contextInfo;
 				const dependency = data.dependencies[0];
 				const dependencyType = data.dependencyType;
+				const request = dependency.request;
+				// a context element's request is relative to the resolved directory
+				// (`./file.mjs`), externals are written against what the user wrote
+				const originalRequest =
+					dependency instanceof ContextElementDependency
+						? dependency.originalRequest
+						: request;
+				const hasOriginalRequest = originalRequest !== request;
 
 				/** @typedef {(err?: Error | null, externalModule?: ExternalModule) => void} HandleExternalCallback */
 
@@ -156,12 +178,33 @@ class ExternalModuleFactoryPlugin {
 				 * @returns {void}
 				 */
 				const handleExternal = (value, type, callback) => {
-					if (value === false) {
+					/** @type {boolean | undefined} */
+					let sideEffects;
+					/** @type {ExternalTargetValue} */
+					let target;
+					// the options form carries the target under `external`; a target
+					// map holding an `external` type key keeps its own meaning
+					if (
+						typeof value === "object" &&
+						value !== null &&
+						!Array.isArray(value) &&
+						Object.prototype.hasOwnProperty.call(value, "external") &&
+						Object.keys(value).every((key) => OPTIONS_FORM_KEYS.has(key))
+					) {
+						const withOptions =
+							/** @type {ExternalValueWithOptions} */
+							(value);
+						sideEffects = withOptions.sideEffects;
+						target = withOptions.external;
+					} else {
+						target = /** @type {ExternalTargetValue} */ (value);
+					}
+					if (target === false) {
 						// Not externals, fallback to original factory
 						return callback();
 					}
-					/** @type {ExternalValue} */
-					let externalConfig = value === true ? dependency.request : value;
+					/** @type {ExternalModuleRequest} */
+					let externalConfig = target === true ? originalRequest : target;
 					// `interop` is a reserved key on the object form, not a target;
 					// pull it out so the rest stays a pure externalsType->request map.
 					/** @type {ExternalItemInterop | undefined} */
@@ -244,8 +287,12 @@ class ExternalModuleFactoryPlugin {
 						};
 					}
 
+					// a css `url()` reads the url out of the external: no js wrapper
+					// TODO webpack 6 drop "css-url" once the alias is removed
 					if (
-						resolvedType === "asset" &&
+						(resolvedType === "asset" ||
+							resolvedType === ASSET_URL_TYPE ||
+							resolvedType === "css-url") &&
 						dependency instanceof CssUrlDependency
 					) {
 						dependencyMeta = { sourceType: ASSET_URL_TYPE };
@@ -256,9 +303,10 @@ class ExternalModuleFactoryPlugin {
 						new ExternalModule(
 							externalConfig,
 							resolvedType,
-							dependency.request,
+							originalRequest,
 							dependencyMeta,
-							interop
+							interop,
+							sideEffects
 						)
 					);
 				};
@@ -272,10 +320,11 @@ class ExternalModuleFactoryPlugin {
 				const handleExternals = (externals, callback) => {
 					if (typeof externals === "string") {
 						if (
-							externals === dependency.request ||
-							externals === getAlternateCoreModuleRequest(dependency.request)
+							externals === request ||
+							(hasOriginalRequest && externals === originalRequest) ||
+							externals === getAlternateCoreModuleRequest(request)
 						) {
-							return handleExternal(dependency.request, undefined, callback);
+							return handleExternal(originalRequest, undefined, callback);
 						}
 					} else if (Array.isArray(externals)) {
 						let i = 0;
@@ -311,8 +360,11 @@ class ExternalModuleFactoryPlugin {
 						next();
 						return;
 					} else if (externals instanceof RegExp) {
-						if (externals.test(dependency.request)) {
-							return handleExternal(dependency.request, undefined, callback);
+						if (
+							externals.test(request) ||
+							(hasOriginalRequest && externals.test(originalRequest))
+						) {
+							return handleExternal(originalRequest, undefined, callback);
 						}
 					} else if (typeof externals === "function") {
 						/**
@@ -332,17 +384,13 @@ class ExternalModuleFactoryPlugin {
 						};
 						if (externals.length === 3) {
 							// TODO webpack 6 remove this
-							callDeprecatedExternals(
-								externals,
-								context,
-								dependency.request,
-								cb
-							);
+							callDeprecatedExternals(externals, context, request, cb);
 						} else {
 							const promise = externals(
 								{
 									context,
-									request: dependency.request,
+									request,
+									originalRequest,
 									dependencyType,
 									contextInfo,
 									getResolve: (options) => (context, request, callback) => {
@@ -401,21 +449,29 @@ class ExternalModuleFactoryPlugin {
 							(contextInfo.issuerLayer)
 						);
 						if (
+							Object.prototype.hasOwnProperty.call(resolvedExternals, request)
+						) {
+							return handleExternal(
+								resolvedExternals[request],
+								undefined,
+								callback
+							);
+						}
+						if (
+							hasOriginalRequest &&
 							Object.prototype.hasOwnProperty.call(
 								resolvedExternals,
-								dependency.request
+								originalRequest
 							)
 						) {
 							return handleExternal(
-								resolvedExternals[dependency.request],
+								resolvedExternals[originalRequest],
 								undefined,
 								callback
 							);
 						}
 						// Fall back to the `node:`-prefixed/unprefixed core module form.
-						const alternateRequest = getAlternateCoreModuleRequest(
-							dependency.request
-						);
+						const alternateRequest = getAlternateCoreModuleRequest(request);
 						if (
 							alternateRequest !== undefined &&
 							Object.prototype.hasOwnProperty.call(
@@ -439,4 +495,7 @@ class ExternalModuleFactoryPlugin {
 	}
 }
 
+ExternalModuleFactoryPlugin.getAlternateCoreModuleRequest =
+	getAlternateCoreModuleRequest;
+
 module.exports = ExternalModuleFactoryPlugin;

package/lib/ExternalsPlugin.js

@@ -9,11 +9,15 @@ const { ModuleExternalInitFragment } = require("./ExternalModule");
 const ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");
 const ConcatenatedModule = require("./optimize/ConcatenatedModule");
 
-/** @typedef {import("../declarations/WebpackOptions").ExternalsType} ExternalsType */
-/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./ExternalModule").Imported} Imported */
-/** @typedef {import("./Dependency")} Dependency */
+/**
+ * @import {
+ * 	ExternalsType,
+ * 	Externals
+ * } from "../declarations/WebpackOptions"
+ */
+/** @import Compiler from "./Compiler" */
+/** @import { Imported } from "./ExternalModule" */
+/** @import Dependency from "./Dependency" */
 
 const PLUGIN_NAME = "ExternalsPlugin";
 
@@ -53,7 +57,7 @@ class ExternalsPlugin {
 
 				const chunkInitFragments = moduleInfo.chunkInitFragments;
 				const moduleExternalInitFragments =
-					/** @type {ModuleExternalInitFragment[]} */
+					/** @type {InstanceType<ModuleExternalInitFragment>[]} */
 					(
 						chunkInitFragments
 							? /** @type {unknown[]} */

package/lib/FileSystemInfo.js

@@ -10,6 +10,7 @@ const { isAbsolute } = require("path");
 const { create: createResolver } = require("enhanced-resolve");
 const asyncLib = require("neo-async");
 const { DEFAULTS } = require("./config/defaults");
+const { collectCjsRequireSpecifiers } = require("./javascript/syntax");
 const AsyncQueue = require("./util/AsyncQueue");
 const StackedCacheMap = require("./util/StackedCacheMap");
 const createHash = require("./util/createHash");
@@ -18,16 +19,20 @@ const makeSerializable = require("./util/makeSerializable");
 const memoize = require("./util/memoize");
 const processAsyncTree = require("./util/processAsyncTree");
 
-/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
-/** @typedef {import("enhanced-resolve").ResolveFunctionAsync} ResolveFunctionAsync */
-/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
-/** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {import("./errors/WebpackError")} WebpackError */
-/** @typedef {import("./util/fs").JsonObject} JsonObject */
-/** @typedef {import("./util/fs").IStats} IStats */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+// only the mjs build-dependency walk needs it
+const getEsModuleLexer = memoize(() => require("es-module-lexer"));
+
+/** @import { ResolveRequest, ResolveFunctionAsync } from "enhanced-resolve" */
+/** @import { HashFunction } from "../declarations/WebpackOptions" */
+/** @import { Logger } from "./logging/Logger" */
+/** @import WebpackError from "./errors/WebpackError" */
+/** @import { JsonObject, IStats, InputFileSystem } from "./util/fs" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "./serialization/ObjectMiddleware"
+ */
 /**
  * Defines the processor callback type used by this module.
  * @template T
@@ -1202,6 +1207,15 @@ const getManagedItem = (managedPath, path) => {
 	return path.slice(0, i);
 };
 
+/**
+ * The managed directory a `snapshot.managedPaths` RegExp matched. The schema
+ * documents it as matching that directory, so a capture-less pattern is it.
+ * @param {RegExpExecArray} match a match of a managed path RegExp
+ * @returns {string} the managed directory
+ */
+const getManagedPathFromMatch = (match) =>
+	match[1] === undefined ? match[0] : match[1];
+
 /**
  * Gets resolved timestamp.
  * @template {ContextFileSystemInfoEntry | ContextTimestampAndHash} T
@@ -1235,60 +1249,10 @@ const addAll = (source, target) => {
 	for (const key of source) target.add(key);
 };
 
-const getEsModuleLexer = memoize(() => require("es-module-lexer"));
-
-const getAcorn = memoize(/* istanbul ignore next */ () => require("acorn"));
-
 // Bun doesn't populate `require.cache` `module.children`, so the CJS build-dependency
 // walk needs a source-parsing fallback there. Node/Deno populate it — never pay for it.
 const IS_BUN = Boolean(process.versions.bun);
 
-/**
- * Collects static `require("literal")` specifiers from CommonJS source. Used as a
- * fallback where `require.cache` children aren't populated (e.g. Bun), so build
- * dependencies of a CJS file are still tracked. Dynamic requires can't be seen here.
- * @param {string} source source
- * @returns {Set<string>} required specifiers
- */
-// Bun-only: exercised by BuildDependencies.longtest under the Bun CI job (no coverage upload).
-/* istanbul ignore next */
-const parseCjsRequires = (source) => {
-	/** @type {Set<string>} */
-	const requires = new Set();
-	const ast = getAcorn().parse(source, {
-		ecmaVersion: "latest",
-		sourceType: "script",
-		allowReturnOutsideFunction: true
-	});
-	/** @type {EXPECTED_ANY[]} */
-	const stack = [ast];
-	while (stack.length > 0) {
-		const node = stack.pop();
-		if (!node || typeof node.type !== "string") continue;
-		if (
-			node.type === "CallExpression" &&
-			node.callee.type === "Identifier" &&
-			node.callee.name === "require" &&
-			node.arguments.length === 1 &&
-			node.arguments[0].type === "Literal" &&
-			typeof node.arguments[0].value === "string"
-		) {
-			requires.add(node.arguments[0].value);
-		}
-		for (const key of Object.keys(node)) {
-			const value = node[key];
-			if (Array.isArray(value)) {
-				for (const item of value) {
-					if (item && typeof item.type === "string") stack.push(item);
-				}
-			} else if (value && typeof value.type === "string") {
-				stack.push(value);
-			}
-		}
-	}
-	return requires;
-};
-
 /** @typedef {Set<string>} LoggedPaths */
 
 /** @typedef {FileSystemInfoEntry | ExistenceOnlyTimeEntry | "ignore" | null} FileTimestamp */
@@ -2290,12 +2254,11 @@ class FileSystemInfo {
 									try {
 										const context = dirname(this.fs, path);
 										const source = /** @type {Buffer} */ (content).toString();
-										/** @type {Set<string>} */
-										const added = new Set();
-										for (const dependency of parseCjsRequires(source)) {
+										for (const dependency of collectCjsRequireSpecifiers(
+											source
+										)) {
 											if (dependency.startsWith("node:")) continue;
 											if (builtinModules.has(dependency)) continue;
-											if (added.has(dependency)) continue;
 											push({
 												type: RBDT_RESOLVE_CJS_FILE,
 												context,
@@ -2304,7 +2267,6 @@ class FileSystemInfo {
 												expected: false,
 												issuer: job
 											});
-											added.add(dependency);
 										}
 									} catch (_err) {
 										// Source we can't parse as CommonJS — ignore its dependencies.
@@ -2710,7 +2672,10 @@ class FileSystemInfo {
 			for (const managedPath of this.managedPathsRegExps) {
 				const match = managedPath.exec(path);
 				if (match) {
-					const managedItem = getManagedItem(match[1], path);
+					const managedItem = getManagedItem(
+						getManagedPathFromMatch(match),
+						path
+					);
 					if (managedItem) {
 						classificationCache.set(path, managedItem);
 						managedItems.add(managedItem);
@@ -3968,7 +3933,10 @@ class FileSystemInfo {
 					for (const managedPath of this.managedPathsRegExps) {
 						const match = managedPath.exec(path);
 						if (match) {
-							const managedItem = getManagedItem(match[1], path);
+							const managedItem = getManagedItem(
+								getManagedPathFromMatch(match),
+								path
+							);
 							if (managedItem) {
 								// construct timestampHash from managed info
 								return this.managedItemQueue.add(managedItem, (err, info) => {
@@ -4332,12 +4300,17 @@ class FileSystemInfo {
 		/**
 		 * Processes the provided timestamp.
 		 * @param {ContextTimestamp} timestamp timestamp
-		 * @param {ContextHash} hash hash
+		 * @param {ContextHash | null} hash hash
 		 */
 		const finalize = (timestamp, hash) => {
+			// Merging two `null` reads yields `{}`, which reads as "exists, no hash" (#21636)
 			const result =
 				/** @type {ContextTimestampAndHash} */
-				(timestamp === "ignore" ? hash : { ...timestamp, ...hash });
+				(
+					hash === null || timestamp === "ignore"
+						? hash
+						: { ...timestamp, ...hash }
+				);
 			this._contextTshs.set(path, result);
 			callback(null, result);
 		};
@@ -4655,5 +4628,6 @@ class FileSystemInfo {
 	}
 }
 
+FileSystemInfo.Snapshot = Snapshot;
+
 module.exports = FileSystemInfo;
-module.exports.Snapshot = Snapshot;

package/lib/FlagAllModulesAsUsedPlugin.js

@@ -7,9 +7,8 @@
 
 const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module").FactoryMeta} FactoryMeta */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import Compiler from "./Compiler" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 const PLUGIN_NAME = "FlagAllModulesAsUsedPlugin";
 class FlagAllModulesAsUsedPlugin {

package/lib/FlagDependencyExportsPlugin.js

@@ -7,25 +7,27 @@
 
 const asyncLib = require("neo-async");
 const Queue = require("./util/Queue");
+const { compareModulesByIdentifier } = require("./util/comparators");
 const createHash = require("./util/createHash");
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").ExportSpec} ExportSpec */
-/** @typedef {import("./Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./ExportsInfo").ExportInfoName} ExportInfoName */
-/** @typedef {import("./ExportsInfo").RestoreProvidedData} RestoreProvidedData */
-/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
-/** @typedef {import("./LazyBarrel")} LazyBarrelController */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @import Compiler from "./Compiler" */
+/** @import DependenciesBlock from "./DependenciesBlock" */
+/**
+ * @import Dependency, {
+ * 	ExportSpec,
+ * 	ExportsSpec,
+ * 	ExportInfoName
+ * } from "./Dependency"
+ */
+/** @import ExportsInfo, { RestoreProvidedData } from "./ExportsInfo" */
+/** @import { HashFunction } from "../declarations/WebpackOptions" */
+/** @import LazyBarrelController from "./LazyBarrel" */
+/** @import Module, { BuildInfo } from "./Module" */
 
 const PLUGIN_NAME = "FlagDependencyExportsPlugin";
 const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
 
-/** @typedef {{ etag: string, data: RestoreProvidedData }} MemCacheEntry */
+/** @typedef {{ etag: string, data: InstanceType<RestoreProvidedData> }} MemCacheEntry */
 
 /**
  * @param {Module} module the module
@@ -70,6 +72,8 @@ class FlagDependencyExportsPlugin {
 
 					/** @type {Queue<Module>} */
 					const queue = new Queue();
+					/** @type {Set<Module>} */
+					const modulesToAnalyse = new Set();
 
 					// Step 1: Try to restore cached provided export info from cache
 					logger.time("restore cached provided exports");
@@ -97,8 +101,8 @@ class FlagDependencyExportsPlugin {
 								"string"
 							) {
 								statFlaggedUncached++;
-								// Enqueue uncacheable module for determining the exports
-								queue.enqueue(module);
+								// Determined below, in a stable order
+								modulesToAnalyse.add(module);
 								exportsInfo.setHasProvideInfo();
 								return callback();
 							}
@@ -133,8 +137,8 @@ class FlagDependencyExportsPlugin {
 										exportsInfo.restoreProvided(result);
 									} else {
 										statNotCached++;
-										// Without cached info enqueue module for determining the exports
-										queue.enqueue(module);
+										// Without cached info determine the exports below
+										modulesToAnalyse.add(module);
 										exportsInfo.setHasProvideInfo();
 									}
 									callback();
@@ -145,6 +149,59 @@ class FlagDependencyExportsPlugin {
 							logger.timeEnd("restore cached provided exports");
 							if (err) return callback(err);
 
+							// Seed the queue with targets before the modules that read
+							// them. Enqueueing at the two branches above ordered the work by
+							// how fast each cache lookup answered — one is synchronous, the
+							// other a `cache.get` callback — so the persistent cache decided
+							// it. A module analysed before the module it re-exports from
+							// reads exports that are not determined yet and over-estimates,
+							// and this loop can add exports info but never retract it, so
+							// the over-estimate survives the pass that corrects it. The
+							// roots are sorted so the walk is stable, and post-order visits
+							// each module after everything it points at.
+							/** @type {Set<Module>} */
+							const visited = new Set();
+							/** @type {Module[]} */
+							const stack = [];
+							/** @type {Set<Module>} */
+							const expanded = new Set();
+							for (const root of [...modulesToAnalyse].sort(
+								compareModulesByIdentifier
+							)) {
+								if (visited.has(root)) continue;
+								stack.push(root);
+								while (stack.length > 0) {
+									const current = stack[stack.length - 1];
+									if (expanded.has(current)) {
+										stack.pop();
+										if (!visited.has(current)) {
+											visited.add(current);
+											if (modulesToAnalyse.has(current)) {
+												queue.enqueue(current);
+											}
+										}
+										continue;
+									}
+									expanded.add(current);
+									for (const connection of moduleGraph.getOutgoingConnections(
+										current
+									)) {
+										const target = connection.module;
+										// A module restored from cache is already final, so
+										// nothing has to be ordered before it and the walk stops
+										// there — on an incremental build that is most of them.
+										if (
+											target !== undefined &&
+											target !== null &&
+											modulesToAnalyse.has(target) &&
+											!expanded.has(target)
+										) {
+											stack.push(target);
+										}
+									}
+								}
+							}
+
 							/** @type {Set<Module>} */
 							const modulesToStore = new Set();
 
@@ -489,7 +546,7 @@ class FlagDependencyExportsPlugin {
 				}
 			);
 
-			/** @type {WeakMap<Module, RestoreProvidedData>} */
+			/** @type {WeakMap<Module, InstanceType<RestoreProvidedData>>} */
 			const providedExportsCache = new WeakMap();
 			compilation.hooks.rebuildModule.tap(PLUGIN_NAME, (module) => {
 				providedExportsCache.set(
@@ -499,7 +556,7 @@ class FlagDependencyExportsPlugin {
 			});
 			compilation.hooks.finishRebuildingModule.tap(PLUGIN_NAME, (module) => {
 				moduleGraph.getExportsInfo(module).restoreProvided(
-					/** @type {RestoreProvidedData} */
+					/** @type {InstanceType<RestoreProvidedData>} */
 					(providedExportsCache.get(module))
 				);
 			});