@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/optimize/SplitChunksPlugin.js

@@ -7,7 +7,7 @@
 
 const Chunk = require("../Chunk");
 const { STAGE_ADVANCED } = require("../OptimizationStages");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const { requestToId } = require("../ids/IdHelpers");
 const { isSubset } = require("../util/SetHelpers");
 const SortableSet = require("../util/SortableSet");
@@ -32,12 +32,13 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
+/** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
 /** @typedef {import("../util/deterministicGrouping").Sizes} Sizes */
 
 /**
+ * Defines the chunk filter fn callback.
  * @callback ChunkFilterFn
  * @param {Chunk} chunk
  * @returns {boolean | undefined}
@@ -49,6 +50,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {number} CountOfRequest */
 
 /**
+ * Defines the combine size function callback.
  * @callback CombineSizeFunction
  * @param {Size} a
  * @param {Size} b
@@ -60,6 +62,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {Record<SourceType, Size>} SplitChunksSizes */
 
 /**
+ * Defines the cache group source type used by this module.
  * @typedef {object} CacheGroupSource
  * @property {string} key
  * @property {Priority=} priority
@@ -75,7 +78,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {CountOfChunk=} minChunks
  * @property {CountOfRequest=} maxAsyncRequests
  * @property {CountOfRequest=} maxInitialRequests
- * @property {TemplatePath=} filename
+ * @property {ChunkFilenameTemplate=} filename
  * @property {string=} idHint
  * @property {string=} automaticNameDelimiter
  * @property {boolean=} reuseExistingChunk
@@ -83,6 +86,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  */
 
 /**
+ * Defines the cache group type used by this module.
  * @typedef {object} CacheGroup
  * @property {string} key
  * @property {Priority} priority
@@ -97,7 +101,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {CountOfChunk} minChunks
  * @property {CountOfRequest} maxAsyncRequests
  * @property {CountOfRequest} maxInitialRequests
- * @property {TemplatePath=} filename
+ * @property {ChunkFilenameTemplate=} filename
  * @property {string} idHint
  * @property {string} automaticNameDelimiter
  * @property {boolean} reuseExistingChunk
@@ -109,6 +113,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  */
 
 /**
+ * Defines the fallback cache group type used by this module.
  * @typedef {object} FallbackCacheGroup
  * @property {ChunkFilterFn} chunksFilter
  * @property {SplitChunksSizes} minSize
@@ -118,6 +123,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  */
 
 /**
+ * Defines the cache groups context type used by this module.
  * @typedef {object} CacheGroupsContext
  * @property {ModuleGraph} moduleGraph
  * @property {ChunkGraph} chunkGraph
@@ -126,6 +132,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {(module: Module) => OptimizationSplitChunksCacheGroup | OptimizationSplitChunksCacheGroup[] | void} RawGetCacheGroups */
 
 /**
+ * Defines the get cache groups callback.
  * @callback GetCacheGroups
  * @param {Module} module
  * @param {CacheGroupsContext} context
@@ -133,6 +140,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  */
 
 /**
+ * Defines the get name fn callback.
  * @callback GetNameFn
  * @param {Module} module
  * @param {Chunk[]} chunks
@@ -141,6 +149,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  */
 
 /**
+ * Defines the split chunks options type used by this module.
  * @typedef {object} SplitChunksOptions
  * @property {ChunkFilterFn} chunksFilter
  * @property {DefaultSizeTypes} defaultSizeTypes
@@ -154,7 +163,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {CountOfRequest} maxAsyncRequests
  * @property {CountOfRequest} maxInitialRequests
  * @property {boolean} hidePathInfo
- * @property {TemplatePath=} filename
+ * @property {ChunkFilenameTemplate=} filename
  * @property {string} automaticNameDelimiter
  * @property {GetCacheGroups} getCacheGroups
  * @property {GetNameFn} getName
@@ -165,6 +174,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {Set<Chunk>} ChunkSet  */
 
 /**
+ * Defines the chunks info item type used by this module.
  * @typedef {object} ChunksInfoItem
  * @property {SortableSet<Module>} modules
  * @property {CacheGroup} cacheGroup
@@ -172,7 +182,6 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {string=} name
  * @property {SplitChunksSizes} sizes
  * @property {ChunkSet} chunks
- * @property {ChunkSet} reusableChunks
  * @property {Set<bigint | Chunk>} chunksKeys
  */
 
