webpack 5.90.1 → 5.90.3

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, ConnectionState]>=} 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<[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
@@ -61,16 +58,34 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @property {ChunkGroup} chunkGroup referenced chunk group
  */
 
-const EMPTY_SET = /** @type {ModuleSetPlus} */ (new Set());
-EMPTY_SET.plus = EMPTY_SET;
+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;
 };
 
 const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
@@ -99,9 +114,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 +127,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 +175,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 +187,8 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 					modules[length] = state;
 					indexMap.set(m, length);
 					length++;
+					modules[length] = [connection];
+					length++;
 				}
 			}
 		}
@@ -184,6 +205,7 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
  * @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 {Map<Chunk, bigint>} maskByChunk module content mask by chunk
  */
 const visitModules = (
 	logger,
@@ -192,7 +214,8 @@ const visitModules = (
 	chunkGroupInfoMap,
 	blockConnections,
 	blocksWithNestedBlocks,
-	allCreatedChunkGroups
+	allCreatedChunkGroups,
+	maskByChunk
 ) => {
 	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
 
@@ -203,11 +226,35 @@ const visitModules = (
 	/** @type {Map<DependenciesBlock, (Module | ConnectionState)[]>} */
 	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 {(Module | ConnectionState | ModuleGraphConnection[])[]} block modules in flatten tuples
 	 */
 	const getBlockModules = (block, runtime) => {
 		if (blockModulesMapRuntime !== runtime) {
@@ -306,7 +353,6 @@ const visitModules = (
 			chunkGroup,
 			runtime,
 			minAvailableModules: undefined,
-			minAvailableModulesOwned: false,
 			availableModulesToBeMerged: [],
 			skippedItems: undefined,
 			resultingAvailableModules: undefined,
@@ -329,15 +375,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({
@@ -382,7 +425,7 @@ const visitModules = (
 	/** @type {QueueItem[]} */
 	let queueDelayed = [];
 
-	/** @type {[Module, ConnectionState][]} */
+	/** @type {[Module, ModuleGraphConnection[]][]} */
 	const skipConnectionBuffer = [];
 	/** @type {Module[]} */
 	const skipBuffer = [];
@@ -425,12 +468,12 @@ const visitModules = (
 						b.loc,
 						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,
@@ -465,7 +508,7 @@ const visitModules = (
 				queueDelayed.push({
 					action: PROCESS_ENTRY_BLOCK,
 					block: b,
-					module: module,
+					module,
 					chunk: entrypoint.chunks[0],
 					chunkGroup: entrypoint,
 					chunkGroupInfo: cgi
@@ -475,7 +518,7 @@ const visitModules = (
 				queue.push({
 					action: PROCESS_BLOCK,
 					block: b,
-					module: module,
+					module,
 					chunk,
 					chunkGroup,
 					chunkGroupInfo
@@ -489,12 +532,12 @@ const visitModules = (
 						b.loc,
 						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,
@@ -559,7 +602,7 @@ const visitModules = (
 			queueDelayed.push({
 				action: PROCESS_BLOCK,
 				block: b,
-				module: module,
+				module,
 				chunk: c.chunks[0],
 				chunkGroup: c,
 				chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
@@ -582,24 +625,28 @@ 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, 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;
@@ -665,15 +712,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,
@@ -683,13 +730,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
@@ -721,12 +761,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 = maskByChunk.get(chunk);
+					chunkMask |= ONE_BIGINT << BigInt(moduleOrdinal);
+					maskByChunk.set(chunk, chunkMask);
 				}
 				// fallthrough
 				case ENTER_MODULE: {
@@ -783,44 +829,22 @@ 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 = 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 = maskByChunk.get(chunk);
+			resultingAvailableModules |= mask;
 		}
+
 		return (chunkGroupInfo.resultingAvailableModules =
 			resultingAvailableModules);
 	};
@@ -867,232 +891,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);
 			}
@@ -1105,34 +921,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);
 		}
@@ -1146,13 +952,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,
@@ -1169,21 +973,22 @@ 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, 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)) {
+							info.skippedItems.add(module);
+							continue;
+						}
 					}
 					queue.push({
 						action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
@@ -1274,7 +1079,7 @@ const visitModules = (
 		let preOrderIndex = 0;
 		let postOrderIndex = 0;
 
-		const process = (current, visited = new Set()) => {
+		const process = (current, visited) => {
 			if (visited.has(current)) {
 				return;
 			}
@@ -1286,14 +1091,14 @@ const visitModules = (
 				return;
 			}
 
-			for (let i = 0; i < blockModules.length; i += 2) {
-				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 (refModule) {
 					chunkGroup.setModulePreOrderIndex(refModule, preOrderIndex++);
@@ -1303,9 +1108,10 @@ const visitModules = (
 			}
 		};
 
-		process(block);
+		process(block, new Set());
 	}
 	outdatedOrderIndexChunkGroups.clear();
+	ordinalByModule.clear();
 
 	logger.log(
 		`${statProcessedQueueItems} queue items processed (${statProcessedBlocks} blocks)`
@@ -1324,13 +1130,13 @@ 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 {Map<Chunk, bigint>} maskByChunk mapping from chunk to module mask
  */
 const connectChunkGroups = (
 	compilation,
 	blocksWithNestedBlocks,
 	blockConnections,
-	chunkGroupInfoMap
+	maskByChunk
 ) => {
 	const { chunkGraph } = compilation;
 
@@ -1338,15 +1144,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 = maskByChunk.get(chunk);
+			if ((chunkMask & availableModules) !== chunkMask) return false;
 		}
 		return true;
 	};
@@ -1431,6 +1235,9 @@ const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
 	/** @type {Set<DependenciesBlock>} */
 	const blocksWithNestedBlocks = new Set();
 
+	/** @type {Map<Chunk, bigint>} */
+	const maskByChunk = new Map();
+
 	// PART ONE
 
 	logger.time("visitModules");
@@ -1441,7 +1248,8 @@ const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
 		chunkGroupInfoMap,
 		blockConnections,
 		blocksWithNestedBlocks,
-		allCreatedChunkGroups
+		allCreatedChunkGroups,
+		maskByChunk
 	);
 	logger.timeEnd("visitModules");
 
@@ -1452,7 +1260,7 @@ const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
 		compilation,
 		blocksWithNestedBlocks,
 		blockConnections,
-		chunkGroupInfoMap
+		maskByChunk
 	);
 	logger.timeEnd("connectChunkGroups");