webpack 5.90.0 → 5.90.2

package/lib/APIPlugin.js

@@ -24,10 +24,12 @@ const ChunkNameRuntimeModule = require("./runtime/ChunkNameRuntimeModule");
 const GetFullHashRuntimeModule = require("./runtime/GetFullHashRuntimeModule");
 
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./javascript/JavascriptParser").Range} Range */
 
 /**
- * @param {boolean} module true if ES module
+ * @param {boolean | undefined} module true if ES module
  * @param {string} importMetaName `import.meta` name
  * @returns {Record<string, {expr: string, req: string[] | null, type?: string, assign: boolean}>} replacements
  */
@@ -150,7 +152,9 @@ class APIPlugin {
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
-				const { importMetaName } = compilation.outputOptions;
+				const importMetaName = /** @type {string} */ (
+					compilation.outputOptions.importMetaName
+				);
 				const REPLACEMENTS = getReplacements(
 					this.options.module,
 					importMetaName
@@ -166,7 +170,7 @@ class APIPlugin {
 					.tap(PLUGIN_NAME, chunk => {
 						compilation.addRuntimeModule(
 							chunk,
-							new ChunkNameRuntimeModule(chunk.name)
+							new ChunkNameRuntimeModule(/** @type {string} */ (chunk.name))
 						);
 						return true;
 					});
@@ -218,7 +222,7 @@ class APIPlugin {
 						if (info.assign === false) {
 							parser.hooks.assign.for(key).tap(PLUGIN_NAME, expr => {
 								const err = new WebpackError(`${key} must not be assigned`);
-								err.loc = expr.loc;
+								err.loc = /** @type {DependencyLocation} */ (expr.loc);
 								throw err;
 							});
 						}
@@ -234,9 +238,9 @@ class APIPlugin {
 						.tap(PLUGIN_NAME, expr => {
 							const dep = new ConstDependency(
 								JSON.stringify(parser.state.module.layer),
-								expr.range
+								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
@@ -248,7 +252,7 @@ class APIPlugin {
 								: new BasicEvaluatedExpression().setString(
 										parser.state.module.layer
 									)
-							).setRange(expr.range)
+							).setRange(/** @type {Range} */ (expr.range))
 						);
 					parser.hooks.evaluateTypeof
 						.for("__webpack_layer__")
@@ -257,7 +261,7 @@ class APIPlugin {
 								.setString(
 									parser.state.module.layer === null ? "object" : "string"
 								)
-								.setRange(expr.range)
+								.setRange(/** @type {Range} */ (expr.range))
 						);
 
 					parser.hooks.expression
@@ -267,10 +271,10 @@ class APIPlugin {
 								"__webpack_module__.id";
 							const dep = new ConstDependency(
 								parser.state.module.moduleArgument + ".id",
-								expr.range,
+								/** @type {Range} */ (expr.range),
 								[RuntimeGlobals.moduleId]
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
@@ -282,10 +286,10 @@ class APIPlugin {
 								"__webpack_module__";
 							const dep = new ConstDependency(
 								parser.state.module.moduleArgument,
-								expr.range,
+								/** @type {Range} */ (expr.range),
 								[RuntimeGlobals.module]
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});

package/lib/Compilation.js

@@ -1087,7 +1087,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
-	 * @param {StatsOptions | string} optionsOrPreset stats option value
+	 * @param {StatsOptions | string | undefined} optionsOrPreset stats option value
 	 * @param {CreateStatsOptionsContext} context context
 	 * @returns {NormalizedStatsOptions} normalized options
 	 */

package/lib/ConditionalInitFragment.js

@@ -62,8 +62,8 @@ class ConditionalInitFragment extends InitFragment {
 	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source} the source code that will be included as initialization code
 	 */
 	getContent(context) {
 		if (this.runtimeCondition === false || !this.content) return "";
@@ -79,7 +79,7 @@ class ConditionalInitFragment extends InitFragment {
 	}
 
 	/**
-	 * @param {Context} context context
+	 * @param {GenerateContext} context context
 	 * @returns {string|Source=} the source code that will be included at the end of the module
 	 */
 	getEndContent(context) {

package/lib/DefinePlugin.js

@@ -23,9 +23,11 @@ const createHash = require("./util/createHash");
 
 /** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./NormalModule")} NormalModule */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./javascript/JavascriptParser").Range} Range */
 /** @typedef {import("./logging/Logger").Logger} Logger */
 
 /** @typedef {null|undefined|RegExp|Function|string|number|boolean|bigint|undefined} CodeValuePrimitive */
@@ -66,7 +68,7 @@ class RuntimeValue {
 	 * @returns {CodeValuePrimitive} code
 	 */
 	exec(parser, valueCacheVersions, key) {
-		const buildInfo = parser.state.module.buildInfo;
+		const buildInfo = /** @type {BuildInfo} */ (parser.state.module.buildInfo);
 		if (this.options === true) {
 			buildInfo.cacheable = false;
 		} else {
@@ -136,19 +138,21 @@ const stringifyObj = (
 	let code;
 	let arr = Array.isArray(obj);
 	if (arr) {
-		code = `[${obj
-			.map(code =>
-				toCode(
-					code,
-					parser,
-					valueCacheVersions,
-					key,
-					runtimeTemplate,
-					logger,
-					null
+		code = `[${
+			/** @type {any[]} */ (obj)
+				.map(code =>
+					toCode(
+						code,
+						parser,
+						valueCacheVersions,
+						key,
+						runtimeTemplate,
+						logger,
+						null
+					)
 				)
-			)
-			.join(",")}]`;
+				.join(",")
+		}]`;
 	} else {
 		let keys = Object.keys(obj);
 		if (objKeys) {
@@ -157,7 +161,7 @@ const stringifyObj = (
 		}
 		code = `{${keys
 			.map(key => {
-				const code = obj[key];
+				const code = /** @type {{[k: string]: any}} */ (obj)[key];
 				return (
 					JSON.stringify(key) +
 					":" +
@@ -263,6 +267,10 @@ const toCode = (
 	return strCode;
 };
 
+/**
+ * @param {CodeValue} code code
+ * @returns {string | undefined} result
+ */
 const toCacheVersion = code => {
 	if (code === null) {
 		return "null";
@@ -285,7 +293,7 @@ const toCacheVersion = code => {
 	if (typeof code === "object") {
 		const items = Object.keys(code).map(key => ({
 			key,
-			value: toCacheVersion(code[key])
+			value: toCacheVersion(/** @type {Record<string, any>} */ (code)[key])
 		}));
 		if (items.some(({ value }) => value === undefined)) return undefined;
 		return `{${items.map(({ key, value }) => `${key}: ${value}`).join(", ")}}`;
@@ -353,14 +361,21 @@ class DefinePlugin {
 				const handler = parser => {
 					const mainValue = compilation.valueCacheVersions.get(VALUE_DEP_MAIN);
 					parser.hooks.program.tap(PLUGIN_NAME, () => {
-						const { buildInfo } = parser.state.module;
+						const buildInfo = /** @type {BuildInfo} */ (
+							parser.state.module.buildInfo
+						);
 						if (!buildInfo.valueDependencies)
 							buildInfo.valueDependencies = new Map();
 						buildInfo.valueDependencies.set(VALUE_DEP_MAIN, mainValue);
 					});
 
+					/**
+					 * @param {string} key key
+					 */
 					const addValueDependency = key => {
-						const { buildInfo } = parser.state.module;
+						const buildInfo = /** @type {BuildInfo} */ (
+							parser.state.module.buildInfo
+						);
 						buildInfo.valueDependencies.set(
 							VALUE_DEP_PREFIX + key,
 							compilation.valueCacheVersions.get(VALUE_DEP_PREFIX + key)
@@ -376,7 +391,7 @@ class DefinePlugin {
 
 					/**
 					 * Walk definitions
-					 * @param {Object} definitions Definitions map
+					 * @param {Record<string, CodeValue>} definitions Definitions map
 					 * @param {string} prefix Prefix string
 					 * @returns {void}
 					 */
@@ -389,7 +404,10 @@ class DefinePlugin {
 								!(code instanceof RuntimeValue) &&
 								!(code instanceof RegExp)
 							) {
-								walkDefinitions(code, prefix + key + ".");
+								walkDefinitions(
+									/** @type {Record<string, CodeValue>} */ (code),
+									prefix + key + "."
+								);
 								applyObjectDefine(prefix + key, code);
 								return;
 							}
@@ -458,7 +476,7 @@ class DefinePlugin {
 										)
 									);
 									recurse = false;
-									res.setRange(expr.range);
+									res.setRange(/** @type {Range} */ (expr.range));
 									return res;
 								});
 							parser.hooks.expression.for(key).tap(PLUGIN_NAME, expr => {
@@ -470,7 +488,7 @@ class DefinePlugin {
 									originalKey,
 									runtimeTemplate,
 									logger,
-									!parser.isAsiPosition(expr.range[0]),
+									!parser.isAsiPosition(/** @type {Range} */ (expr.range)[0]),
 									parser.destructuringAssignmentPropertiesFor(expr)
 								);
 
@@ -517,7 +535,7 @@ class DefinePlugin {
 								: "typeof (" + codeCode + ")";
 							const res = parser.evaluate(typeofCode);
 							recurseTypeof = false;
-							res.setRange(expr.range);
+							res.setRange(/** @type {Range} */ (expr.range));
 							return res;
 						});
 						parser.hooks.typeof.for(key).tap(PLUGIN_NAME, expr => {
@@ -559,7 +577,7 @@ class DefinePlugin {
 							return new BasicEvaluatedExpression()
 								.setTruthy()
 								.setSideEffects(false)
-								.setRange(expr.range);
+								.setRange(/** @type {Range} */ (expr.range));
 						});
 						parser.hooks.evaluateTypeof
 							.for(key)
@@ -576,7 +594,7 @@ class DefinePlugin {
 								key,
 								runtimeTemplate,
 								logger,
-								!parser.isAsiPosition(expr.range[0]),
+								!parser.isAsiPosition(/** @type {Range} */ (expr.range)[0]),
 								parser.destructuringAssignmentPropertiesFor(expr)
 							);
 
@@ -622,7 +640,7 @@ class DefinePlugin {
 
 				/**
 				 * Walk definitions
-				 * @param {Object} definitions Definitions map
+				 * @param {Record<string, CodeValue>} definitions Definitions map
 				 * @param {string} prefix Prefix string
 				 * @returns {void}
 				 */
@@ -649,7 +667,10 @@ class DefinePlugin {
 							!(code instanceof RuntimeValue) &&
 							!(code instanceof RegExp)
 						) {
-							walkDefinitionsForValues(code, prefix + key + ".");
+							walkDefinitionsForValues(
+								/** @type {Record<string, CodeValue>} */ (code),
+								prefix + key + "."
+							);
 						}
 					});
 				};

package/lib/EvalSourceMapDevToolPlugin.js

@@ -129,7 +129,7 @@ class EvalSourceMapDevToolPlugin {
 
 						// Clone (flat) the sourcemap to ensure that the mutations below do not persist.
 						sourceMap = { ...sourceMap };
-						const context = compiler.options.context;
+						const context = /** @type {string} */ (compiler.options.context);
 						const root = compiler.root;
 						const modules = sourceMap.sources.map(source => {
 							if (!source.startsWith("webpack://")) return source;

package/lib/InitFragment.js

@@ -36,15 +36,15 @@ const sortFragmentWithIndex = ([a, i], [b, j]) => {
 };
 
 /**
- * @template Context
+ * @template GenerateContext
  */
 class InitFragment {
 	/**
-	 * @param {string|Source} content the source code that will be included as initialization code
+	 * @param {string | Source} content the source code that will be included as initialization code
 	 * @param {number} stage category of initialization code (contribute to order)
 	 * @param {number} position position in the category (contribute to order)
 	 * @param {string=} key unique key to avoid emitting the same initialization code twice
-	 * @param {string|Source=} endContent the source code that will be included at the end of the module
+	 * @param {string | Source=} endContent the source code that will be included at the end of the module
 	 */
 	constructor(content, stage, position, key, endContent) {
 		this.content = content;
@@ -55,15 +55,15 @@ class InitFragment {
 	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source} the source code that will be included as initialization code
 	 */
 	getContent(context) {
 		return this.content;
 	}
 
 	/**
-	 * @param {Context} context context
+	 * @param {GenerateContext} context context
 	 * @returns {string|Source=} the source code that will be included at the end of the module
 	 */
 	getEndContent(context) {
@@ -91,7 +91,7 @@ class InitFragment {
 			for (const [fragment] of sortedFragments) {
 				if (
 					typeof (
-						/** @type {InitFragment<T> & { mergeAll?: (fragments: InitFragment[]) => InitFragment[] }} */
+						/** @type {InitFragment<T> & { mergeAll?: (fragments: InitFragment<Context>[]) => InitFragment<Context>[] }} */
 						(fragment).mergeAll
 					) === "function"
 				) {

package/lib/NodeStuffPlugin.js

@@ -136,7 +136,7 @@ class NodeStuffPlugin {
 
 					/**
 					 * @param {string} expressionName expression name
-					 * @param {(value: string) => void} fn function
+					 * @param {(value: string) => string} fn function
 					 * @returns {void}
 					 */
 					const setUrlModuleConstant = (expressionName, fn) => {
@@ -153,10 +153,10 @@ class NodeStuffPlugin {
 									],
 									undefined,
 									fn("__webpack_fileURLToPath__"),
-									expr.range,
+									/** @type {Range} */ (expr.range),
 									expressionName
 								);
-								dep.loc = expr.loc;
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
 
 								return true;

package/lib/Stats.js

@@ -65,6 +65,10 @@ class Stats {
 		});
 	}
 
+	/**
+	 * @param {(string|StatsOptions)=} options stats options
+	 * @returns {string} string output
+	 */
 	toString(options) {
 		options = this.compilation.createStatsOptions(options, {
 			forToString: true

package/lib/async-modules/AwaitDependenciesInitFragment.js

@@ -42,8 +42,8 @@ class AwaitDependenciesInitFragment extends InitFragment {
 	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source} the source code that will be included as initialization code
 	 */
 	getContent({ runtimeRequirements }) {
 		runtimeRequirements.add(RuntimeGlobals.module);

package/lib/buildChunkGraph.js

@@ -44,7 +44,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @property {boolean | undefined} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
  * @property {ModuleSetPlus[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
  * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
- * @property {Set<[Module, ConnectionState]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
+ * @property {Set<[Module, ModuleGraphConnection[]]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
  * @property {ModuleSetPlus | undefined} resultingAvailableModules set of modules available including modules from this chunk group
  * @property {Set<ChunkGroupInfo> | undefined} children set of children chunk groups, that will be revisited when availableModules shrink
  * @property {Set<ChunkGroupInfo> | undefined} availableSources set of chunk groups that are the source for minAvailableModules
@@ -73,6 +73,25 @@ const bySetSize = (a, b) => {
 	return b.size + b.plus.size - a.size - a.plus.size;
 };
 
+/**
+ * @param {ModuleGraphConnection[]} connections list of connections
+ * @param {RuntimeSpec} runtime for which runtime
+ * @returns {ConnectionState} connection state
+ */
+const getActiveStateOfConnections = (connections, runtime) => {
+	let merged = connections[0].getActiveState(runtime);
+	if (merged === true) return true;
+	for (let i = 1; i < connections.length; i++) {
+		const c = connections[i];
+		merged = ModuleGraphConnection.addConnectionStates(
+			merged,
+			c.getActiveState(runtime)
+		);
+		if (merged === true) return true;
+	}
+	return merged;
+};
+
 const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 	let blockCache;
 	let modules;
@@ -99,9 +118,6 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 		if (!m) continue;
 		// We skip weak connections
 		if (connection.weak) continue;
-		const state = connection.getActiveState(runtime);
-		// We skip inactive connections
-		if (state === false) continue;
 
 		const block = moduleGraph.getParentBlock(d);
 		let index = moduleGraph.getParentBlockIndex(d);
@@ -115,41 +131,47 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 			modules = blockModulesMap.get((blockCache = block));
 		}
 
-		const i = index << 2;
+		const i = index * 3;
 		modules[i] = m;
-		modules[i + 1] = state;
+		modules[i + 1] = connection.getActiveState(runtime);
+		modules[i + 2] = connection;
 	}
 
 	for (const modules of arrays) {
 		if (modules.length === 0) continue;
 		let indexMap;
 		let length = 0;
-		outer: for (let j = 0; j < modules.length; j += 2) {
+		outer: for (let j = 0; j < modules.length; j += 3) {
 			const m = modules[j];
 			if (m === undefined) continue;
 			const state = modules[j + 1];
+			const connection = modules[j + 2];
 			if (indexMap === undefined) {
 				let i = 0;
-				for (; i < length; i += 2) {
+				for (; i < length; i += 3) {
 					if (modules[i] === m) {
 						const merged = modules[i + 1];
+						modules[i + 2].push(connection);
 						if (merged === true) continue outer;
 						modules[i + 1] = ModuleGraphConnection.addConnectionStates(
 							merged,
 							state
 						);
+						continue outer;
 					}
 				}
 				modules[length] = m;
 				length++;
 				modules[length] = state;
 				length++;
+				modules[length] = [connection];
+				length++;
 				if (length > 30) {
 					// To avoid worse case performance, we will use an index map for
 					// linear cost access, which allows to maintain O(n) complexity
 					// while keeping allocations down to a minimum
 					indexMap = new Map();
-					for (let i = 0; i < length; i += 2) {
+					for (let i = 0; i < length; i += 3) {
 						indexMap.set(modules[i], i + 1);
 					}
 				}
@@ -157,6 +179,7 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 				const idx = indexMap.get(m);
 				if (idx !== undefined) {
 					const merged = modules[idx];
+					modules[idx + 1].push(connection);
 					if (merged === true) continue outer;
 					modules[idx] = ModuleGraphConnection.addConnectionStates(
 						merged,
@@ -168,6 +191,8 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 					modules[length] = state;
 					indexMap.set(m, length);
 					length++;
+					modules[length] = [connection];
+					length++;
 				}
 			}
 		}
@@ -207,7 +232,7 @@ const visitModules = (
 	 *
 	 * @param {DependenciesBlock} block block
 	 * @param {RuntimeSpec} runtime runtime
-	 * @returns {(Module | ConnectionState)[]} block modules in flatten tuples
+	 * @returns {(Module | ConnectionState | ModuleGraphConnection[])[]} block modules in flatten tuples
 	 */
 	const getBlockModules = (block, runtime) => {
 		if (blockModulesMapRuntime !== runtime) {
@@ -266,12 +291,18 @@ const visitModules = (
 	/** @type {Map<DependenciesBlock, ChunkGroupInfo>} */
 	const blockChunkGroups = new Map();
 
+	/** @type {Map<ChunkGroupInfo, DependenciesBlock>} */
+	const blockByChunkGroups = new Map();
+
 	/** @type {Map<string, ChunkGroupInfo>} */
 	const namedChunkGroups = new Map();
 
 	/** @type {Map<string, ChunkGroupInfo>} */
 	const namedAsyncEntrypoints = new Map();
 
+	/** @type {Set<ChunkGroupInfo>} */
+	const outdatedOrderIndexChunkGroups = new Set();
+
 	const ADD_AND_ENTER_ENTRY_MODULE = 0;
 	const ADD_AND_ENTER_MODULE = 1;
 	const ENTER_MODULE = 2;
@@ -376,7 +407,7 @@ const visitModules = (
 	/** @type {QueueItem[]} */
 	let queueDelayed = [];
 
-	/** @type {[Module, ConnectionState][]} */
+	/** @type {[Module, ModuleGraphConnection[]][]} */
 	const skipConnectionBuffer = [];
 	/** @type {Module[]} */
 	const skipBuffer = [];
@@ -524,6 +555,7 @@ const visitModules = (
 				blockConnections.set(b, []);
 			}
 			blockChunkGroups.set(b, /** @type {ChunkGroupInfo} */ (cgi));
+			blockByChunkGroups.set(cgi, b);
 		} else if (entryOptions) {
 			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 		} else {
@@ -575,7 +607,7 @@ const visitModules = (
 			const { minAvailableModules } = chunkGroupInfo;
 			// Buffer items because order need to be reversed to get indices correct
 			// Traverse all referenced modules
-			for (let i = 0; i < blockModules.length; i += 2) {
+			for (let i = 0; i < blockModules.length; i += 3) {
 				const refModule = /** @type {Module} */ (blockModules[i]);
 				if (chunkGraph.isModuleInChunk(refModule, chunk)) {
 					// skip early if already connected
@@ -585,7 +617,11 @@ const visitModules = (
 					blockModules[i + 1]
 				);
 				if (activeState !== true) {
-					skipConnectionBuffer.push([refModule, activeState]);
+					const connections = /** @type {ModuleGraphConnection[]} */ (
+						blockModules[i + 2]
+					);
+					skipConnectionBuffer.push([refModule, connections]);
+					// We skip inactive connections
 					if (activeState === false) continue;
 				}
 				if (
@@ -659,7 +695,7 @@ const visitModules = (
 
 		if (blockModules !== undefined) {
 			// Traverse all referenced modules
-			for (let i = 0; i < blockModules.length; i += 2) {
+			for (let i = 0; i < blockModules.length; i += 3) {
 				const refModule = /** @type {Module} */ (blockModules[i]);
 				const activeState = /** @type {ConnectionState} */ (
 					blockModules[i + 1]
@@ -1165,7 +1201,11 @@ const visitModules = (
 					/** @type {ModuleSetPlus} */
 					(info.minAvailableModules);
 				for (const entry of info.skippedModuleConnections) {
-					const [module, activeState] = entry;
+					const [module, connections] = entry;
+					const activeState = getActiveStateOfConnections(
+						connections,
+						info.runtime
+					);
 					if (activeState === false) continue;
 					if (activeState === true) {
 						info.skippedModuleConnections.delete(entry);
@@ -1208,6 +1248,7 @@ const visitModules = (
 					chunkGroupsForCombining.add(cgi);
 				}
 			}
+			outdatedOrderIndexChunkGroups.add(info);
 		}
 		outdatedChunkGroupInfo.clear();
 	};
@@ -1254,6 +1295,51 @@ const visitModules = (
 		}
 	}
 
+	for (const info of outdatedOrderIndexChunkGroups) {
+		const { chunkGroup, runtime } = info;
+
+		const block = blockByChunkGroups.get(info);
+
+		if (!block) {
+			continue;
+		}
+
+		let preOrderIndex = 0;
+		let postOrderIndex = 0;
+
+		const process = (current, visited = new Set()) => {
+			if (visited.has(current)) {
+				return;
+			}
+
+			visited.add(current);
+
+			const blockModules = getBlockModules(current, runtime);
+			if (blockModules === undefined) {
+				return;
+			}
+
+			for (let i = 0; i < blockModules.length; i += 3) {
+				const refModule = /** @type {Module} */ (blockModules[i]);
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
+				if (activeState === false) {
+					continue;
+				}
+
+				if (refModule) {
+					chunkGroup.setModulePreOrderIndex(refModule, preOrderIndex++);
+					process(refModule, visited);
+					chunkGroup.setModulePostOrderIndex(refModule, postOrderIndex++);
+				}
+			}
+		};
+
+		process(block);
+	}
+	outdatedOrderIndexChunkGroups.clear();
+
 	logger.log(
 		`${statProcessedQueueItems} queue items processed (${statProcessedBlocks} blocks)`
 	);