@@ -187,6 +196,7 @@ const deterministicGroupingForModules =
 const getKeyCache = new WeakMap();
 
 /**
+ * Returns hashed filename.
  * @param {string} name a filename to hash
  * @param {OutputOptions} outputOptions hash function used
  * @returns {string} hashed filename
@@ -203,6 +213,7 @@ const hashFilename = (name, outputOptions) => {
 };
 
 /**
+ * Returns the number of requests.
  * @param {Chunk} chunk the chunk
  * @returns {CountOfRequest} the number of requests
  */
@@ -215,8 +226,8 @@ const getRequests = (chunk) => {
 };
 
 /**
+ * Returns result.
  * @template {object} T
- * @template {object} R
  * @param {T} obj obj an object
  * @param {(obj: T[keyof T], key: keyof T) => T[keyof T]} fn fn
  * @returns {T} result
@@ -235,6 +246,7 @@ const mapObject = (obj, fn) => {
 };
 
 /**
+ * Checks whether this object is overlap.
  * @template T
  * @param {Set<T>} a set
  * @param {Set<T>} b other set
@@ -250,6 +262,7 @@ const isOverlap = (a, b) => {
 const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 
 /**
+ * Compares the provided values and returns their ordering.
  * @param {ChunksInfoItem} a item
  * @param {ChunksInfoItem} b item
  * @returns {number} compare result
@@ -281,22 +294,29 @@ const compareEntries = (a, b) => {
 };
 
 /**
+ * Initial chunk filter.
  * @param {Chunk} chunk the chunk
  * @returns {boolean} true, if the chunk is an entry chunk
  */
 const INITIAL_CHUNK_FILTER = (chunk) => chunk.canBeInitial();
 /**
+ * Async chunk filter.
  * @param {Chunk} chunk the chunk
  * @returns {boolean} true, if the chunk is an async chunk
  */
 const ASYNC_CHUNK_FILTER = (chunk) => !chunk.canBeInitial();
 /**
+ * Returns always true.
  * @param {Chunk} _chunk the chunk
  * @returns {boolean} always true
  */
 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);
+
 /**
+ * Returns normalized representation.
  * @param {OptimizationSplitChunksSizes | undefined} value the sizes
  * @param {DefaultSizeTypes} defaultSizeTypes the default size types
  * @returns {SplitChunksSizes} normalized representation
@@ -314,6 +334,7 @@ const normalizeSizes = (value, defaultSizeTypes) => {
 };
 
 /**
+ * Merges the provided values into a single result.
  * @param {...(SplitChunksSizes | undefined)} sizes the sizes
  * @returns {SplitChunksSizes} the merged sizes
  */
@@ -327,6 +348,7 @@ const mergeSizes = (...sizes) => {
 };
 
 /**
+ * Checks whether this object contains the size.
  * @param {SplitChunksSizes} sizes the sizes
  * @returns {boolean} true, if there are sizes > 0
  */
@@ -338,6 +360,7 @@ const hasNonZeroSizes = (sizes) => {
 };
 
 /**
+ * Returns the combine sizes.
  * @param {SplitChunksSizes} a first sizes
  * @param {SplitChunksSizes} b second sizes
  * @param {CombineSizeFunction} combine a function to combine sizes
@@ -360,6 +383,7 @@ const combineSizes = (a, b, combine) => {
 };
 
 /**
+ * Checks true if there are sizes and all existing sizes are at least minSize.
  * @param {SplitChunksSizes} sizes the sizes
  * @param {SplitChunksSizes} minSize the min sizes
  * @returns {boolean} true if there are sizes and all existing sizes are at least `minSize`
@@ -374,6 +398,7 @@ const checkMinSize = (sizes, minSize) => {
 };
 
 /**
+ * Checks min size reduction.
  * @param {SplitChunksSizes} sizes the sizes
  * @param {SplitChunksSizes} minSizeReduction the min sizes
  * @param {CountOfChunk} chunkCount number of chunks
@@ -391,6 +416,7 @@ const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
 };
 
 /**
+ * Gets violating min sizes.
  * @param {SplitChunksSizes} sizes the sizes
  * @param {SplitChunksSizes} minSize the min sizes
  * @returns {undefined | SourceTypes} list of size types that are below min size
@@ -410,6 +436,7 @@ const getViolatingMinSizes = (sizes, minSize) => {
 };
 
 /**
+ * Returns the total size.
  * @param {SplitChunksSizes} sizes the sizes
  * @returns {Size} the total size
  */
@@ -422,6 +449,7 @@ const totalSize = (sizes) => {
 };
 
 /**
+ * Returns a function to get the name of the chunk.
  * @param {OptimizationSplitChunksCacheGroup["name"]} name the chunk name
  * @returns {GetNameFn | undefined} a function to get the name of the chunk
  */
