@depup/webpack 5.111.1-depup.1 → 5.112.0-depup.0

package/lib/optimize/SplitChunksPlugin.js

@@ -5,8 +5,7 @@
 
 "use strict";
 
-const Chunk = require("../Chunk");
-const { STAGE_ADVANCED } = require("../OptimizationStages");
+const MinMaxSizeWarning = require("../errors/MinMaxSizeWarning");
 const WebpackError = require("../errors/WebpackError");
 const { requestToId } = require("../ids/IdHelpers");
 const { isSubset } = require("../util/SetHelpers");
@@ -16,10 +15,15 @@ const {
 	compareModulesByIdentifier
 } = require("../util/comparators");
 const createHash = require("../util/createHash");
-const deterministicGrouping = require("../util/deterministicGrouping");
 const { makePathsRelative } = require("../util/identifier");
 const memoize = require("../util/memoize");
-const MinMaxSizeWarning = require("./MinMaxSizeWarning");
+const { STAGE_ADVANCED } = require("./OptimizationStages");
+const { discoverIntersections } = require("./chunkSetIntersections");
+const deterministicGrouping = require("./deterministicGrouping");
+
+const getMatchModuleGlobCondition = memoize(
+	() => require("../util/globUtils").matchModuleGlobCondition
+);
 
 /**
  * @import {
@@ -33,16 +37,16 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * 	OutputNormalizedWithDefaults as OutputOptions
  * } from "../config/defaults"
  */
-/** @import { ChunkName, ChunkFilenameTemplate } from "../Chunk" */
-/** @import ChunkGraph from "../ChunkGraph" */
-/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Chunk, { ChunkName, ChunkFilenameTemplate } from "../graph/Chunk" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
+/** @import ChunkGroup from "../graph/ChunkGroup" */
 /** @import Compilation from "../Compilation" */
 /** @import Compiler from "../Compiler" */
-/** @import Module, { SourceType } from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
-/** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
-/** @import { Sizes } from "../util/deterministicGrouping" */
+/** @import Module, { SourceType } from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @typedef {import("./deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
+/** @typedef {import("./deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
+/** @import { Sizes } from "./deterministicGrouping" */
 
 /**
  * Defines the chunk filter fn callback.
@@ -114,6 +118,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {boolean} reuseExistingChunk
  * @property {boolean} usedExports
  * @property {boolean} _validateSize
+ * @property {boolean} _validateSizeReduction
  * @property {boolean} _validateRemainingSize
  * @property {SplitChunksSizes} _minSizeForMaxSize
  * @property {boolean} _conditionalEnforce
@@ -158,6 +163,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /**
  * Defines the split chunks options type used by this module.
  * @typedef {object} SplitChunksOptions
+ * @property {number | undefined} dedupDepth
  * @property {ChunkFilterFn} chunksFilter
  * @property {DefaultSizeTypes} defaultSizeTypes
  * @property {SplitChunksSizes} minSize
@@ -178,6 +184,22 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {FallbackCacheGroup} fallbackCacheGroup
  */
 
+/**
+ * A cache group as intersection discovery reads it: what it takes, and how much
+ * the modules it would take have to weigh.
+ * @typedef {object} IntersectionCacheGroup
+ * @property {OptimizationSplitChunksCacheGroup["test"]} test the modules it accepts
+ * @property {SplitChunksSizes} minSize the size each of their types must reach
+ */
+
+/**
+ * What the cache groups taking intersections allow discovery to assume.
+ * @typedef {object} IntersectionSettings
+ * @property {number} minSize size an intersection's modules must reach, `0` when unbounded
+ * @property {number} minMembers fewest chunks an intersection is worth discovering with
+ * @property {IntersectionCacheGroup[] | undefined} groups the cache groups taking them, when every one of them is known
+ */
+
 /** @typedef {Set<Chunk>} ChunkSet  */
 
 /**
@@ -340,8 +362,14 @@ const ASYNC_CHUNK_FILTER = (chunk) => !chunk.canBeInitial();
  */
 const ALL_CHUNK_FILTER = (_chunk) => true;
 
