webpack 5.90.2 → 5.91.0

package/lib/buildChunkGraph.js

@@ -34,18 +34,15 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @property {ChunkGroupInfo} chunkGroupInfo
  */
 
-/** @typedef {Set<Module> & { plus: Set<Module> }} ModuleSetPlus */
-
 /**
  * @typedef {Object} ChunkGroupInfo
  * @property {ChunkGroup} chunkGroup the chunk group
  * @property {RuntimeSpec} runtime the runtimes
- * @property {ModuleSetPlus | undefined} minAvailableModules current minimal set of modules available at this point
- * @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 {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, 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 {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
@@ -61,17 +58,26 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @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
@@ -92,15 +98,26 @@ const getActiveStateOfConnections = (connections, runtime) => {
 	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);
@@ -124,17 +141,26 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 
 		// 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 * 3;
-		modules[i] = m;
-		modules[i + 1] = connection.getActiveState(runtime);
-		modules[i + 2] = connection;
+		/** @type {BlockModulesInTuples} */
+		(modules)[i] = m;
+		/** @type {BlockModulesInTuples} */
+		(modules)[i + 1] = connection.getActiveState(runtime);
+		/** @type {BlockModulesInTuples} */
+		(modules)[i + 2] = connection;
 	}
 
 	for (const modules of arrays) {
@@ -144,14 +170,15 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 		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];
+			const state = /** @type {ConnectionState} */ (modules[j + 1]);
+			const connection = /** @type {ModuleGraphConnection} */ (modules[j + 2]);
 			if (indexMap === undefined) {
 				let i = 0;
 				for (; i < length; i += 3) {
 					if (modules[i] === m) {
-						const merged = modules[i + 1];
-						modules[i + 2].push(connection);
+						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,
@@ -164,7 +191,8 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 				length++;
 				modules[length] = state;
 				length++;
-				modules[length] = [connection];
+				/** @type {ModuleGraphConnection[]} */
+				(/** @type {unknown} */ (modules[length])) = [connection];
 				length++;
 				if (length > 30) {
 					// To avoid worse case performance, we will use an index map for
@@ -178,8 +206,9 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 			} else {
 				const idx = indexMap.get(m);
 				if (idx !== undefined) {
-					const merged = modules[idx];
-					modules[idx + 1].push(connection);
+					const merged = /** @type {ConnectionState} */ (modules[idx]);
+					/** @type {ModuleGraphConnection[]} */
+					(/** @type {unknown} */ (modules[idx + 1])).push(connection);
 					if (merged === true) continue outer;
 					modules[idx] = ModuleGraphConnection.addConnectionStates(
 						merged,
@@ -191,7 +220,11 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 					modules[length] = state;
 					indexMap.set(m, length);
 					length++;
-					modules[length] = [connection];
+					/** @type {ModuleGraphConnection[]} */
+					(
+						/** @type {unknown} */
+						(modules[length])
+					) = [connection];
 					length++;
 				}
 			}
@@ -204,11 +237,12 @@ 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,
@@ -217,30 +251,51 @@ const visitModules = (
 	chunkGroupInfoMap,
 	blockConnections,
 	blocksWithNestedBlocks,
-	allCreatedChunkGroups
+	allCreatedChunkGroups,
+	maskByChunk
 ) => {
 	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
 
 	const blockModulesRuntimeMap = new Map();
 
-	/** @type {RuntimeSpec | false} */
-	let blockModulesMapRuntime = false;
-	/** @type {Map<DependenciesBlock, (Module | ConnectionState)[]>} */
+	/** @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 | ModuleGraphConnection[])[]} 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;
@@ -264,9 +319,11 @@ const visitModules = (
 		} else {
 			logger.time("visitModules: prepare");
 			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
-			blockModules = blockModulesMap.get(block);
+			blockModules =
+				/** @type {BlockModulesInFlattenTuples} */
+				(blockModulesMap.get(block));
 			logger.timeAggregate("visitModules: prepare");
-			return /** @type {(Module | ConnectionState)[]} */ (blockModules);
+			return blockModules;
 		}
 	};
 
@@ -331,7 +388,6 @@ const visitModules = (
 			chunkGroup,
 			runtime,
 			minAvailableModules: undefined,
-			minAvailableModulesOwned: false,
 			availableModulesToBeMerged: [],
 			skippedItems: undefined,
 			resultingAvailableModules: undefined,
@@ -354,15 +410,12 @@ const visitModules = (
 			// 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({
@@ -433,6 +486,7 @@ 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 | undefined} */
 		let c;
@@ -447,15 +501,15 @@ const visitModules = (
 					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,
@@ -482,7 +536,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);
 				}
 
@@ -490,7 +548,7 @@ const visitModules = (
 				queueDelayed.push({
 					action: PROCESS_ENTRY_BLOCK,
 					block: b,
-					module: module,
+					module,
 					chunk: entrypoint.chunks[0],
 					chunkGroup: entrypoint,
 					chunkGroupInfo: cgi
@@ -500,26 +558,26 @@ const visitModules = (
 				queue.push({
 					action: PROCESS_BLOCK,
 					block: b,
-					module: module,
+					module,
 					chunk,
 					chunkGroup,
 					chunkGroupInfo
 				});
 			} else {
-				cgi = chunkName && 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,
@@ -543,19 +601,23 @@ const visitModules = (
 							new AsyncDependencyToInitialChunkError(
 								/** @type {string} */ (chunkName),
 								module,
-								b.loc
+								/** @type {DependencyLocation} */ (b.loc)
 							)
 						);
 						c = chunkGroup;
 					} else {
 						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, /** @type {ChunkGroupInfo} */ (cgi));
-			blockByChunkGroups.set(cgi, b);
+			blockByChunkGroups.set(/** @type {ChunkGroupInfo} */ (cgi), b);
 		} else if (entryOptions) {
 			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 		} else {
@@ -565,7 +627,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
 			});
@@ -584,7 +647,7 @@ const visitModules = (
 			queueDelayed.push({
 				action: PROCESS_BLOCK,
 				block: b,
-				module: module,
+				module,
 				chunk: c.chunks[0],
 				chunkGroup: c,
 				chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
@@ -604,15 +667,22 @@ 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 += 3) {
+			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]
 				);
@@ -623,12 +693,7 @@ const visitModules = (
 					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;
@@ -694,15 +759,15 @@ const visitModules = (
 		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
 		if (blockModules !== undefined) {
-			// Traverse all referenced modules
-			for (let i = 0; i < blockModules.length; i += 3) {
+			// 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,
@@ -712,13 +777,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
@@ -750,12 +808,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: {
@@ -812,44 +876,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);
 	};
@@ -896,232 +940,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(module)
-										) {
-											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);
 			}
@@ -1134,34 +970,24 @@ const visitModules = (
 			for (const source of /** @type {Set<ChunkGroupInfo>} */ (
 				info.availableSources
 			)) {
-				if (!source.minAvailableModules) {
+				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 /** @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);
 		}
@@ -1175,13 +1001,11 @@ const visitModules = (
 			// 1. Reconsider skipped items
 			if (info.skippedItems !== undefined) {
 				const minAvailableModules =
-					/** @type {ModuleSetPlus} */
+					/** @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,
@@ -1198,7 +1022,7 @@ const visitModules = (
 			// 2. Reconsider skipped connections
 			if (info.skippedModuleConnections !== undefined) {
 				const minAvailableModules =
-					/** @type {ModuleSetPlus} */
+					/** @type {bigint} */
 					(info.minAvailableModules);
 				for (const entry of info.skippedModuleConnections) {
 					const [module, connections] = entry;
@@ -1208,15 +1032,13 @@ const visitModules = (
 					);
 					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,
@@ -1307,26 +1129,29 @@ const visitModules = (
 		let preOrderIndex = 0;
 		let postOrderIndex = 0;
 
-		const process = (current, visited = new Set()) => {
-			if (visited.has(current)) {
-				return;
-			}
-
-			visited.add(current);
-
+		/**
+		 * @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; i < blockModules.length; i += 3) {
-				const refModule = /** @type {Module} */ (blockModules[i]);
+			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++);
@@ -1336,9 +1161,10 @@ const visitModules = (
 			}
 		};
 
-		process(block);
+		process(block, new Set());
 	}
 	outdatedOrderIndexChunkGroups.clear();
+	ordinalByModule.clear();
 
 	logger.log(
 		`${statProcessedQueueItems} queue items processed (${statProcessedBlocks} blocks)`
@@ -1355,15 +1181,15 @@ 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;
 
@@ -1371,15 +1197,13 @@ const connectChunkGroups = (
 	 * 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;
 	};
@@ -1398,7 +1222,7 @@ const connectChunkGroups = (
 			connections.every(({ chunkGroup, originChunkGroupInfo }) =>
 				areModulesAvailable(
 					chunkGroup,
-					originChunkGroupInfo.resultingAvailableModules
+					/** @type {bigint} */ (originChunkGroupInfo.resultingAvailableModules)
 				)
 			)
 		) {
@@ -1444,7 +1268,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) => {
@@ -1452,18 +1276,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");
@@ -1474,7 +1301,8 @@ const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
 		chunkGroupInfoMap,
 		blockConnections,
 		blocksWithNestedBlocks,
-		allCreatedChunkGroups
+		allCreatedChunkGroups,
+		maskByChunk
 	);
 	logger.timeEnd("visitModules");
 
@@ -1485,7 +1313,7 @@ const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
 		compilation,
 		blocksWithNestedBlocks,
 		blockConnections,
-		chunkGroupInfoMap
+		maskByChunk
 	);
 	logger.timeEnd("connectChunkGroups");