@@ -435,6 +463,7 @@ const normalizeName = (name) => {
 };
 
 /**
+ * Normalizes chunks filter.
  * @param {OptimizationSplitChunksCacheGroup["chunks"]} chunks the chunk filter option
  * @returns {ChunkFilterFn | undefined} the chunk filter function
  */
@@ -457,6 +486,7 @@ const normalizeChunksFilter = (chunks) => {
 };
 
 /**
+ * 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
@@ -517,6 +547,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 			}
 		}
 		/**
+		 * Returns the matching cache groups.
 		 * @param {Module} module the current module
 		 * @param {CacheGroupsContext} context the current context
 		 * @returns {CacheGroupSource[]} the matching cache groups
@@ -537,6 +568,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 /** @typedef {(module: Module, context: CacheGroupsContext) => boolean} CheckTestFn */
 
 /**
+ * Checks true, if the module should be selected.
  * @param {OptimizationSplitChunksCacheGroup["test"]} test test option
  * @param {Module} module the module
  * @param {CacheGroupsContext} context context object
@@ -562,6 +594,7 @@ const checkTest = (test, module, context) => {
 /** @typedef {(type: string) => boolean} CheckModuleTypeFn */
 
 /**
+ * Checks module type.
  * @param {OptimizationSplitChunksCacheGroup["type"]} test type option
  * @param {Module} module the module
  * @returns {boolean} true, if the module should be selected
@@ -585,6 +618,7 @@ const checkModuleType = (test, module) => {
 /** @typedef {(layer: string | null) => boolean} CheckModuleLayerFn */
 
 /**
+ * Checks module layer.
  * @param {OptimizationSplitChunksCacheGroup["layer"]} test type option
  * @param {Module} module the module
  * @returns {boolean} true, if the module should be selected
@@ -606,6 +640,7 @@ const checkModuleLayer = (test, module) => {
 };
 
 /**
+ * Creates a cache group source.
  * @param {OptimizationSplitChunksCacheGroup} options the group options
  * @param {string} key key of cache group
  * @param {DefaultSizeTypes} defaultSizeTypes the default size types
@@ -657,6 +692,7 @@ const PLUGIN_NAME = "SplitChunksPlugin";
 
 module.exports = class SplitChunksPlugin {
 	/**
+	 * Creates an instance of SplitChunksPlugin.
 	 * @param {OptimizationSplitChunksOptions=} options plugin options
 	 */
 	constructor(options = {}) {
@@ -746,6 +782,7 @@ module.exports = class SplitChunksPlugin {
 	}
 
 	/**
+	 * Returns the cache group (cached).
 	 * @param {CacheGroupSource} cacheGroupSource source
 	 * @returns {CacheGroup} the cache group (cached)
 	 */
@@ -837,7 +874,7 @@ module.exports = class SplitChunksPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -866,18 +903,25 @@ module.exports = class SplitChunksPlugin {
 					// 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);
 						index <<= ONE;
 					}
 					/**
+					 * Returns key of the chunks.
 					 * @param {Iterable<Chunk, undefined, undefined>} chunks list of chunks
 					 * @returns {bigint | Chunk} key of the chunks
 					 */
@@ -898,6 +942,7 @@ module.exports = class SplitChunksPlugin {
 						return key;
 					};
 					/**
+					 * Returns stringified key.
 					 * @param {bigint | Chunk} key key of the chunks
 					 * @returns {string} stringified key
 					 */
@@ -926,6 +971,7 @@ module.exports = class SplitChunksPlugin {
 					});
 
 					/**
+					 * Group chunks by exports.
 					 * @param {Module} module the module
 					 * @returns {Iterable<Chunk[]>} groups of chunks with equal exports
 					 */
@@ -972,12 +1018,42 @@ module.exports = class SplitChunksPlugin {
 						return { chunkSetsInGraph, singleChunkSets };
 					});
 
-					/** @typedef {Map<CountOfChunk, ChunkSet[]>} ChunkSetsByCount */
+					/**
+					 * 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
+					 */
+
+					/** @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}
+					 */
+					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);
+						}
+					};
 
 					// 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
 					 */