-/** Placeholder until a chunk set group is filled and its signatures are written. */
-const EMPTY_SIGNATURES = new Uint32Array(0);
+// What one compilation may spend looking for the intersections of its chunk
+// sets: a word of every pair of them it reaches, and the intersections it keeps,
+// bounding the worst case of chunk sets that each span most chunks.
+
+// TODO raise or drop both once threads carry the search, as rspack needs no
+// ceiling with rayon behind it
+const MAX_INTERSECTION_WORK = 50000000;
+const MAX_INTERSECTIONS = 10000;
 
 /**
  * Returns normalized representation.
@@ -513,19 +541,41 @@ const normalizeChunksFilter = (chunks) => {
 	}
 };
 
+/**
+ * A cache group source a module can only match or not, and what decides it.
+ * @typedef {object} StaticCacheGroupSource
+ * @property {CacheGroupSource} source the normalized source
+ * @property {OptimizationSplitChunksCacheGroup["test"]} test the modules it accepts
+ */
+
+/**
+ * The normalized cache groups, and what is known about them without a module.
+ * @typedef {object} NormalizedCacheGroups
+ * @property {GetCacheGroups} getCacheGroups a function to get the cache groups
+ * @property {StaticCacheGroupSource[]} staticSources the sources a module can only match or not
+ * @property {boolean} hasDynamicSources true when a callback builds sources per module
+ */
+
 /**
  * Normalizes cache groups.
  * @param {undefined | GetCacheGroups | Record<string, false | string | RegExp | RawGetCacheGroups | OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
  * @param {DefaultSizeTypes} defaultSizeTypes the default size types
- * @returns {GetCacheGroups} a function to get the cache groups
+ * @returns {NormalizedCacheGroups} the normalized cache groups
  */
 const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 	if (typeof cacheGroups === "function") {
-		return cacheGroups;
+		return {
+			getCacheGroups: cacheGroups,
+			staticSources: [],
+			hasDynamicSources: true
+		};
 	}
 	if (typeof cacheGroups === "object" && cacheGroups !== null) {
 		/** @type {((module: Module, context: CacheGroupsContext, results: CacheGroupSource[]) => void)[]} */
 		const handlers = [];
+		/** @type {StaticCacheGroupSource[]} */
+		const staticSources = [];
+		let hasDynamicSources = false;
 		for (const key of Object.keys(cacheGroups)) {
 			const option = cacheGroups[key];
 			if (option === false) {
@@ -533,6 +583,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 			}
 			if (typeof option === "string" || option instanceof RegExp) {
 				const source = createCacheGroupSource({}, key, defaultSizeTypes);
+				staticSources.push({ source, test: option });
 				handlers.push((module, context, results) => {
 					if (checkTest(option, module, context)) {
 						results.push(source);
@@ -541,6 +592,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 			} else if (typeof option === "function") {
 				/** @type {WeakMap<OptimizationSplitChunksCacheGroup, CacheGroupSource>} */
 				const cache = new WeakMap();
+				hasDynamicSources = true;
 				handlers.push((module, context, results) => {
 					const result = option(module);
 					if (result) {
@@ -563,6 +615,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 				});
 			} else {
 				const source = createCacheGroupSource(option, key, defaultSizeTypes);
+				staticSources.push({ source, test: option.test });
 				handlers.push((module, context, results) => {
 					if (
 						checkTest(option.test, module, context) &&
@@ -588,9 +641,13 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 			}
 			return results;
 		};
-		return fn;
+		return { getCacheGroups: fn, staticSources, hasDynamicSources };
 	}
-	return () => null;
+	return {
+		getCacheGroups: () => null,
+		staticSources: [],
+		hasDynamicSources: false
+	};
 };
 
 /** @typedef {(module: Module, context: CacheGroupsContext) => boolean} CheckTestFn */
@@ -616,9 +673,36 @@ const checkTest = (test, module, context) => {
 		const name = module.nameForCondition();
 		return name ? test.test(name) : false;
 	}
+	if (typeof test === "object") {
+		return getMatchModuleGlobCondition()(test, module);
+	}
 	return false;
 };
 
+/**
+ * Whether a module matches a test that decides it without running user code.
+ * A callback or a test naming no modules is treated as matching, so a module it
+ * might take is never taken for one it cannot.
+ * @param {OptimizationSplitChunksCacheGroup["test"]} test test option
+ * @param {Module} module the module
+ * @returns {boolean} true, if the module may be selected
+ */
+const matchesStaticTest = (test, module) => {
+	if (typeof test === "string") {
+		const name = module.nameForCondition();
+		return name ? name.startsWith(test) : false;
+	}
+	if (test instanceof RegExp) {
+		const name = module.nameForCondition();
+		return name ? test.test(name) : false;
+	}
+	if (typeof test === "object") {
+		return getMatchModuleGlobCondition()(test, module);
+	}
+	if (typeof test === "boolean") return test;
+	return true;
+};
+
 /** @typedef {(type: string) => boolean} CheckModuleTypeFn */
 
 /**
@@ -724,6 +808,16 @@ class SplitChunksPlugin {
 	 * @param {OptimizationSplitChunksOptions=} options plugin options
 	 */
 	constructor(options = {}) {
+		if (
+			options.dedupDepth !== undefined &&
+			(!Number.isInteger(options.dedupDepth) ||
+				options.dedupDepth < 0 ||
+				options.dedupDepth > 0xffffffff)
+		) {
+			throw new WebpackError(
+				'"optimization.splitChunks.dedupDepth" must be an integer between 0 and 4294967295.'
+			);
+		}
 		const defaultSizeTypes = options.defaultSizeTypes || [
 			"javascript",
 			"unknown"
@@ -735,9 +829,12 @@ class SplitChunksPlugin {
 			defaultSizeTypes
 		);
 		const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
+		const { getCacheGroups, staticSources, hasDynamicSources } =
+			normalizeCacheGroups(options.cacheGroups, defaultSizeTypes);
 
 		/** @type {SplitChunksOptions} */
 		this.options = {
+			dedupDepth: options.dedupDepth,
 			chunksFilter:
 				/** @type {ChunkFilterFn} */
 				(normalizeChunksFilter(options.chunks || "all")),
@@ -765,10 +862,7 @@ class SplitChunksPlugin {
 			maxInitialRequests: options.maxInitialRequests || 1,
 			hidePathInfo: options.hidePathInfo || false,
 			filename: options.filename || undefined,
-			getCacheGroups: normalizeCacheGroups(
-				options.cacheGroups,
-				defaultSizeTypes
-			),
+			getCacheGroups,
 			getName: options.name
 				? /** @type {GetNameFn} */ (normalizeName(options.name))
 				: defaultGetName,
@@ -807,6 +901,64 @@ class SplitChunksPlugin {
 
 		/** @type {WeakMap<CacheGroupSource, CacheGroup>} */
 		this._cacheGroupCache = new WeakMap();
+		/** @type {StaticCacheGroupSource[]} */
+		this._staticCacheGroupSources = staticSources;
+		this._hasDynamicCacheGroups = hasDynamicSources;
+	}
+
+	/**
+	 * Settings for the intersections a chunk set discovers, or `undefined` when no
+	 * cache group would take one.
+	 * @param {boolean} usedExports true for the sets grouped by used exports
+	 * @param {number} dedupDepth rounds of discovery this compilation allows
+	 * @returns {IntersectionSettings | undefined} the settings, when discovery applies
+	 */
+	_getIntersectionSettings(usedExports, dedupDepth) {
+		if (dedupDepth === 0) return undefined;
+		// A callback builds its cache groups per module, so neither what they take
+		// nor what they ask of it is known here: discover for the widest of them,
+		// and bound nothing.
+		if (this._hasDynamicCacheGroups) {
+			return { minSize: 0, minMembers: 1, groups: undefined };
+		}
+		/** @type {IntersectionCacheGroup[]} */
+		const groups = [];
+		let minMembers = Number.POSITIVE_INFINITY;
+		/** @type {number | undefined} */
+		let minSize;
+		for (const { source, test } of this._staticCacheGroupSources) {
+			const cacheGroup = this._getCacheGroup(source);
+			if (
+				cacheGroup.usedExports !== usedExports ||
+				cacheGroup.getName !== defaultGetName ||
+				(!cacheGroup._validateSize && !cacheGroup._validateSizeReduction)
+			) {
+				continue;
+			}
+			groups.push({ test, minSize: cacheGroup.minSize });
+			minMembers = Math.min(minMembers, Math.max(1, cacheGroup.minChunks));
+			if (minSize === 0) continue;
+			// A chunk filter can map two intersections onto the same selected
+			// chunks, where only the modules of both together reach `minSize`, so
+			// a bound holds only for groups taking the chunks as they are.
+
+			// TODO intersect what a filter selects, where every group shares one,
+			// so a filtered build is bounded as well
+			if (
+				cacheGroup.chunksFilter !== ALL_CHUNK_FILTER ||
+				!cacheGroup._validateSize
+			) {
+				minSize = 0;
+				continue;
+			}
+			for (const size of Object.values(cacheGroup.minSize)) {
+				if (size > 0 && (minSize === undefined || size < minSize)) {
+					minSize = size;
+				}
+			}
+		}
+		if (groups.length === 0) return undefined;
+		return { minSize: minSize || 0, minMembers, groups };
 	}
 
 	/**
@@ -890,6 +1042,7 @@ class SplitChunksPlugin {
 					: cacheGroupSource.key,
 			reuseExistingChunk: cacheGroupSource.reuseExistingChunk || false,
 			_validateSize: hasNonZeroSizes(minSize),
+			_validateSizeReduction: hasNonZeroSizes(minSizeReduction),
 			_validateRemainingSize: hasNonZeroSizes(minRemainingSize),
 			_minSizeForMaxSize: mergeSizes(
 				cacheGroupSource.minSize,
@@ -941,24 +1094,50 @@ class SplitChunksPlugin {
 					logger.time("prepare");
 					const chunkGraph = compilation.chunkGraph;
 					const moduleGraph = compilation.moduleGraph;
+					// Rounds of discovery: what the option says, or what the defaults
+					// of the next major imply, as a plugin constructed by hand reads
+					// no defaults of its own
+					const dedupDepth =
+						this.options.dedupDepth === undefined
+							? compiler.options.experiments.futureDefaults
+								? 1
+								: 0
+							: this.options.dedupDepth;
+					const intersectionSettings = this._getIntersectionSettings(
+						false,
+						dedupDepth
+					);
+					const exportsIntersectionSettings = this._getIntersectionSettings(
+						true,
+						dedupDepth
+					);
+					// Chunks in the index intersection discovery works in, built only
+					// when a cache group would take an intersection
+					/** @type {Chunk[] | undefined} */
+					const intersectionChunks =
+						intersectionSettings === undefined &&
+						exportsIntersectionSettings === undefined
+							? undefined
+							: [];
+					// The index of each of those chunks
+					/** @type {Map<Chunk, number>} */
+					const intersectionChunkIndices = new Map();
 					// Give each selected chunk an index (to create strings from chunks)
 					/** @type {Map<Chunk, bigint>} */
 					const chunkIndexMap = new Map();
-					// Dense per-chunk index, folded into the 64 bit membership
-					// signatures that reject non-subsets in getCombinations
-					/** @type {Map<Chunk, number>} */
-					const chunkSignatureBitMap = new Map();
 					const ZERO = BigInt("0");
 					const ONE = BigInt("1");
 					const START = ONE << BigInt("31");
 					let index = START;
-					let denseIndex = 0;
 					for (const chunk of chunks) {
 						chunkIndexMap.set(
 							chunk,
 							index | BigInt((Math.random() * 0x7fffffff) | 0)
 						);
-						chunkSignatureBitMap.set(chunk, denseIndex++ & 63);
+						if (intersectionChunks !== undefined) {
+							intersectionChunkIndices.set(chunk, intersectionChunks.length);
+							intersectionChunks.push(chunk);
+						}
 						index <<= ONE;
 					}
 					/**
@@ -992,11 +1171,61 @@ class SplitChunksPlugin {
 						return /** @type {bigint} */ (chunkIndexMap.get(key)).toString(16);
 					};
 
+					/**
+					 * Most a module can weigh towards an intersection of these cache groups, `0`
+					 * when none of them takes it and `Infinity` when a size of it is unknown or
+					 * bounded by nothing.
+					 * @param {Module} module the module
+					 * @param {IntersectionCacheGroup[]} groups the cache groups taking the intersections
+					 * @returns {number} the bound
+					 */
+					const getModuleSizeBound = (module, groups) => {
+						// A native test is exact, so a module no group accepts weighs nothing. A
+						// callback stays a possible match rather than being called a second time.
+						if (!groups.some(({ test }) => matchesStaticTest(test, module))) {
+							return 0;
+						}
+						let bound = 0;
+						let types = 0;
+						for (const type of module.getSourceTypes()) {
+							types++;
+							for (const { minSize } of groups) {
+								// Without a threshold on this type, arbitrarily few bytes of it survive
+								// minSize, so nothing about this module bounds anything
+								if (!(minSize[type] > 0)) return Number.POSITIVE_INFINITY;
+							}
+							const size = module.size(type);
+							if (!(size >= 0) || size === Number.POSITIVE_INFINITY) {
+								return Number.POSITIVE_INFINITY;
+							}
+							bound += size;
+						}
+						return types === 0 ? Number.POSITIVE_INFINITY : bound;
+					};
+
+					/** Whether discovery of these sets prunes by size. */
+					const boundsChunkSetSizes =
+						intersectionSettings !== undefined &&
+						intersectionSettings.minSize > 0;
+					const boundsExportsChunkSetSizes =
+						exportsIntersectionSettings !== undefined &&
+						exportsIntersectionSettings.minSize > 0;
+
 					const getChunkSetsInGraph = memoize(() => {
 						/** @type {Map<bigint, ChunkSet>} */
 						const chunkSetsInGraph = new Map();
 						/** @type {ChunkSet} */
 						const singleChunkSets = new Set();
+						// Only what a chunk set's own modules weigh, and only where a bound on it
+						// can reject an intersection
+						/** @type {Map<bigint | Chunk, number> | undefined} */
+						const sizeByKey = boundsChunkSetSizes ? new Map() : undefined;
+						const groups = boundsChunkSetSizes
+							? /** @type {IntersectionCacheGroup[]} */ (
+									/** @type {IntersectionSettings} */ (intersectionSettings)
+										.groups
+								)
+							: undefined;
 						for (const module of compilation.modules) {
 							const chunks = chunkGraph.getModuleChunksIterable(module);
 							const chunksKey = getKey(chunks);
@@ -1007,8 +1236,18 @@ class SplitChunksPlugin {
 							} else {
 								singleChunkSets.add(chunksKey);
 							}
+							if (sizeByKey !== undefined) {
+								sizeByKey.set(
+									chunksKey,
+									(sizeByKey.get(chunksKey) || 0) +
+										getModuleSizeBound(
+											module,
+											/** @type {IntersectionCacheGroup[]} */ (groups)
+										)
+								);
+							}
 						}
-						return { chunkSetsInGraph, singleChunkSets };
+						return { chunkSetsInGraph, singleChunkSets, sizeByKey };
 					});
 
 					/**
@@ -1032,127 +1271,355 @@ class SplitChunksPlugin {
 						return groupedByUsedExports.values();
 					};
 
-					/** @type {Map<Module, Iterable<Chunk[]>>} */
+					/** @type {Map<Module, Chunk[][]>} */
 					const groupedByExportsMap = new Map();
 
-					/** @typedef {Map<bigint | Chunk, ChunkSet>} ChunkSetsInGraph */
+					/** @typedef {Map<bigint, ChunkSet>} ChunkSetsInGraph */
 
 					const getExportsChunkSetsInGraph = memoize(() => {
 						/** @type {ChunkSetsInGraph} */
 						const chunkSetsInGraph = new Map();
 						/** @type {ChunkSet} */
 						const singleChunkSets = new Set();
+						// A module counts towards every group it appears in, which can only
+						// overstate a group, never hide an intersection worth splitting
+						/** @type {Map<bigint | Chunk, number> | undefined} */
+						const sizeByKey = boundsExportsChunkSetSizes
+							? new Map()
+							: undefined;
+						const groups = boundsExportsChunkSetSizes
+							? /** @type {IntersectionCacheGroup[]} */ (
+									/** @type {IntersectionSettings} */ (
+										exportsIntersectionSettings
+									).groups
+								)
+							: undefined;
 						for (const module of compilation.modules) {
 							const groupedChunks = [...groupChunksByExports(module)];
 							groupedByExportsMap.set(module, groupedChunks);
 							for (const chunks of groupedChunks) {
+								const chunksKey = getKey(chunks);
 								if (chunks.length === 1) {
 									singleChunkSets.add(chunks[0]);
 								} else {
-									const chunksKey = getKey(chunks);
-									if (!chunkSetsInGraph.has(chunksKey)) {
-										chunkSetsInGraph.set(chunksKey, new Set(chunks));
+									// More than one chunk, so the key is the bigint of their ids
+									const setKey = /** @type {bigint} */ (chunksKey);
+									if (!chunkSetsInGraph.has(setKey)) {
+										chunkSetsInGraph.set(setKey, new Set(chunks));
 									}
 								}
+								if (sizeByKey !== undefined) {
+									sizeByKey.set(
+										chunksKey,
+										(sizeByKey.get(chunksKey) || 0) +
+											getModuleSizeBound(
+												module,
+												/** @type {IntersectionCacheGroup[]} */ (groups)
+											)
+									);
+								}
 							}
 						}
-						return { chunkSetsInGraph, singleChunkSets };
+						return { chunkSetsInGraph, singleChunkSets, sizeByKey };
 					});
 
 					/**
-					 * Chunk sets of equal size, with a 64 bit membership signature
-					 * per set stored as two words at `2 * i` in `signatures`.
-					 * @typedef {object} ChunkSetGroup
-					 * @property {ChunkSet[]} sets the chunk sets
-					 * @property {Uint32Array} signatures two signature words per set
+					 * The chunk sets a combination can be taken from, in the order they are
+					 * combined in, indexed by the chunk fewest of them hold.
+					 * @typedef {object} ChunkSetIndex
+					 * @property {ChunkSet[]} sets the chunk sets, smaller counts first
+					 * @property {Map<Chunk, number[]>} setsByRarestChunk what to try for a chunk
+					 * @property {Map<Chunk, number>} singleOrder order of the single chunk sets
 					 */
 
-					/** @typedef {Map<CountOfChunk, ChunkSetGroup>} ChunkSetsByCount */
-
-					// holds the signature of the set currently being combined; transient
-					const signatureScratch = new Uint32Array(2);
-
 					/**
-					 * Folds a chunk set into a 64 bit membership signature.
-					 * @param {ChunkSet} chunksSet set of chunks
-					 * @param {Uint32Array} out target array
-					 * @param {number} offset index of the first of the two words
-					 * @returns {void}
+					 * Indexes chunk sets for the subsets of a set to be found without walking all
+					 * of them: a subset holds the chunk fewest sets hold of it, so only the sets
+					 * indexed under a chunk of the superset can be one.
+					 * @param {IterableIterator<ChunkSet>} chunkSets set of sets of chunks
+					 * @param {ChunkSet} singleChunkSets the chunks holding modules of their own
+					 * @returns {ChunkSetIndex} the sets, and where to look for a subset
 					 */
-					const writeSignature = (chunksSet, out, offset) => {
-						out[offset] = 0;
-						out[offset + 1] = 0;
-						for (const chunk of chunksSet) {
-							const bit = /** @type {number} */ (
-								chunkSignatureBitMap.get(chunk)
-							);
-							out[offset + (bit >> 5)] |= 1 << (bit & 31);
+					const indexChunkSets = (chunkSets, singleChunkSets) => {
+						// Grouped by count, as only a smaller set can be a proper subset, and
+						// combined in that order
+						/** @type {Map<CountOfChunk, ChunkSet[]>} */
+						const setsByCount = new Map();
+						/** @type {Map<Chunk, number>} */
+						const holders = new Map();
+						for (const chunksSet of chunkSets) {
+							const group = setsByCount.get(chunksSet.size);
+							if (group === undefined) {
+								setsByCount.set(chunksSet.size, [chunksSet]);
+							} else {
+								group.push(chunksSet);
+							}
+							for (const chunk of chunksSet) {
+								holders.set(chunk, (holders.get(chunk) || 0) + 1);
+							}
+						}
+						/** @type {ChunkSet[]} */
+						const sets = [];
+						for (const group of setsByCount.values()) {
+							for (const chunksSet of group) sets.push(chunksSet);
 						}
+						/** @type {Map<Chunk, number[]>} */
+						const setsByRarestChunk = new Map();
+						for (let i = 0; i < sets.length; i++) {
+							/** @type {Chunk | undefined} */
+							let rarest;
+							let fewest = 0;
+							for (const chunk of sets[i]) {
+								const count = /** @type {number} */ (holders.get(chunk));
+								if (rarest === undefined || count < fewest) {
+									rarest = chunk;
+									fewest = count;
+								}
+							}
+							if (rarest === undefined) continue;
+							const indices = setsByRarestChunk.get(rarest);
+							if (indices === undefined) setsByRarestChunk.set(rarest, [i]);
+							else indices.push(i);
+						}
+						/** @type {Map<Chunk, number>} */
+						const singleOrder = new Map();
+						for (const chunk of singleChunkSets) {
+							singleOrder.set(chunk, singleOrder.size);
+						}
+						return { sets, setsByRarestChunk, singleOrder };
 					};
+					const getChunkSetIndex = memoize(() => {
+						const { chunkSetsInGraph, singleChunkSets } = getChunkSetsInGraph();
+						return indexChunkSets(chunkSetsInGraph.values(), singleChunkSets);
+					});
+					const getExportsChunkSetIndex = memoize(() => {
+						const { chunkSetsInGraph, singleChunkSets } =
+							getExportsChunkSetsInGraph();
+						return indexChunkSets(chunkSetsInGraph.values(), singleChunkSets);
+					});
 
-					// group these set of chunks by count
-					// to allow to check less sets via isSubset
-					// (only smaller sets can be subset)
 					/**
-					 * Group chunk sets by count.
-					 * @param {IterableIterator<ChunkSet>} chunkSets set of sets of chunks
-					 * @returns {ChunkSetsByCount} map of sets of chunks by count
+					 * Discovers the intersections of the chunk sets that are not chunk sets
+					 * themselves, and groups them by the sets holding all of their chunks.
+					 * @param {ChunkSetsInGraph} chunkSets the chunk sets in the graph
+					 * @param {ChunkSet} singleChunkSets the chunks holding modules of their own
+					 * @param {Map<bigint | Chunk, number> | undefined} sizeByKey size of the modules behind each chunk set
+					 * @param {IntersectionSettings} settings what the cache groups taking them allow
+					 * @returns {Map<bigint | Chunk, ChunkSet[]>} intersections by the key of each set holding them
 					 */
-					const groupChunkSetsByCount = (chunkSets) => {
-						/** @type {ChunkSetsByCount} */
-						const chunkSetsByCount = new Map();
-						for (const chunksSet of chunkSets) {
-							const count = chunksSet.size;
-							let group = chunkSetsByCount.get(count);
-							if (group === undefined) {
-								group = { sets: [], signatures: EMPTY_SIGNATURES };
-								chunkSetsByCount.set(count, group);
+					const discoverChunkSetIntersections = (
+						chunkSets,
+						singleChunkSets,
+						sizeByKey,
+						settings
+					) => {
+						/** @type {Map<bigint | Chunk, ChunkSet[]>} */
+						const result = new Map();
+						if (chunkSets.size < 2) return result;
+						// Widest sets first, so a limit keeps the intersections reaching the most
+						// chunks, and by key after that, so no module order reaches the result
+						/** @type {(bigint | Chunk)[]} */
+						const keys = [...chunkSets.keys()].sort((a, b) => {
+							const countDiff =
+								/** @type {ChunkSet} */ (chunkSets.get(b)).size -
+								/** @type {ChunkSet} */ (chunkSets.get(a)).size;
+							if (countDiff !== 0) return countDiff;
+							return a < b ? -1 : 1;
+						});
+						// A chunk of its own is keyed by the chunk, so what holds both is wider
+						// than what the graph's chunk sets are keyed by
+						let memberCount = 0;
+						for (const set of chunkSets.values()) memberCount += set.size;
+						// A one chunk intersection holds only what a chunk of its own already holds,
+						// so those sets are inputs for what they weigh and the sets holding them
+						const multiSetCount = keys.length;
+						if (settings.minMembers < 2) {
+							for (const chunk of singleChunkSets) keys.push(chunk);
+							memberCount += keys.length - multiSetCount;
+						}
+						const setCount = keys.length;
+						const offsets = new Int32Array(setCount + 1);
+						const members = new Int32Array(memberCount);
+						const sizes =
+							sizeByKey === undefined ? undefined : new Float64Array(setCount);
+						let cursor = 0;
+						for (let i = 0; i < setCount; i++) {
+							const key = keys[i];
+							if (sizes !== undefined) {
+								sizes[i] =
+									/** @type {Map<bigint | Chunk, number>} */ (sizeByKey).get(
+										key
+									) || 0;
+							}
+							offsets[i] = cursor;
+							if (i < multiSetCount) {
+								for (const chunk of /** @type {ChunkSet} */ (
+									chunkSets.get(/** @type {bigint} */ (key))
+								)) {
+									members[cursor++] = /** @type {number} */ (
+										intersectionChunkIndices.get(chunk)
+									);
+								}
+							} else {
+								members[cursor++] = /** @type {number} */ (
+									intersectionChunkIndices.get(/** @type {Chunk} */ (key))
+								);
 							}
-							group.sets.push(chunksSet);
+							offsets[i + 1] = cursor;
 						}
-						for (const group of chunkSetsByCount.values()) {
-							const { sets } = group;
-							const signatures = new Uint32Array(sets.length * 2);
-							for (let i = 0; i < sets.length; i++) {
-								writeSignature(sets[i], signatures, i * 2);
+						const { intersections, capped } = discoverIntersections({
+							setCount,
+							memberCount: intersectionChunkIndices.size,
+							offsets,
+							members,
+							depth: dedupDepth,
+							minMembers: settings.minMembers,
+							sizes,
+							minSize: settings.minSize,
+							maxIntersections: MAX_INTERSECTIONS,
+							maxWork: MAX_INTERSECTION_WORK
+						});
+						if (capped) {
+							logger.warn(
+								`Stopped looking for chunk sets to share modules through at ${MAX_INTERSECTIONS} of them, or at the work of intersecting ${MAX_INTERSECTION_WORK} words. Some modules chunks share stay where they are. Lower "optimization.splitChunks.dedupDepth" to spend less on the search.`
+							);
+						}
+						const chunkList = /** @type {Chunk[]} */ (intersectionChunks);
+						for (const { members: chunkIndices, support } of intersections) {
+							/** @type {ChunkSet} */
+							const intersection = new Set();
+							for (const index of chunkIndices) {
+								intersection.add(chunkList[index]);
+							}
+							for (const set of support) {
+								// The one intersection a single chunk could hold is that chunk, which
+								// is a combination of its modules already
+								if (set >= multiSetCount) continue;
+								const key = keys[set];
+								const held = result.get(key);
+								if (held === undefined) result.set(key, [intersection]);
+								else held.push(intersection);
 							}
-							group.signatures = signatures;
 						}
-						return chunkSetsByCount;
+						return result;
 					};
-					const getChunkSetsByCount = memoize(() =>
-						groupChunkSetsByCount(
-							getChunkSetsInGraph().chunkSetsInGraph.values()
-						)
-					);
-					const getExportsChunkSetsByCount = memoize(() =>
-						groupChunkSetsByCount(
-							getExportsChunkSetsInGraph().chunkSetsInGraph.values()
-						)
-					);
+
+					// How many combinations of each chunk set are chunk sets in the graph, for the
+					// cache groups that take no intersections. Missing means all of them.
+					/** @type {Map<Combinations, number>} */
+					const originalCombinationCounts = new Map();
+					/** @type {Map<Combinations, number>} */
+					const originalExportsCombinationCounts = new Map();
+
+					// TODO rebuild the candidates per cache group priority, from the
+					// module chunk edges the priorities before it left, as rspack does
+					const getIntersectionsByChunkSetKey = memoize(() => {
+						const { chunkSetsInGraph, singleChunkSets, sizeByKey } =
+							getChunkSetsInGraph();
+						return discoverChunkSetIntersections(
+							chunkSetsInGraph,
+							singleChunkSets,
+							sizeByKey,
+							/** @type {IntersectionSettings} */ (intersectionSettings)
+						);
+					});
+					const getExportsIntersectionsByChunkSetKey = memoize(() => {
+						const { chunkSetsInGraph, singleChunkSets, sizeByKey } =
+							getExportsChunkSetsInGraph();
+						return discoverChunkSetIntersections(
+							chunkSetsInGraph,
+							singleChunkSets,
+							sizeByKey,
+							/** @type {IntersectionSettings} */ (exportsIntersectionSettings)
+						);
+					});
 
 					/** @typedef {(ChunkSet | Chunk)[]} Combinations */
 
+					/**
+					 * Where a chunk set's own combinations end, for a cache group that
+					 * takes no intersection.
+					 * @param {Combinations} combinations the combinations
+					 * @param {boolean} withIntersections whether the group takes the intersections too
+					 * @param {Map<Combinations, number>} originalCounts how many of them are chunk sets themselves
+					 * @returns {number} where to stop
+					 */
+					const originalCombinationCount = (
+						combinations,
+						withIntersections,
+						originalCounts
+					) => {
+						if (withIntersections || originalCounts.size === 0) {
+							return combinations.length;
+						}
+						const originals = originalCounts.get(combinations);
+						return originals === undefined ? combinations.length : originals;
+					};
+
+					/**
+					 * Appends the intersections a chunk set holds to its combinations.
+					 * @param {bigint | Chunk} key key of the chunk set
+					 * @param {Combinations} combinations its combinations
+					 * @param {() => Map<bigint | Chunk, ChunkSet[]>} getIntersectionsByKey takes the intersections held by each chunk set
+					 * @param {Map<Combinations, number>} originalCounts takes how many of them are chunk sets themselves
+					 * @returns {void}
+					 */
+					const appendIntersections = (
+						key,
+						combinations,
+						getIntersectionsByKey,
+						originalCounts
+					) => {
+						// The chunk sets stay in front, so a cache group taking no
+						// intersection reads only up to their count
+						originalCounts.set(combinations, combinations.length);
+						const intersections = getIntersectionsByKey().get(key);
+						if (intersections === undefined) return;
+						for (const intersection of intersections) {
+							combinations.push(intersection);
+						}
+					};
+
 					// Create a list of possible combinations
 					/**
 					 * Creates a get combinations.
 					 * @param {ChunkSetsInGraph} chunkSets chunk sets
-					 * @param {ChunkSet} singleChunkSets single chunks sets
-					 * @param {ChunkSetsByCount} chunkSetsByCount chunk sets by count
-					 * @returns {(key: bigint | Chunk) => Combinations} combinations
+					 * @param {ChunkSetIndex} index the chunk sets a combination is taken from
+					 * @param {(() => Map<bigint | Chunk, ChunkSet[]>) | undefined} getIntersectionsByKey takes the intersections held by each chunk set, on the first cache group asking for them
+					 * @param {Map<Combinations, number>} originalCounts takes how many of a chunk set's combinations are chunk sets themselves
+					 * @returns {(key: bigint | Chunk, withIntersections: boolean) => Combinations} combinations
 					 */
 					const createGetCombinations = (
 						chunkSets,
-						singleChunkSets,
-						chunkSetsByCount
+						index,
+						getIntersectionsByKey,
+						originalCounts
 					) => {
+						const { sets, setsByRarestChunk, singleOrder } = index;
 						/** @type {Map<bigint | Chunk, Combinations>} */
 						const combinationsCache = new Map();
 
-						return (key) => {
+						return (key, withIntersections) => {
 							const cacheEntry = combinationsCache.get(key);
-							if (cacheEntry !== undefined) return cacheEntry;
-							if (key instanceof Chunk) {
+							if (cacheEntry !== undefined) {
+								// Nothing is discovered until a cache group that takes the
+								// intersections reaches a chunk set of more than one chunk
+								if (
+									withIntersections &&
+									getIntersectionsByKey !== undefined &&
+									cacheEntry[0] instanceof Set &&
+									!originalCounts.has(cacheEntry)
+								) {
+									appendIntersections(
+										key,
+										cacheEntry,
+										getIntersectionsByKey,
+										originalCounts
+									);
+								}
+								return cacheEntry;
+							}
+							if (typeof key !== "bigint") {
 								const result = [key];
 								combinationsCache.set(key, result);
 								return result;
@@ -1162,72 +1629,90 @@ class SplitChunksPlugin {
 								(chunkSets.get(key));
 							/** @type {Combinations} */
 							const array = [chunksSet];
-							writeSignature(chunksSet, signatureScratch, 0);
-							const selfLow = signatureScratch[0];
-							const selfHigh = signatureScratch[1];
-							for (const [count, group] of chunkSetsByCount) {
-								// "equal" is not needed because they would have been merge in the first step
-								if (count < chunksSet.size) {
-									const { sets, signatures } = group;
-									for (let i = 0; i < sets.length; i++) {
-										// a subset cannot hold a signature bit the superset lacks,
-										// so this rejects nearly every candidate without touching the Set
-										const offset = i * 2;
-										if (
-											(signatures[offset] & ~selfLow) !== 0 ||
-											(signatures[offset + 1] & ~selfHigh) !== 0
-										) {
-											continue;
-										}
-										const set = sets[i];
-										if (isSubset(chunksSet, set)) {
-											array.push(set);
-										}
+							// A subset holds the chunk fewest sets hold of it, so only the sets
+							// indexed under a chunk of this one can be one
+							/** @type {number[]} */
+							const subsets = [];
+							for (const chunk of chunksSet) {
+								const indices = setsByRarestChunk.get(chunk);
+								if (indices === undefined) continue;
+								for (const candidate of indices) {
+									const set = sets[candidate];
+									// "equal" is not needed because they would have been merge in the first step
+									if (set.size < chunksSet.size && isSubset(chunksSet, set)) {
+										subsets.push(candidate);
 									}
 								}
 							}
-							for (const chunk of singleChunkSets) {
-								if (chunksSet.has(chunk)) {
-									array.push(chunk);
-								}
+							// Combined in the order they were indexed in, smaller counts first
+							if (subsets.length > 1) subsets.sort((a, b) => a - b);
+							for (const candidate of subsets) array.push(sets[candidate]);
+							/** @type {Chunk[]} */
+							const singles = [];
+							for (const chunk of chunksSet) {
+								if (singleOrder.has(chunk)) singles.push(chunk);
 							}
+							if (singles.length > 1) {
+								singles.sort(
+									(a, b) =>
+										/** @type {number} */ (singleOrder.get(a)) -
+										/** @type {number} */ (singleOrder.get(b))
+								);
+							}
+							for (const chunk of singles) array.push(chunk);
 							combinationsCache.set(key, array);
+							if (withIntersections && getIntersectionsByKey !== undefined) {
+								appendIntersections(
+									key,
+									array,
+									getIntersectionsByKey,
+									originalCounts
+								);
+							}
 							return array;
 						};
 					};
 
 					const getCombinationsFactory = memoize(() => {
-						const { chunkSetsInGraph, singleChunkSets } = getChunkSetsInGraph();
+						const { chunkSetsInGraph } = getChunkSetsInGraph();
 						return createGetCombinations(
 							chunkSetsInGraph,
-							singleChunkSets,
-							getChunkSetsByCount()
+							getChunkSetIndex(),
+							intersectionSettings === undefined
+								? undefined
+								: getIntersectionsByChunkSetKey,
+							originalCombinationCounts
 						);
 					});
 
 					/**
 					 * Returns combinations by key.
 					 * @param {bigint | Chunk} key key
+					 * @param {boolean} withIntersections whether to take the intersections of the chunk sets too
 					 * @returns {Combinations} combinations by key
 					 */
-					const getCombinations = (key) => getCombinationsFactory()(key);
+					const getCombinations = (key, withIntersections) =>
+						getCombinationsFactory()(key, withIntersections);
 
 					const getExportsCombinationsFactory = memoize(() => {
-						const { chunkSetsInGraph, singleChunkSets } =
-							getExportsChunkSetsInGraph();
+						const { chunkSetsInGraph } = getExportsChunkSetsInGraph();
 						return createGetCombinations(
 							chunkSetsInGraph,
-							singleChunkSets,
-							getExportsChunkSetsByCount()
+							getExportsChunkSetIndex(),
+							exportsIntersectionSettings === undefined
+								? undefined
+								: getExportsIntersectionsByChunkSetKey,
+							originalExportsCombinationCounts
 						);
 					});
 					/**
 					 * Gets exports combinations.
 					 * @param {bigint | Chunk} key key
+					 * @param {boolean} withIntersections whether to take the intersections of the chunk sets too
 					 * @returns {Combinations} exports combinations by key
 					 */
-					const getExportsCombinations = (key) =>
-						getExportsCombinationsFactory()(key);
+					const getExportsCombinations = (key, withIntersections) =>
+						getExportsCombinationsFactory()(key, withIntersections);
 
 					/**
 					 * Defines the selected chunks result type used by this module.
@@ -1260,7 +1745,7 @@ class SplitChunksPlugin {
 						if (entry2 === undefined) {
 							/** @type {Chunk[]} */
 							const selectedChunks = [];
-							if (chunks instanceof Chunk) {
+							if (!(chunks instanceof Set)) {
 								if (chunkFilter(chunks)) selectedChunks.push(chunks);
 							} else {
 								for (const chunk of chunks) {
@@ -1438,32 +1923,77 @@ class SplitChunksPlugin {
 					/**
 					 * Returns combinations of the chunks the module is in.
 					 * @param {Module} module the module
+					 * @param {boolean} withIntersections whether to take the intersections of the chunk sets too
 					 * @returns {Combinations} chunk combinations
 					 */
-					const computeCombinations = (module) =>
-						getCombinations(getKey(chunkGraph.getModuleChunksIterable(module)));
+					const computeCombinations = (module, withIntersections) =>
+						getCombinations(
+							getKey(chunkGraph.getModuleChunksIterable(module)),
+							withIntersections
+						);
 
 					/**
-					 * Returns combinations of the module's chunks grouped by used exports.
+					 * Returns combinations of the module's chunks grouped by used exports. A
+					 * module whose chunks all use the same exports takes the combinations of that
+					 * one group as they are, without a copy to merge into.
 					 * @param {Module} module the module
-					 * @returns {Set<ChunkSet | Chunk>} chunk combinations
+					 * @param {boolean} withIntersections whether to take the intersections of the chunk sets too
+					 * @returns {Combinations} chunk combinations
 					 */
-					const computeCombinationsByUsedExports = (module) => {
+					const computeCombinationsByUsedExports = (
+						module,
+						withIntersections
+					) => {
 						// fill the groupedByExportsMap
 						getExportsChunkSetsInGraph();
-						/** @type {Set<ChunkSet | Chunk>} */
-						const set = new Set();
 						const groupedByUsedExports =
-							/** @type {Iterable<Chunk[]>} */
+							/** @type {Chunk[][]} */
 							(groupedByExportsMap.get(module));
+						if (groupedByUsedExports.length === 1) {
+							return getExportsCombinations(
+								getKey(groupedByUsedExports[0]),
+								withIntersections
+							);
+						}
+						/** @type {Combinations} */
+						const array = [];
+						/** @type {Set<ChunkSet | Chunk>} */
+						const seen = new Set();
 						for (const chunks of groupedByUsedExports) {
-							for (const comb of getExportsCombinations(getKey(chunks))) {
-								set.add(comb);
+							const combinations = getExportsCombinations(
+								getKey(chunks),
+								withIntersections
+							);
+							const end = originalCombinationCount(
+								combinations,
+								withIntersections,
+								originalExportsCombinationCounts
+							);
+							for (let i = 0; i < end; i++) {
+								const combination = combinations[i];
+								const known = seen.size;
+								seen.add(combination);
+								if (seen.size !== known) array.push(combination);
 							}
 						}
-						return set;
+						return array;
 					};
 
+					/**
+					 * Whether a cache group puts the intersections of the chunk sets to use. Only
+					 * one naming its chunk after the modules it takes, and holding out for a size,
+					 * can group modules that no chunk set holds together.
+					 * @param {CacheGroup} cacheGroup the cache group
+					 * @returns {boolean} true when it takes them
+					 */
+					const takesIntersections = (cacheGroup) =>
+						intersectionChunks !== undefined &&
+						(cacheGroup.usedExports
+							? exportsIntersectionSettings
+							: intersectionSettings) !== undefined &&
+						cacheGroup.getName === defaultGetName &&
+						(cacheGroup._validateSize || cacheGroup._validateSizeReduction);
+
 					logger.timeEnd("prepare");
 
 					logger.time("modules");
@@ -1479,31 +2009,59 @@ class SplitChunksPlugin {
 						// Computed at most once per module, on first use by a cache group
 						/** @type {Combinations | undefined} */
 						let combsCache;
-						/** @type {Set<ChunkSet | Chunk> | undefined} */
+						let combsCacheHasIntersections = false;
+						/** @type {(Combinations | undefined)[] | undefined} */
 						let combsByUsedExportsCache;
 
 						let cacheGroupIndex = 0;
 						for (const cacheGroupSource of cacheGroups) {
 							const cacheGroup = this._getCacheGroup(cacheGroupSource);
-
+							const withIntersections = takesIntersections(cacheGroup);
+							/** @type {Combinations} */
 							let combs;
+							let end;
 							if (cacheGroup.usedExports) {
 								if (combsByUsedExportsCache === undefined) {
-									combsByUsedExportsCache =
-										computeCombinationsByUsedExports(module);
+									combsByUsedExportsCache = [];
 								}
-								combs = combsByUsedExportsCache;
+								const index = withIntersections ? 1 : 0;
+								let cached = combsByUsedExportsCache[index];
+								if (cached === undefined) {
+									cached = computeCombinationsByUsedExports(
+										module,
+										withIntersections
+									);
+									combsByUsedExportsCache[index] = cached;
+								}
+								combs = cached;
+								// The intersections trail the chunk sets, so a cache group that takes
+								// none of them stops where they begin
+								end = originalCombinationCount(
+									combs,
+									withIntersections,
+									originalExportsCombinationCounts
+								);
 							} else {
-								if (combsCache === undefined) {
-									combsCache = computeCombinations(module);
+								if (
+									combsCache === undefined ||
+									(withIntersections && !combsCacheHasIntersections)
+								) {
+									combsCache = computeCombinations(module, withIntersections);
+									combsCacheHasIntersections = withIntersections;
 								}
 								combs = combsCache;
+								end = originalCombinationCount(
+									combs,
+									withIntersections,
+									originalCombinationCounts
+								);
 							}
 							// For all combination of chunk selection
-							for (const chunkCombination of combs) {
+							for (let i = 0; i < end; i++) {
+								const chunkCombination = combs[i];
 								// Break if minimum number of chunks is not reached
 								const count =
-									chunkCombination instanceof Chunk ? 1 : chunkCombination.size;
+									chunkCombination instanceof Set ? chunkCombination.size : 1;
 								if (count < cacheGroup.minChunks) continue;
 								// Select chunks by configuration
 								const { chunks: selectedChunks, key: selectedChunksKey } =