webpack 5.59.0 → 5.94.0

package/lib/buildChunkGraph.js

@@ -16,6 +16,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Entrypoint")} Entrypoint */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
@@ -24,7 +25,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @typedef {Object} QueueItem
+ * @typedef {object} QueueItem
  * @property {number} action
  * @property {DependenciesBlock} block
  * @property {Module} module
@@ -33,52 +34,90 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @property {ChunkGroupInfo} chunkGroupInfo
  */
 
-/** @typedef {Set<Module> & { plus: Set<Module> }} ModuleSetPlus */
-
 /**
- * @typedef {Object} ChunkGroupInfo
+ * @typedef {object} ChunkGroupInfo
  * @property {ChunkGroup} chunkGroup the chunk group
  * @property {RuntimeSpec} runtime the runtimes
- * @property {ModuleSetPlus} minAvailableModules current minimal set of modules available at this point
- * @property {boolean} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
- * @property {ModuleSetPlus[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
+ * @property {bigint | undefined} minAvailableModules current minimal set of modules available at this point
+ * @property {bigint[]} 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 {ModuleSetPlus} resultingAvailableModules set of modules available including modules from this chunk group
- * @property {Set<ChunkGroupInfo>} children set of children chunk groups, that will be revisited when availableModules shrink
- * @property {Set<ChunkGroupInfo>} availableSources set of chunk groups that are the source for minAvailableModules
- * @property {Set<ChunkGroupInfo>} availableChildren set of chunk groups which depend on the this chunk group as availableSource
+ * @property {Set<[Module, ModuleGraphConnection[]]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
+ * @property {bigint | 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
+ * @property {Set<ChunkGroupInfo> | undefined} availableChildren set of chunk groups which depend on the this chunk group as availableSource
  * @property {number} preOrderIndex next pre order index
  * @property {number} postOrderIndex next post order index
+ * @property {boolean} chunkLoading has a chunk loading mechanism
+ * @property {boolean} asyncChunks create async chunks
  */
 
 /**
- * @typedef {Object} BlockChunkGroupConnection
+ * @typedef {object} BlockChunkGroupConnection
  * @property {ChunkGroupInfo} originChunkGroupInfo origin chunk group
  * @property {ChunkGroup} chunkGroup referenced chunk group
  */
 
-const EMPTY_SET = /** @type {ModuleSetPlus} */ (new Set());
-EMPTY_SET.plus = EMPTY_SET;
+/** @typedef {(Module | ConnectionState | ModuleGraphConnection)[]} BlockModulesInTuples */
+/** @typedef {(Module | ConnectionState | ModuleGraphConnection[])[]} BlockModulesInFlattenTuples */
+/** @typedef {Map<DependenciesBlock, BlockModulesInFlattenTuples>} BlockModulesMap */
+/** @typedef {Map<Chunk, bigint>} MaskByChunk */
+/** @typedef {Set<DependenciesBlock>} BlocksWithNestedBlocks */
+/** @typedef {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} BlockConnections */
+/** @typedef {Map<ChunkGroup, ChunkGroupInfo>} ChunkGroupInfoMap */
+/** @typedef {Set<ChunkGroup>} AllCreatedChunkGroups */
+/** @typedef {Map<Entrypoint, Module[]>} InputEntrypointsAndModules */
+
+const ZERO_BIGINT = BigInt(0);
+const ONE_BIGINT = BigInt(1);
 
 /**
- * @param {ModuleSetPlus} a first set
- * @param {ModuleSetPlus} b second set
- * @returns {number} cmp
+ * @param {bigint} mask The mask to test
+ * @param {number} ordinal The ordinal of the bit to test
+ * @returns {boolean} If the ordinal-th bit is set in the mask
  */