@@ -986,12 +1062,20 @@ module.exports = class SplitChunksPlugin {
 						const chunkSetsByCount = new Map();
 						for (const chunksSet of chunkSets) {
 							const count = chunksSet.size;
-							let array = chunkSetsByCount.get(count);
-							if (array === undefined) {
-								array = [];
-								chunkSetsByCount.set(count, array);
+							let group = chunkSetsByCount.get(count);
+							if (group === undefined) {
+								group = { sets: [], signatures: EMPTY_SIGNATURES };
+								chunkSetsByCount.set(count, group);
 							}
-							array.push(chunksSet);
+							group.sets.push(chunksSet);
+						}
+						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);
+							}
+							group.signatures = signatures;
 						}
 						return chunkSetsByCount;
 					};
@@ -1010,6 +1094,7 @@ module.exports = class SplitChunksPlugin {
 
 					// 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
@@ -1036,10 +1121,24 @@ module.exports = class SplitChunksPlugin {
 								(chunkSets.get(key));
 							/** @type {Combinations} */
 							const array = [chunksSet];
-							for (const [count, setArray] of chunkSetsByCount) {
+							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) {
-									for (const set of setArray) {
+									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);
 										}
@@ -1066,6 +1165,7 @@ module.exports = class SplitChunksPlugin {
 					});
 
 					/**
+					 * Returns combinations by key.
 					 * @param {bigint | Chunk} key key
 					 * @returns {Combinations} combinations by key
 					 */
@@ -1081,6 +1181,7 @@ module.exports = class SplitChunksPlugin {
 						);
 					});
 					/**
+					 * Gets exports combinations.
 					 * @param {bigint | Chunk} key key
 					 * @returns {Combinations} exports combinations by key
 					 */
@@ -1088,6 +1189,7 @@ module.exports = class SplitChunksPlugin {
 						getExportsCombinationsFactory()(key);
 
 					/**
+					 * Defines the selected chunks result type used by this module.
 					 * @typedef {object} SelectedChunksResult
 					 * @property {Chunk[]} chunks the list of chunks
 					 * @property {bigint | Chunk} key a key of the list
@@ -1143,7 +1245,33 @@ module.exports = class SplitChunksPlugin {
 					/** @type {Map<string, ChunksInfoItem>} */
 					const chunksInfoMap = new Map();
 
+					// The unnamed key is derived only from cache group and chunk set, so it
+					// repeats for every module sharing that pair — build the string once
+					/** @type {Map<CacheGroup, Map<bigint | Chunk, string>>} */
+					const unnamedKeyCache = new Map();
+
+					/**
+					 * Returns the chunksInfoMap key for a cache group and chunk set.
+					 * @param {CacheGroup} cacheGroup the current cache group
+					 * @param {bigint | Chunk} selectedChunksKey a key of selectedChunks
+					 * @returns {string} key into chunksInfoMap
+					 */
+					const getUnnamedKey = (cacheGroup, selectedChunksKey) => {
+						let byChunksKey = unnamedKeyCache.get(cacheGroup);
+						if (byChunksKey === undefined) {
+							byChunksKey = new Map();
+							unnamedKeyCache.set(cacheGroup, byChunksKey);
+						}
+						let key = byChunksKey.get(selectedChunksKey);
+						if (key === undefined) {
+							key = `${cacheGroup.key} chunks:${keyToString(selectedChunksKey)}`;
+							byChunksKey.set(selectedChunksKey, key);
+						}
+						return key;
+					};
+
 					/**
+					 * Adds module to chunks info map.
 					 * @param {CacheGroup} cacheGroup the current cache group
 					 * @param {number} cacheGroupIndex the index of the cache group of ordering
 					 * @param {Chunk[]} selectedChunks chunks selected for this module
@@ -1225,11 +1353,9 @@ module.exports = class SplitChunksPlugin {
 						// When it has a name we use the name as key
 						// Otherwise we create the key from chunks and cache group key
 						// This automatically merges equal names
-						const key =
-							cacheGroup.key +
-							(name
-								? ` name:${name}`
-								: ` chunks:${keyToString(selectedChunksKey)}`);
+						const key = name
+							? `${cacheGroup.key} name:${name}`
+							: getUnnamedKey(cacheGroup, selectedChunksKey);
 						// Add module to maps
 						let info = chunksInfoMap.get(key);
 						if (info === undefined) {
@@ -1245,7 +1371,6 @@ module.exports = class SplitChunksPlugin {
 									name,
 									sizes: {},
 									chunks: new Set(),
-									reusableChunks: new Set(),
 									chunksKeys: new Set()
 								})
 							);
@@ -1271,6 +1396,35 @@ module.exports = class SplitChunksPlugin {
 						chunkGraph
 					};
 
+					/**
+					 * Returns combinations of the chunks the module is in.
+					 * @param {Module} module the module
+					 * @returns {Combinations} chunk combinations
+					 */
+					const computeCombinations = (module) =>
+						getCombinations(getKey(chunkGraph.getModuleChunksIterable(module)));
+
+					/**
+					 * Returns combinations of the module's chunks grouped by used exports.
+					 * @param {Module} module the module
+					 * @returns {Set<ChunkSet | Chunk>} chunk combinations
+					 */
+					const computeCombinationsByUsedExports = (module) => {
+						// fill the groupedByExportsMap
+						getExportsChunkSetsInGraph();
+						/** @type {Set<ChunkSet | Chunk>} */
+						const set = new Set();
+						const groupedByUsedExports =
+							/** @type {Iterable<Chunk[]>} */
+							(groupedByExportsMap.get(module));
+						for (const chunks of groupedByUsedExports) {
+							for (const comb of getExportsCombinations(getKey(chunks))) {
+								set.add(comb);
+							}
+						}
+						return set;
+					};
+
 					logger.timeEnd("prepare");
 
 					logger.time("modules");
@@ -1283,38 +1437,29 @@ module.exports = class SplitChunksPlugin {
 							continue;
 						}
 
-						// Prepare some values (usedExports = false)
-						const getCombs = memoize(() => {
-							const chunks = chunkGraph.getModuleChunksIterable(module);
-							const chunksKey = getKey(chunks);
-							return getCombinations(chunksKey);
-						});
-
-						// Prepare some values (usedExports = true)
-						const getCombsByUsedExports = memoize(() => {
-							// fill the groupedByExportsMap
-							getExportsChunkSetsInGraph();
-							/** @type {Set<ChunkSet | Chunk>} */
-							const set = new Set();
-							const groupedByUsedExports =
-								/** @type {Iterable<Chunk[]>} */
-								(groupedByExportsMap.get(module));
-							for (const chunks of groupedByUsedExports) {
-								const chunksKey = getKey(chunks);
-								for (const comb of getExportsCombinations(chunksKey)) {
-									set.add(comb);
-								}
-							}
-							return set;
-						});
+						// Computed at most once per module, on first use by a cache group
+						/** @type {Combinations | undefined} */
+						let combsCache;
+						/** @type {Set<ChunkSet | Chunk> | undefined} */
+						let combsByUsedExportsCache;
 
 						let cacheGroupIndex = 0;
 						for (const cacheGroupSource of cacheGroups) {
 							const cacheGroup = this._getCacheGroup(cacheGroupSource);
 
-							const combs = cacheGroup.usedExports
-								? getCombsByUsedExports()
-								: getCombs();
+							let combs;
+							if (cacheGroup.usedExports) {
+								if (combsByUsedExportsCache === undefined) {
+									combsByUsedExportsCache =
+										computeCombinationsByUsedExports(module);
+								}
+								combs = combsByUsedExportsCache;
+							} else {
+								if (combsCache === undefined) {
+									combsCache = computeCombinations(module);
+								}
+								combs = combsCache;
+							}
 							// For all combination of chunk selection
 							for (const chunkCombination of combs) {
 								// Break if minimum number of chunks is not reached
@@ -1346,6 +1491,7 @@ module.exports = class SplitChunksPlugin {
 					logger.time("queue");
 
 					/**
+					 * Removes modules with source type.
 					 * @param {ChunksInfoItem} info entry
 					 * @param {SourceTypes} sourceTypes source types to be removed
 					 */
@@ -1362,6 +1508,7 @@ module.exports = class SplitChunksPlugin {
 					};
 
 					/**
+					 * Removes min size violating modules.
 					 * @param {ChunksInfoItem} info entry
 					 * @returns {boolean} true, if entry become empty
 					 */
@@ -1392,6 +1539,7 @@ module.exports = class SplitChunksPlugin {
 					}
 
 					/**
+					 * Defines the max size queue item type used by this module.
 					 * @typedef {object} MaxSizeQueueItem
 					 * @property {SplitChunksSizes} minSize
 					 * @property {SplitChunksSizes} maxAsyncSize
@@ -1529,12 +1677,14 @@ module.exports = class SplitChunksPlugin {
 							}
 							if (usedChunks.size >= item.cacheGroup.minChunks) {
 								const chunksArr = [...usedChunks];
+								// invariant across the module loop below
+								const usedChunksKey = getKey(usedChunks);
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
 										item.cacheGroup,
 										item.cacheGroupIndex,
 										chunksArr,
-										getKey(usedChunks),
+										usedChunksKey,
 										module
 									);
 								}