-const bySetSize = (a, b) => {
-	return b.size + b.plus.size - a.size - a.plus.size;
+const isOrdinalSetInMask = (mask, ordinal) =>
+	BigInt.asUintN(1, mask >> BigInt(ordinal)) !== ZERO_BIGINT;
+
+/**
+ * @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;
 };
 
+/**
+ * @param {Module} module module
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {RuntimeSpec} runtime runtime
+ * @param {BlockModulesMap} blockModulesMap block modules map
+ */
 const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
+	/** @type {DependenciesBlock | undefined} */
 	let blockCache;
+	/** @type {BlockModulesInTuples | undefined} */
 	let modules;
 
+	/** @type {BlockModulesInTuples[]} */
 	const arrays = [];
 
+	/** @type {DependenciesBlock[]} */
 	const queue = [module];
 	while (queue.length > 0) {
-		const block = queue.pop();
+		const block = /** @type {DependenciesBlock} */ (queue.pop());
+		/** @type {Module[]} */
 		const arr = [];
 		arrays.push(arr);
 		blockModulesMap.set(block, arr);
@@ -96,65 +135,81 @@ 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);
 
 		// deprecated fallback
 		if (index < 0) {
-			index = block.dependencies.indexOf(d);
+			index = /** @type {DependenciesBlock} */ (block).dependencies.indexOf(d);
 		}
 
 		if (blockCache !== block) {
-			modules = blockModulesMap.get((blockCache = block));
+			modules =
+				/** @type {BlockModulesInTuples} */
+				(
+					blockModulesMap.get(
+						(blockCache = /** @type {DependenciesBlock} */ (block))
+					)
+				);
 		}
 
-		const i = index << 2;
-		modules[i] = m;
-		modules[i + 1] = state;
+		const i = index * 3;
+		/** @type {BlockModulesInTuples} */
+		(modules)[i] = m;
+		/** @type {BlockModulesInTuples} */
+		(modules)[i + 1] = connection.getActiveState(runtime);
+		/** @type {BlockModulesInTuples} */
+		(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 state = /** @type {ConnectionState} */ (modules[j + 1]);
+			const connection = /** @type {ModuleGraphConnection} */ (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];
+						const merged = /** @type {ConnectionState} */ (modules[i + 1]);
+						/** @type {ModuleGraphConnection[]} */
+						(/** @type {unknown} */ (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++;
+				/** @type {ModuleGraphConnection[]} */
+				(/** @type {unknown} */ (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);
 					}
 				}
 			} else {
 				const idx = indexMap.get(m);
 				if (idx !== undefined) {
-					const merged = modules[idx];
-					if (merged === true) continue outer;
+					const merged = /** @type {ConnectionState} */ (modules[idx]);
+					/** @type {ModuleGraphConnection[]} */
+					(/** @type {unknown} */ (modules[idx + 1])).push(connection);
+					if (merged === true) continue;
 					modules[idx] = ModuleGraphConnection.addConnectionStates(
 						merged,
 						state
@@ -165,6 +220,12 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 					modules[length] = state;
 					indexMap.set(m, length);
 					length++;
+					/** @type {ModuleGraphConnection[]} */
+					(
+						/** @type {unknown} */
+						(modules[length])
+					) = [connection];
+					length++;
 				}
 			}
 		}
@@ -173,14 +234,14 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 };
 
 /**
- *
  * @param {Logger} logger a logger
  * @param {Compilation} compilation the compilation
- * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
- * @param {Map<ChunkGroup, ChunkGroupInfo>} chunkGroupInfoMap mapping from chunk group to available modules
- * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
- * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
- * @param {Set<ChunkGroup>} allCreatedChunkGroups filled with all chunk groups that are created here
+ * @param {InputEntrypointsAndModules} inputEntrypointsAndModules chunk groups which are processed with the modules
+ * @param {ChunkGroupInfoMap} chunkGroupInfoMap mapping from chunk group to available modules
+ * @param {BlockConnections} blockConnections connection for blocks
+ * @param {BlocksWithNestedBlocks} blocksWithNestedBlocks flag for blocks that have nested blocks
+ * @param {AllCreatedChunkGroups} allCreatedChunkGroups filled with all chunk groups that are created here
+ * @param {MaskByChunk} maskByChunk module content mask by chunk
  */
 const visitModules = (
 	logger,
@@ -189,29 +250,50 @@ const visitModules = (
 	chunkGroupInfoMap,
 	blockConnections,
 	blocksWithNestedBlocks,
-	allCreatedChunkGroups
+	allCreatedChunkGroups,
+	maskByChunk
 ) => {
 	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
 
 	const blockModulesRuntimeMap = new Map();
 
-	/** @type {RuntimeSpec | false} */
-	let blockModulesMapRuntime = false;
+	/** @type {BlockModulesMap | undefined} */
 	let blockModulesMap;
 
+	/** @type {Map<Module, number>} */
+	const ordinalByModule = new Map();
+
+	/**
+	 * @param {Module} module The module to look up
+	 * @returns {number} The ordinal of the module in masks
+	 */
+	const getModuleOrdinal = module => {
+		let ordinal = ordinalByModule.get(module);
+		if (ordinal === undefined) {
+			ordinal = ordinalByModule.size;
+			ordinalByModule.set(module, ordinal);
+		}
+		return ordinal;
+	};
+
+	for (const chunk of compilation.chunks) {
+		let mask = ZERO_BIGINT;
+		for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
+			mask |= ONE_BIGINT << BigInt(getModuleOrdinal(m));
+		}
+		maskByChunk.set(chunk, mask);
+	}
+
 	/**
-	 *
 	 * @param {DependenciesBlock} block block
 	 * @param {RuntimeSpec} runtime runtime
-	 * @returns {(Module | ConnectionState)[]} block modules in flatten tuples
+	 * @returns {BlockModulesInFlattenTuples} block modules in flatten tuples
 	 */
 	const getBlockModules = (block, runtime) => {
-		if (blockModulesMapRuntime !== runtime) {
-			blockModulesMap = blockModulesRuntimeMap.get(runtime);
-			if (blockModulesMap === undefined) {
-				blockModulesMap = new Map();
-				blockModulesRuntimeMap.set(runtime, blockModulesMap);
-			}
+		blockModulesMap = blockModulesRuntimeMap.get(runtime);
+		if (blockModulesMap === undefined) {
+			blockModulesMap = new Map();
+			blockModulesRuntimeMap.set(runtime, blockModulesMap);
 		}
 		let blockModules = blockModulesMap.get(block);
 		if (blockModules !== undefined) return blockModules;
@@ -232,13 +314,14 @@ const visitModules = (
 			for (const [block, blockModules] of map)
 				blockModulesMap.set(block, blockModules);
 			return map.get(block);
-		} else {
-			logger.time("visitModules: prepare");
-			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
-			blockModules = blockModulesMap.get(block);
-			logger.timeAggregate("visitModules: prepare");
-			return blockModules;
 		}
+		logger.time("visitModules: prepare");
+		extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
+		blockModules =
+			/** @type {BlockModulesInFlattenTuples} */
+			(blockModulesMap.get(block));
+		logger.timeAggregate("visitModules: prepare");
+		return blockModules;
 	};
 
 	let statProcessedQueueItems = 0;
@@ -246,12 +329,12 @@ const visitModules = (
 	let statConnectedChunkGroups = 0;
 	let statProcessedChunkGroupsForMerging = 0;
 	let statMergedAvailableModuleSets = 0;
-	let statForkedAvailableModules = 0;
-	let statForkedAvailableModulesCount = 0;
-	let statForkedAvailableModulesCountPlus = 0;
-	let statForkedMergedModulesCount = 0;
-	let statForkedMergedModulesCountPlus = 0;
-	let statForkedResultModulesCount = 0;
+	const statForkedAvailableModules = 0;
+	const statForkedAvailableModulesCount = 0;
+	const statForkedAvailableModulesCountPlus = 0;
+	const statForkedMergedModulesCount = 0;
+	const statForkedMergedModulesCountPlus = 0;
+	const statForkedResultModulesCount = 0;
 	let statChunkGroupInfoUpdated = 0;
 	let statChildChunkGroupsReconnected = 0;
 
@@ -262,12 +345,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;
@@ -288,7 +377,7 @@ const visitModules = (
 	for (const [chunkGroup, modules] of inputEntrypointsAndModules) {
 		const runtime = getEntryRuntime(
 			compilation,
-			chunkGroup.name,
+			/** @type {string} */ (chunkGroup.name),
 			chunkGroup.options
 		);
 		/** @type {ChunkGroupInfo} */
@@ -296,7 +385,6 @@ const visitModules = (
 			chunkGroup,
 			runtime,
 			minAvailableModules: undefined,
-			minAvailableModulesOwned: false,
 			availableModulesToBeMerged: [],
 			skippedItems: undefined,
 			resultingAvailableModules: undefined,
@@ -304,22 +392,27 @@ const visitModules = (
 			availableSources: undefined,
 			availableChildren: undefined,
 			preOrderIndex: 0,
-			postOrderIndex: 0
+			postOrderIndex: 0,
+			chunkLoading:
+				chunkGroup.options.chunkLoading !== undefined
+					? chunkGroup.options.chunkLoading !== false
+					: compilation.outputOptions.chunkLoading !== false,
+			asyncChunks:
+				chunkGroup.options.asyncChunks !== undefined
+					? chunkGroup.options.asyncChunks
+					: compilation.outputOptions.asyncChunks !== false
 		};
 		chunkGroup.index = nextChunkGroupIndex++;
 		if (chunkGroup.getNumberOfParents() > 0) {
 			// minAvailableModules for child entrypoints are unknown yet, set to undefined.
 			// This means no module is added until other sets are merged into
 			// this minAvailableModules (by the parent entrypoints)
-			const skippedItems = new Set();
-			for (const module of modules) {
-				skippedItems.add(module);
-			}
+			const skippedItems = new Set(modules);
 			chunkGroupInfo.skippedItems = skippedItems;
 			chunkGroupsForCombining.add(chunkGroupInfo);
 		} else {
 			// The application may start here: We start with an empty list of available modules
-			chunkGroupInfo.minAvailableModules = EMPTY_SET;
+			chunkGroupInfo.minAvailableModules = ZERO_BIGINT;
 			const chunk = chunkGroup.getEntrypointChunk();
 			for (const module of modules) {
 				queue.push({
@@ -342,7 +435,9 @@ const visitModules = (
 		const { chunkGroup } = chunkGroupInfo;
 		chunkGroupInfo.availableSources = new Set();
 		for (const parent of chunkGroup.parentsIterable) {
-			const parentChunkGroupInfo = chunkGroupInfoMap.get(parent);
+			const parentChunkGroupInfo =
+				/** @type {ChunkGroupInfo} */
+				(chunkGroupInfoMap.get(parent));
 			chunkGroupInfo.availableSources.add(parentChunkGroupInfo);
 			if (parentChunkGroupInfo.availableChildren === undefined) {
 				parentChunkGroupInfo.availableChildren = new Set();
@@ -362,7 +457,7 @@ const visitModules = (
 	/** @type {QueueItem[]} */
 	let queueDelayed = [];
 
-	/** @type {[Module, ConnectionState][]} */
+	/** @type {[Module, ModuleGraphConnection[]][]} */
 	const skipConnectionBuffer = [];
 	/** @type {Module[]} */
 	const skipBuffer = [];
@@ -388,29 +483,30 @@ const visitModules = (
 	const iteratorBlock = b => {
 		// 1. We create a chunk group with single chunk in it for this Block
 		// but only once (blockChunkGroups map)
+		/** @type {ChunkGroupInfo | undefined} */
 		let cgi = blockChunkGroups.get(b);
-		/** @type {ChunkGroup} */
+		/** @type {ChunkGroup | undefined} */
 		let c;
-		/** @type {Entrypoint} */
+		/** @type {Entrypoint | undefined} */
 		let entrypoint;
 		const entryOptions = b.groupOptions && b.groupOptions.entryOptions;
 		if (cgi === undefined) {
 			const chunkName = (b.groupOptions && b.groupOptions.name) || b.chunkName;
 			if (entryOptions) {
-				cgi = namedAsyncEntrypoints.get(chunkName);
+				cgi = namedAsyncEntrypoints.get(/** @type {string} */ (chunkName));
 				if (!cgi) {
 					entrypoint = compilation.addAsyncEntrypoint(
 						entryOptions,
 						module,
-						b.loc,
-						b.request
+						/** @type {DependencyLocation} */ (b.loc),
+						/** @type {string} */ (b.request)
 					);
+					maskByChunk.set(entrypoint.chunks[0], ZERO_BIGINT);
 					entrypoint.index = nextChunkGroupIndex++;
 					cgi = {
 						chunkGroup: entrypoint,
 						runtime: entrypoint.options.runtime || entrypoint.name,
-						minAvailableModules: EMPTY_SET,
-						minAvailableModulesOwned: false,
+						minAvailableModules: ZERO_BIGINT,
 						availableModulesToBeMerged: [],
 						skippedItems: undefined,
 						resultingAvailableModules: undefined,
@@ -418,7 +514,15 @@ const visitModules = (
 						availableSources: undefined,
 						availableChildren: undefined,
 						preOrderIndex: 0,
-						postOrderIndex: 0
+						postOrderIndex: 0,
+						chunkLoading:
+							entryOptions.chunkLoading !== undefined
+								? entryOptions.chunkLoading !== false
+								: chunkGroupInfo.chunkLoading,
+						asyncChunks:
+							entryOptions.asyncChunks !== undefined
+								? entryOptions.asyncChunks
+								: chunkGroupInfo.asyncChunks
 					};
 					chunkGroupInfoMap.set(entrypoint, cgi);
 
@@ -429,7 +533,11 @@ const visitModules = (
 				} else {
 					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 					// TODO merge entryOptions
-					entrypoint.addOrigin(module, b.loc, b.request);
+					entrypoint.addOrigin(
+						module,
+						/** @type {DependencyLocation} */ (b.loc),
+						/** @type {string} */ (b.request)
+					);
 					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
 				}
 
@@ -437,26 +545,36 @@ const visitModules = (
 				queueDelayed.push({
 					action: PROCESS_ENTRY_BLOCK,
 					block: b,
-					module: module,
+					module,
 					chunk: entrypoint.chunks[0],
 					chunkGroup: entrypoint,
 					chunkGroupInfo: cgi
 				});
+			} else if (!chunkGroupInfo.asyncChunks || !chunkGroupInfo.chunkLoading) {
+				// Just queue the block into the current chunk group
+				queue.push({
+					action: PROCESS_BLOCK,
+					block: b,
+					module,
+					chunk,
+					chunkGroup,
+					chunkGroupInfo
+				});
 			} else {
-				cgi = namedChunkGroups.get(chunkName);
+				cgi = chunkName ? namedChunkGroups.get(chunkName) : undefined;
 				if (!cgi) {
 					c = compilation.addChunkInGroup(
 						b.groupOptions || b.chunkName,
 						module,
-						b.loc,
-						b.request
+						/** @type {DependencyLocation} */ (b.loc),
+						/** @type {string} */ (b.request)
 					);
+					maskByChunk.set(c.chunks[0], ZERO_BIGINT);
 					c.index = nextChunkGroupIndex++;
 					cgi = {
 						chunkGroup: c,
 						runtime: chunkGroupInfo.runtime,
 						minAvailableModules: undefined,
-						minAvailableModulesOwned: undefined,
 						availableModulesToBeMerged: [],
 						skippedItems: undefined,
 						resultingAvailableModules: undefined,
@@ -464,7 +582,9 @@ const visitModules = (
 						availableSources: undefined,
 						availableChildren: undefined,
 						preOrderIndex: 0,
-						postOrderIndex: 0
+						postOrderIndex: 0,
+						chunkLoading: chunkGroupInfo.chunkLoading,
+						asyncChunks: chunkGroupInfo.asyncChunks
 					};
 					allCreatedChunkGroups.add(c);
 					chunkGroupInfoMap.set(c, cgi);
@@ -475,16 +595,26 @@ const visitModules = (
 					c = cgi.chunkGroup;
 					if (c.isInitial()) {
 						compilation.errors.push(
-							new AsyncDependencyToInitialChunkError(chunkName, module, b.loc)
+							new AsyncDependencyToInitialChunkError(
+								/** @type {string} */ (chunkName),
+								module,
+								/** @type {DependencyLocation} */ (b.loc)
+							)
 						);
 						c = chunkGroup;
+					} else {
+						c.addOptions(b.groupOptions);
 					}
-					c.addOptions(b.groupOptions);
-					c.addOrigin(module, b.loc, b.request);
+					c.addOrigin(
+						module,
+						/** @type {DependencyLocation} */ (b.loc),
+						/** @type {string} */ (b.request)
+					);
 				}
 				blockConnections.set(b, []);
 			}
-			blockChunkGroups.set(b, cgi);
+			blockChunkGroups.set(b, /** @type {ChunkGroupInfo} */ (cgi));
+			blockByChunkGroups.set(/** @type {ChunkGroupInfo} */ (cgi), b);
 		} else if (entryOptions) {
 			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 		} else {
@@ -494,7 +624,8 @@ const visitModules = (
 		if (c !== undefined) {
 			// 2. We store the connection for the block
 			// to connect it later if needed
-			blockConnections.get(b).push({
+			/** @type {BlockChunkGroupConnection[]} */
+			(blockConnections.get(b)).push({
 				originChunkGroupInfo: chunkGroupInfo,
 				chunkGroup: c
 			});
@@ -505,7 +636,7 @@ const visitModules = (
 				connectList = new Set();
 				queueConnect.set(chunkGroupInfo, connectList);
 			}
-			connectList.add(cgi);
+			connectList.add(/** @type {ChunkGroupInfo} */ (cgi));
 
 			// TODO check if this really need to be done for each traversal
 			// or if it is enough when it's queued when created
@@ -513,12 +644,12 @@ const visitModules = (
 			queueDelayed.push({
 				action: PROCESS_BLOCK,
 				block: b,
-				module: module,
+				module,
 				chunk: c.chunks[0],
 				chunkGroup: c,
-				chunkGroupInfo: cgi
+				chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
 			});
-		} else {
+		} else if (entrypoint !== undefined) {
 			chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
 		}
 	};
@@ -533,27 +664,33 @@ const visitModules = (
 		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
 		if (blockModules !== undefined) {
-			const { minAvailableModules } = chunkGroupInfo;
+			const minAvailableModules =
+				/** @type {bigint} */
+				(chunkGroupInfo.minAvailableModules);
 			// 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, len = blockModules.length; i < len; i += 3) {
 				const refModule = /** @type {Module} */ (blockModules[i]);
-				if (chunkGraph.isModuleInChunk(refModule, chunk)) {
+				// For single comparisons this might be cheaper
+				const isModuleInChunk = chunkGraph.isModuleInChunk(refModule, chunk);
+
+				if (isModuleInChunk) {
 					// skip early if already connected
 					continue;
 				}
+
+				const refOrdinal = /** @type {number} */ getModuleOrdinal(refModule);
 				const activeState = /** @type {ConnectionState} */ (
 					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 (
-					activeState === true &&
-					(minAvailableModules.has(refModule) ||
-						minAvailableModules.plus.has(refModule))
-				) {
+				} else if (isOrdinalSetInMask(minAvailableModules, refOrdinal)) {
 					// already in parent chunks, skip it for now
 					skipBuffer.push(refModule);
 					continue;
@@ -619,15 +756,15 @@ const visitModules = (
 		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
 		if (blockModules !== undefined) {
-			// Traverse all referenced modules
-			for (let i = 0; i < blockModules.length; i += 2) {
+			// Traverse all referenced modules in reverse order
+			for (let i = blockModules.length - 3; i >= 0; i -= 3) {
 				const refModule = /** @type {Module} */ (blockModules[i]);
 				const activeState = /** @type {ConnectionState} */ (
 					blockModules[i + 1]
 				);
 				// enqueue, then add and enter to be in the correct order
 				// this is relevant with circular dependencies
-				queueBuffer.push({
+				queue.push({
 					action:
 						activeState === true ? ADD_AND_ENTER_ENTRY_MODULE : PROCESS_BLOCK,
 					block: refModule,
@@ -637,13 +774,6 @@ const visitModules = (
 					chunkGroupInfo
 				});
 			}
-			// Add buffered items in reverse order
-			if (queueBuffer.length > 0) {
-				for (let i = queueBuffer.length - 1; i >= 0; i--) {
-					queue.push(queueBuffer[i]);
-				}
-				queueBuffer.length = 0;
-			}
 		}
 
 		// Traverse all Blocks
@@ -659,7 +789,7 @@ const visitModules = (
 	const processQueue = () => {
 		while (queue.length) {
 			statProcessedQueueItems++;
-			const queueItem = queue.pop();
+			const queueItem = /** @type {QueueItem} */ (queue.pop());
 			module = queueItem.module;
 			block = queueItem.block;
 			chunk = queueItem.chunk;
@@ -675,12 +805,18 @@ const visitModules = (
 					);
 				// fallthrough
 				case ADD_AND_ENTER_MODULE: {
-					if (chunkGraph.isModuleInChunk(module, chunk)) {
+					const isModuleInChunk = chunkGraph.isModuleInChunk(module, chunk);
+
+					if (isModuleInChunk) {
 						// already connected, skip it
 						break;
 					}
 					// We connect Module and Chunk
 					chunkGraph.connectChunkAndModule(chunk, module);
+					const moduleOrdinal = getModuleOrdinal(module);
+					let chunkMask = /** @type {bigint} */ (maskByChunk.get(chunk));
+					chunkMask |= ONE_BIGINT << BigInt(moduleOrdinal);
+					maskByChunk.set(chunk, chunkMask);
 				}
 				// fallthrough
 				case ENTER_MODULE: {
@@ -737,44 +873,24 @@ const visitModules = (
 		}
 	};
 
+	/**
+	 * @param {ChunkGroupInfo} chunkGroupInfo The info object for the chunk group
+	 * @returns {bigint} The mask of available modules after the chunk group
+	 */
 	const calculateResultingAvailableModules = chunkGroupInfo => {
-		if (chunkGroupInfo.resultingAvailableModules)
+		if (chunkGroupInfo.resultingAvailableModules !== undefined)
 			return chunkGroupInfo.resultingAvailableModules;
 
-		const minAvailableModules = chunkGroupInfo.minAvailableModules;
-
-		// Create a new Set of available modules at this point
-		// We want to be as lazy as possible. There are multiple ways doing this:
-		// Note that resultingAvailableModules is stored as "(a) + (b)" as it's a ModuleSetPlus
-		// - resultingAvailableModules = (modules of chunk) + (minAvailableModules + minAvailableModules.plus)
-		// - resultingAvailableModules = (minAvailableModules + modules of chunk) + (minAvailableModules.plus)
-		// We choose one depending on the size of minAvailableModules vs minAvailableModules.plus
-
-		let resultingAvailableModules;
-		if (minAvailableModules.size > minAvailableModules.plus.size) {
-			// resultingAvailableModules = (modules of chunk) + (minAvailableModules + minAvailableModules.plus)
-			resultingAvailableModules =
-				/** @type {Set<Module> & {plus: Set<Module>}} */ (new Set());
-			for (const module of minAvailableModules.plus)
-				minAvailableModules.add(module);
-			minAvailableModules.plus = EMPTY_SET;
-			resultingAvailableModules.plus = minAvailableModules;
-			chunkGroupInfo.minAvailableModulesOwned = false;
-		} else {
-			// resultingAvailableModules = (minAvailableModules + modules of chunk) + (minAvailableModules.plus)
-			resultingAvailableModules =
-				/** @type {Set<Module> & {plus: Set<Module>}} */ (
-					new Set(minAvailableModules)
-				);
-			resultingAvailableModules.plus = minAvailableModules.plus;
-		}
+		let resultingAvailableModules = /** @type {bigint} */ (
+			chunkGroupInfo.minAvailableModules
+		);
 
 		// add the modules from the chunk group to the set
 		for (const chunk of chunkGroupInfo.chunkGroup.chunks) {
-			for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
-				resultingAvailableModules.add(m);
-			}
+			const mask = /** @type {bigint} */ (maskByChunk.get(chunk));
+			resultingAvailableModules |= mask;
 		}
+
 		return (chunkGroupInfo.resultingAvailableModules =
 			resultingAvailableModules);
 	};
@@ -821,232 +937,24 @@ const visitModules = (
 		// Execute the merge
 		for (const info of chunkGroupsForMerging) {
 			const availableModulesToBeMerged = info.availableModulesToBeMerged;
-			let cachedMinAvailableModules = info.minAvailableModules;
+			const cachedMinAvailableModules = info.minAvailableModules;
+			let minAvailableModules = cachedMinAvailableModules;
 
 			statMergedAvailableModuleSets += availableModulesToBeMerged.length;
 
-			// 1. Get minimal available modules
-			// It doesn't make sense to traverse a chunk again with more available modules.
-			// This step calculates the minimal available modules and skips traversal when
-			// the list didn't shrink.
-			if (availableModulesToBeMerged.length > 1) {
-				availableModulesToBeMerged.sort(bySetSize);
-			}
-			let changed = false;
-			merge: for (const availableModules of availableModulesToBeMerged) {
-				if (cachedMinAvailableModules === undefined) {
-					cachedMinAvailableModules = availableModules;
-					info.minAvailableModules = cachedMinAvailableModules;
-					info.minAvailableModulesOwned = false;
-					changed = true;
+			for (const availableModules of availableModulesToBeMerged) {
+				if (minAvailableModules === undefined) {
+					minAvailableModules = availableModules;
 				} else {
-					if (info.minAvailableModulesOwned) {
-						// We own it and can modify it
-						if (cachedMinAvailableModules.plus === availableModules.plus) {
-							for (const m of cachedMinAvailableModules) {
-								if (!availableModules.has(m)) {
-									cachedMinAvailableModules.delete(m);
-									changed = true;
-								}
-							}
-						} else {
-							for (const m of cachedMinAvailableModules) {
-								if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-									cachedMinAvailableModules.delete(m);
-									changed = true;
-								}
-							}
-							for (const m of cachedMinAvailableModules.plus) {
-								if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-									// We can't remove modules from the plus part
-									// so we need to merge plus into the normal part to allow modifying it
-									const iterator =
-										cachedMinAvailableModules.plus[Symbol.iterator]();
-									// fast forward add all modules until m
-									/** @type {IteratorResult<Module>} */
-									let it;
-									while (!(it = iterator.next()).done) {
-										const module = it.value;
-										if (module === m) break;
-										cachedMinAvailableModules.add(module);
-									}
-									// check the remaining modules before adding
-									while (!(it = iterator.next()).done) {
-										const module = it.value;
-										if (
-											availableModules.has(module) ||
-											availableModules.plus.has(m)
-										) {
-											cachedMinAvailableModules.add(module);
-										}
-									}
-									cachedMinAvailableModules.plus = EMPTY_SET;
-									changed = true;
-									continue merge;
-								}
-							}
-						}
-					} else if (cachedMinAvailableModules.plus === availableModules.plus) {
-						// Common and fast case when the plus part is shared
-						// We only need to care about the normal part
-						if (availableModules.size < cachedMinAvailableModules.size) {
-							// the new availableModules is smaller so it's faster to
-							// fork from the new availableModules
-							statForkedAvailableModules++;
-							statForkedAvailableModulesCount += availableModules.size;
-							statForkedMergedModulesCount += cachedMinAvailableModules.size;
-							// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-							const newSet = /** @type {ModuleSetPlus} */ (new Set());
-							newSet.plus = availableModules.plus;
-							for (const m of availableModules) {
-								if (cachedMinAvailableModules.has(m)) {
-									newSet.add(m);
-								}
-							}
-							statForkedResultModulesCount += newSet.size;
-							cachedMinAvailableModules = newSet;
-							info.minAvailableModulesOwned = true;
-							info.minAvailableModules = newSet;
-							changed = true;
-							continue merge;
-						}
-						for (const m of cachedMinAvailableModules) {
-							if (!availableModules.has(m)) {
-								// cachedMinAvailableModules need to be modified
-								// but we don't own it
-								statForkedAvailableModules++;
-								statForkedAvailableModulesCount +=
-									cachedMinAvailableModules.size;
-								statForkedMergedModulesCount += availableModules.size;
-								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-								// as the plus part is equal we can just take over this one
-								const newSet = /** @type {ModuleSetPlus} */ (new Set());
-								newSet.plus = availableModules.plus;
-								const iterator = cachedMinAvailableModules[Symbol.iterator]();
-								// fast forward add all modules until m
-								/** @type {IteratorResult<Module>} */
-								let it;
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (module === m) break;
-									newSet.add(module);
-								}
-								// check the remaining modules before adding
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (availableModules.has(module)) {
-										newSet.add(module);
-									}
-								}
-								statForkedResultModulesCount += newSet.size;
-								cachedMinAvailableModules = newSet;
-								info.minAvailableModulesOwned = true;
-								info.minAvailableModules = newSet;
-								changed = true;
-								continue merge;
-							}
-						}
-					} else {
-						for (const m of cachedMinAvailableModules) {
-							if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-								// cachedMinAvailableModules need to be modified
-								// but we don't own it
-								statForkedAvailableModules++;
-								statForkedAvailableModulesCount +=
-									cachedMinAvailableModules.size;
-								statForkedAvailableModulesCountPlus +=
-									cachedMinAvailableModules.plus.size;
-								statForkedMergedModulesCount += availableModules.size;
-								statForkedMergedModulesCountPlus += availableModules.plus.size;
-								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-								const newSet = /** @type {ModuleSetPlus} */ (new Set());
-								newSet.plus = EMPTY_SET;
-								const iterator = cachedMinAvailableModules[Symbol.iterator]();
-								// fast forward add all modules until m
-								/** @type {IteratorResult<Module>} */
-								let it;
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (module === m) break;
-									newSet.add(module);
-								}
-								// check the remaining modules before adding
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (
-										availableModules.has(module) ||
-										availableModules.plus.has(module)
-									) {
-										newSet.add(module);
-									}
-								}
-								// also check all modules in cachedMinAvailableModules.plus
-								for (const module of cachedMinAvailableModules.plus) {
-									if (
-										availableModules.has(module) ||
-										availableModules.plus.has(module)
-									) {
-										newSet.add(module);
-									}
-								}
-								statForkedResultModulesCount += newSet.size;
-								cachedMinAvailableModules = newSet;
-								info.minAvailableModulesOwned = true;
-								info.minAvailableModules = newSet;
-								changed = true;
-								continue merge;
-							}
-						}
-						for (const m of cachedMinAvailableModules.plus) {
-							if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-								// cachedMinAvailableModules need to be modified
-								// but we don't own it
-								statForkedAvailableModules++;
-								statForkedAvailableModulesCount +=
-									cachedMinAvailableModules.size;
-								statForkedAvailableModulesCountPlus +=
-									cachedMinAvailableModules.plus.size;
-								statForkedMergedModulesCount += availableModules.size;
-								statForkedMergedModulesCountPlus += availableModules.plus.size;
-								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-								// we already know that all modules directly from cachedMinAvailableModules are in availableModules too
-								const newSet = /** @type {ModuleSetPlus} */ (
-									new Set(cachedMinAvailableModules)
-								);
-								newSet.plus = EMPTY_SET;
-								const iterator =
-									cachedMinAvailableModules.plus[Symbol.iterator]();
-								// fast forward add all modules until m
-								/** @type {IteratorResult<Module>} */
-								let it;
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (module === m) break;
-									newSet.add(module);
-								}
-								// check the remaining modules before adding
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (
-										availableModules.has(module) ||
-										availableModules.plus.has(module)
-									) {
-										newSet.add(module);
-									}
-								}
-								statForkedResultModulesCount += newSet.size;
-								cachedMinAvailableModules = newSet;
-								info.minAvailableModulesOwned = true;
-								info.minAvailableModules = newSet;
-								changed = true;
-								continue merge;
-							}
-						}
-					}
+					minAvailableModules &= availableModules;
 				}
 			}
+
+			const changed = minAvailableModules !== cachedMinAvailableModules;
+
 			availableModulesToBeMerged.length = 0;
 			if (changed) {
+				info.minAvailableModules = minAvailableModules;
 				info.resultingAvailableModules = undefined;
 				outdatedChunkGroupInfo.add(info);
 			}
@@ -1056,33 +964,27 @@ const visitModules = (
 
 	const processChunkGroupsForCombining = () => {
 		for (const info of chunkGroupsForCombining) {
-			for (const source of info.availableSources) {
-				if (!source.minAvailableModules) {
+			for (const source of /** @type {Set<ChunkGroupInfo>} */ (
+				info.availableSources
+			)) {
+				if (source.minAvailableModules === undefined) {
 					chunkGroupsForCombining.delete(info);
 					break;
 				}
 			}
 		}
+
 		for (const info of chunkGroupsForCombining) {
-			const availableModules = /** @type {ModuleSetPlus} */ (new Set());
-			availableModules.plus = EMPTY_SET;
-			const mergeSet = set => {
-				if (set.size > availableModules.plus.size) {
-					for (const item of availableModules.plus) availableModules.add(item);
-					availableModules.plus = set;
-				} else {
-					for (const item of set) availableModules.add(item);
-				}
-			};
+			let availableModules = ZERO_BIGINT;
 			// combine minAvailableModules from all resultingAvailableModules
-			for (const source of info.availableSources) {
+			for (const source of /** @type {Set<ChunkGroupInfo>} */ (
+				info.availableSources
+			)) {
 				const resultingAvailableModules =
 					calculateResultingAvailableModules(source);
-				mergeSet(resultingAvailableModules);
-				mergeSet(resultingAvailableModules.plus);
+				availableModules |= resultingAvailableModules;
 			}
 			info.minAvailableModules = availableModules;
-			info.minAvailableModulesOwned = false;
 			info.resultingAvailableModules = undefined;
 			outdatedChunkGroupInfo.add(info);
 		}
@@ -1095,12 +997,12 @@ const visitModules = (
 		for (const info of outdatedChunkGroupInfo) {
 			// 1. Reconsider skipped items
 			if (info.skippedItems !== undefined) {
-				const { minAvailableModules } = info;
+				const minAvailableModules =
+					/** @type {bigint} */
+					(info.minAvailableModules);
 				for (const module of info.skippedItems) {
-					if (
-						!minAvailableModules.has(module) &&
-						!minAvailableModules.plus.has(module)
-					) {
+					const ordinal = getModuleOrdinal(module);
+					if (!isOrdinalSetInMask(minAvailableModules, ordinal)) {
 						queue.push({
 							action: ADD_AND_ENTER_MODULE,
 							block: module,
@@ -1116,20 +1018,24 @@ const visitModules = (
 
 			// 2. Reconsider skipped connections
 			if (info.skippedModuleConnections !== undefined) {
-				const { minAvailableModules } = info;
+				const minAvailableModules =
+					/** @type {bigint} */
+					(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) {
+						const ordinal = getModuleOrdinal(module);
 						info.skippedModuleConnections.delete(entry);
-					}
-					if (
-						activeState === true &&
-						(minAvailableModules.has(module) ||
-							minAvailableModules.plus.has(module))
-					) {
-						info.skippedItems.add(module);
-						continue;
+						if (isOrdinalSetInMask(minAvailableModules, ordinal)) {
+							/** @type {NonNullable<ChunkGroupInfo["skippedItems"]>} */
+							(info.skippedItems).add(module);
+							continue;
+						}
 					}
 					queue.push({
 						action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
@@ -1161,6 +1067,7 @@ const visitModules = (
 					chunkGroupsForCombining.add(cgi);
 				}
 			}
+			outdatedOrderIndexChunkGroups.add(info);
 		}
 		outdatedChunkGroupInfo.clear();
 	};
@@ -1207,6 +1114,55 @@ 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;
+
+		/**
+		 * @param {DependenciesBlock} current current
+		 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
+		 */
+		const process = (current, visited) => {
+			const blockModules = getBlockModules(current, runtime);
+			if (blockModules === undefined) {
+				return;
+			}
+
+			for (let i = 0, len = blockModules.length; i < len; i += 3) {
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
+				if (activeState === false) {
+					continue;
+				}
+				const refModule = /** @type {Module} */ (blockModules[i]);
+				if (visited.has(refModule)) {
+					continue;
+				}
+
+				visited.add(refModule);
+
+				if (refModule) {
+					chunkGroup.setModulePreOrderIndex(refModule, preOrderIndex++);
+					process(refModule, visited);
+					chunkGroup.setModulePostOrderIndex(refModule, postOrderIndex++);
+				}
+			}
+		};
+
+		process(block, new Set());
+	}
+	outdatedOrderIndexChunkGroups.clear();
+	ordinalByModule.clear();
+
 	logger.log(
 		`${statProcessedQueueItems} queue items processed (${statProcessedBlocks} blocks)`
 	);
@@ -1220,33 +1176,29 @@ const visitModules = (
 };
 
 /**
- *
  * @param {Compilation} compilation the compilation
- * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
- * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
- * @param {Map<ChunkGroup, ChunkGroupInfo>} chunkGroupInfoMap mapping from chunk group to available modules
+ * @param {BlocksWithNestedBlocks} blocksWithNestedBlocks flag for blocks that have nested blocks
+ * @param {BlockConnections} blockConnections connection for blocks
+ * @param {MaskByChunk} maskByChunk mapping from chunk to module mask
  */
 const connectChunkGroups = (
 	compilation,
 	blocksWithNestedBlocks,
 	blockConnections,
-	chunkGroupInfoMap
+	maskByChunk
 ) => {
 	const { chunkGraph } = compilation;
 
 	/**
 	 * Helper function to check if all modules of a chunk are available
-	 *
 	 * @param {ChunkGroup} chunkGroup the chunkGroup to scan
-	 * @param {ModuleSetPlus} availableModules the comparator set
+	 * @param {bigint} availableModules the comparator set
 	 * @returns {boolean} return true if all modules of a chunk are available
 	 */
 	const areModulesAvailable = (chunkGroup, availableModules) => {
 		for (const chunk of chunkGroup.chunks) {
-			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-				if (!availableModules.has(module) && !availableModules.plus.has(module))
-					return false;
-			}
+			const chunkMask = /** @type {bigint} */ (maskByChunk.get(chunk));
+			if ((chunkMask & availableModules) !== chunkMask) return false;
 		}
 		return true;
 	};
@@ -1265,7 +1217,7 @@ const connectChunkGroups = (
 			connections.every(({ chunkGroup, originChunkGroupInfo }) =>
 				areModulesAvailable(
 					chunkGroup,
-					originChunkGroupInfo.resultingAvailableModules
+					/** @type {bigint} */ (originChunkGroupInfo.resultingAvailableModules)
 				)
 			)
 		) {
@@ -1311,7 +1263,7 @@ const cleanupUnconnectedGroups = (compilation, allCreatedChunkGroups) => {
 /**
  * This method creates the Chunk graph from the Module graph
  * @param {Compilation} compilation the compilation
- * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
+ * @param {InputEntrypointsAndModules} inputEntrypointsAndModules chunk groups which are processed with the modules
  * @returns {void}
  */
 const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
@@ -1319,18 +1271,21 @@ const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
 
 	// SHARED STATE
 
-	/** @type {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} */
+	/** @type {BlockConnections} */
 	const blockConnections = new Map();
 
-	/** @type {Set<ChunkGroup>} */
+	/** @type {AllCreatedChunkGroups} */
 	const allCreatedChunkGroups = new Set();
 
-	/** @type {Map<ChunkGroup, ChunkGroupInfo>} */
+	/** @type {ChunkGroupInfoMap} */
 	const chunkGroupInfoMap = new Map();
 
-	/** @type {Set<DependenciesBlock>} */
+	/** @type {BlocksWithNestedBlocks} */
 	const blocksWithNestedBlocks = new Set();
 
+	/** @type {MaskByChunk} */
+	const maskByChunk = new Map();
+
 	// PART ONE
 
 	logger.time("visitModules");
@@ -1341,7 +1296,8 @@ const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
 		chunkGroupInfoMap,
 		blockConnections,
 		blocksWithNestedBlocks,
-		allCreatedChunkGroups
+		allCreatedChunkGroups,
+		maskByChunk
 	);
 	logger.timeEnd("visitModules");
 
@@ -1352,7 +1308,7 @@ const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
 		compilation,
 		blocksWithNestedBlocks,
 		blockConnections,
-		chunkGroupInfoMap
+		maskByChunk
 	);
 	logger.timeEnd("connectChunkGroups");