webpack 5.58.0 → 5.59.1

package/lib/optimize/SplitChunksPlugin.js

@@ -5,10 +5,11 @@
 
 "use strict";
 
-const ChunkCombination = require("../ChunkCombination");
+const Chunk = require("../Chunk");
 const { STAGE_ADVANCED } = require("../OptimizationStages");
 const WebpackError = require("../WebpackError");
 const { requestToId } = require("../ids/IdHelpers");
+const { isSubset } = require("../util/SetHelpers");
 const SortableSet = require("../util/SortableSet");
 const {
 	compareModulesByIdentifier,
@@ -25,7 +26,6 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksSizes} OptimizationSplitChunksSizes */
 /** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
-/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
@@ -59,6 +59,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {ChunkFilterFunction=} chunksFilter
  * @property {boolean=} enforce
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxAsyncSize
@@ -80,6 +81,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {GetName=} getName
  * @property {ChunkFilterFunction=} chunksFilter
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxAsyncSize
@@ -132,6 +134,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {ChunkFilterFunction} chunksFilter
  * @property {string[]} defaultSizeTypes
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxInitialSize
@@ -155,9 +158,9 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number} cacheGroupIndex
  * @property {string} name
  * @property {Record<string, number>} sizes
- * @property {ChunkCombination} chunks
+ * @property {Set<Chunk>} chunks
  * @property {Set<Chunk>} reuseableChunks
- * @property {Set<ChunkCombination>} chunkCombinations
+ * @property {Set<bigint | Chunk>} chunksKeys
  */
 
 const defaultGetName = /** @type {GetName} */ (() => {});
@@ -204,6 +207,19 @@ const mapObject = (obj, fn) => {
 	return newObj;
 };
 
+/**
+ * @template T
+ * @param {Set<T>} a set
+ * @param {Set<T>} b other set
+ * @returns {boolean} true if at least one item of a is in b
+ */
+const isOverlap = (a, b) => {
+	for (const item of a) {
+		if (b.has(item)) return true;
+	}
+	return false;
+};
+
 const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 
 /**
@@ -323,6 +339,21 @@ const checkMinSize = (sizes, minSize) => {
 	return true;
 };
 
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @param {SplitChunksSizes} minSizeReduction the min sizes
+ * @param {number} chunkCount number of chunks
+ * @returns {boolean} true if there are sizes and all existing sizes are at least `minSizeReduction`
+ */
+const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
+	for (const key of Object.keys(minSizeReduction)) {
+		const size = sizes[key];
+		if (size === undefined || size === 0) continue;
+		if (size * chunkCount < minSizeReduction[key]) return false;
+	}
+	return true;
+};
+
 /**
  * @param {SplitChunksSizes} sizes the sizes
  * @param {SplitChunksSizes} minSize the min sizes
@@ -535,6 +566,10 @@ const checkModuleLayer = (test, module) => {
  */
 const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 	const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+	const minSizeReduction = normalizeSizes(
+		options.minSizeReduction,
+		defaultSizeTypes
+	);
 	const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
 	return {
 		key,
@@ -543,6 +578,7 @@ const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 		chunksFilter: normalizeChunksFilter(options.chunks),
 		enforce: options.enforce,
 		minSize,
+		minSizeReduction,
 		minRemainingSize: mergeSizes(
 			normalizeSizes(options.minRemainingSize, defaultSizeTypes),
 			minSize
@@ -581,6 +617,10 @@ module.exports = class SplitChunksPlugin {
 		];
 		const fallbackCacheGroup = options.fallbackCacheGroup || {};
 		const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+		const minSizeReduction = normalizeSizes(
+			options.minSizeReduction,
+			defaultSizeTypes
+		);
 		const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
 
 		/** @type {SplitChunksOptions} */
@@ -588,6 +628,7 @@ module.exports = class SplitChunksPlugin {
 			chunksFilter: normalizeChunksFilter(options.chunks || "all"),
 			defaultSizeTypes,
 			minSize,
+			minSizeReduction,
 			minRemainingSize: mergeSizes(
 				normalizeSizes(options.minRemainingSize, defaultSizeTypes),
 				minSize
@@ -655,6 +696,10 @@ module.exports = class SplitChunksPlugin {
 			cacheGroupSource.minSize,
 			cacheGroupSource.enforce ? undefined : this.options.minSize
 		);
+		const minSizeReduction = mergeSizes(
+			cacheGroupSource.minSizeReduction,
+			cacheGroupSource.enforce ? undefined : this.options.minSizeReduction
+		);
 		const minRemainingSize = mergeSizes(
 			cacheGroupSource.minRemainingSize,
 			cacheGroupSource.enforce ? undefined : this.options.minRemainingSize
@@ -668,6 +713,7 @@ module.exports = class SplitChunksPlugin {
 			priority: cacheGroupSource.priority || 0,
 			chunksFilter: cacheGroupSource.chunksFilter || this.options.chunksFilter,
 			minSize,
+			minSizeReduction,
 			minRemainingSize,
 			enforceSizeThreshold,
 			maxAsyncSize: mergeSizes(
@@ -756,132 +802,212 @@ module.exports = class SplitChunksPlugin {
 					logger.time("prepare");
 					const chunkGraph = compilation.chunkGraph;
 					const moduleGraph = compilation.moduleGraph;
+					// Give each selected chunk an index (to create strings from chunks)
+					/** @type {Map<Chunk, bigint>} */
+					const chunkIndexMap = new Map();
+					const ZERO = BigInt("0");
+					const ONE = BigInt("1");
+					const START = ONE << BigInt("31");
+					let index = START;
+					for (const chunk of chunks) {
+						chunkIndexMap.set(
+							chunk,
+							index | BigInt((Math.random() * 0x7fffffff) | 0)
+						);
+						index = index << ONE;
+					}
+					/**
+					 * @param {Iterable<Chunk>} chunks list of chunks
+					 * @returns {bigint | Chunk} key of the chunks
+					 */
+					const getKey = chunks => {
+						const iterator = chunks[Symbol.iterator]();
+						let result = iterator.next();
+						if (result.done) return ZERO;
+						const first = result.value;
+						result = iterator.next();
+						if (result.done) return first;
+						let key =
+							chunkIndexMap.get(first) | chunkIndexMap.get(result.value);
+						while (!(result = iterator.next()).done) {
+							const raw = chunkIndexMap.get(result.value);
+							key = key ^ raw;
+						}
+						return key;
+					};
+					const keyToString = key => {
+						if (typeof key === "bigint") return key.toString(16);
+						return chunkIndexMap.get(key).toString(16);
+					};
 
-					const getChunkCombinationsInGraph = memoize(() => {
-						/** @type {Set<ChunkCombination>} */
-						const chunkCombinationsInGraph = new Set();
+					const getChunkSetsInGraph = memoize(() => {
+						/** @type {Map<bigint, Set<Chunk>>} */
+						const chunkSetsInGraph = new Map();
+						/** @type {Set<Chunk>} */
+						const singleChunkSets = new Set();
 						for (const module of compilation.modules) {
-							const chunkCombination =
-								chunkGraph.getModuleChunkCombination(module);
-							chunkCombinationsInGraph.add(chunkCombination);
+							const chunks = chunkGraph.getModuleChunksIterable(module);
+							const chunksKey = getKey(chunks);
+							if (typeof chunksKey === "bigint") {
+								if (!chunkSetsInGraph.has(chunksKey)) {
+									chunkSetsInGraph.set(chunksKey, new Set(chunks));
+								}
+							} else {
+								singleChunkSets.add(chunksKey);
+							}
 						}
-						return chunkCombinationsInGraph;
+						return { chunkSetsInGraph, singleChunkSets };
 					});
 
 					/**
 					 * @param {Module} module the module
-					 * @returns {Iterable<ChunkCombination>} groups of chunks with equal exports
+					 * @returns {Iterable<Chunk[]>} groups of chunks with equal exports
 					 */
 					const groupChunksByExports = module => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
 						const groupedByUsedExports = new Map();
 						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
 							const key = exportsInfo.getUsageKey(chunk.runtime);
-							const combination =
-								groupedByUsedExports.get(key) || ChunkCombination.empty;
-							groupedByUsedExports.set(key, combination.with(chunk));
+							const list = groupedByUsedExports.get(key);
+							if (list !== undefined) {
+								list.push(chunk);
+							} else {
+								groupedByUsedExports.set(key, [chunk]);
+							}
 						}
 						return groupedByUsedExports.values();
 					};
 
-					/** @type {Map<Module, Iterable<ChunkCombination>>} */
+					/** @type {Map<Module, Iterable<Chunk[]>>} */
 					const groupedByExportsMap = new Map();
 
-					const getExportsChunkCombinationsInGraph = memoize(() => {
-						/** @type {Set<ChunkCombination>} */
-						const chunkCombinationsInGraph = new Set();
+					const getExportsChunkSetsInGraph = memoize(() => {
+						/** @type {Map<bigint, Set<Chunk>>} */
+						const chunkSetsInGraph = new Map();
+						/** @type {Set<Chunk>} */
+						const singleChunkSets = new Set();
 						for (const module of compilation.modules) {
 							const groupedChunks = Array.from(groupChunksByExports(module));
 							groupedByExportsMap.set(module, groupedChunks);
-							for (const chunkCombination of groupedChunks) {
-								chunkCombinationsInGraph.add(chunkCombination);
+							for (const chunks of groupedChunks) {
+								if (chunks.length === 1) {
+									singleChunkSets.add(chunks[0]);
+								} else {
+									const chunksKey = /** @type {bigint} */ (getKey(chunks));
+									if (!chunkSetsInGraph.has(chunksKey)) {
+										chunkSetsInGraph.set(chunksKey, new Set(chunks));
+									}
+								}
 							}
 						}
-						return chunkCombinationsInGraph;
+						return { chunkSetsInGraph, singleChunkSets };
 					});
 
 					// group these set of chunks by count
 					// to allow to check less sets via isSubset
 					// (only smaller sets can be subset)
-					const groupChunkCombinationsByCount = chunkCombinations => {
-						/** @type {Map<number, ChunkCombination[]>} */
-						const chunkCombinationsByCount = new Map();
-						for (const chunksSet of chunkCombinations) {
+					const groupChunkSetsByCount = chunkSets => {
+						/** @type {Map<number, Array<Set<Chunk>>>} */
+						const chunkSetsByCount = new Map();
+						for (const chunksSet of chunkSets) {
 							const count = chunksSet.size;
-							let array = chunkCombinationsByCount.get(count);
+							let array = chunkSetsByCount.get(count);
 							if (array === undefined) {
 								array = [];
-								chunkCombinationsByCount.set(count, array);
+								chunkSetsByCount.set(count, array);
 							}
 							array.push(chunksSet);
 						}
-						return chunkCombinationsByCount;
+						return chunkSetsByCount;
 					};
-					const getChunkCombinationsByCount = memoize(() =>
-						groupChunkCombinationsByCount(getChunkCombinationsInGraph())
+					const getChunkSetsByCount = memoize(() =>
+						groupChunkSetsByCount(
+							getChunkSetsInGraph().chunkSetsInGraph.values()
+						)
 					);
-					const getExportsChunkCombinationsByCount = memoize(() =>
-						groupChunkCombinationsByCount(getExportsChunkCombinationsInGraph())
+					const getExportsChunkSetsByCount = memoize(() =>
+						groupChunkSetsByCount(
+							getExportsChunkSetsInGraph().chunkSetsInGraph.values()
+						)
 					);
 
-					/**
-					 * Create a list of possible combinations
-					 * @param {Map<number, ChunkCombination[]>} chunkCombinationsByCount by count
-					 * @returns {function(ChunkCombination): ChunkCombination[]} get combinations function
-					 */
-					const createGetCombinations = chunkCombinationsByCount => {
-						/** @type {Map<ChunkCombination, ChunkCombination[]>} */
+					// Create a list of possible combinations
+					const createGetCombinations = (
+						chunkSets,
+						singleChunkSets,
+						chunkSetsByCount
+					) => {
+						/** @type {Map<bigint | Chunk, (Set<Chunk> | Chunk)[]>} */
 						const combinationsCache = new Map();
 
-						/**
-						 * @param {ChunkCombination} chunkCombination chunkCombination
-						 * @returns {ChunkCombination[]} combinations
-						 */
-						return chunkCombination => {
-							const cacheEntry = combinationsCache.get(chunkCombination);
+						return key => {
+							const cacheEntry = combinationsCache.get(key);
 							if (cacheEntry !== undefined) return cacheEntry;
-							if (chunkCombination.size === 1) {
-								const result = [chunkCombination];
-								combinationsCache.set(chunkCombination, result);
+							if (key instanceof Chunk) {
+								const result = [key];
+								combinationsCache.set(key, result);
 								return result;
 							}
-							/** @type {ChunkCombination[]} */
-							const array = [chunkCombination];
-							for (const [count, setArray] of chunkCombinationsByCount) {
+							const chunksSet = chunkSets.get(key);
+							/** @type {(Set<Chunk> | Chunk)[]} */
+							const array = [chunksSet];
+							for (const [count, setArray] of chunkSetsByCount) {
 								// "equal" is not needed because they would have been merge in the first step
-								if (count < chunkCombination.size) {
+								if (count < chunksSet.size) {
 									for (const set of setArray) {
-										if (chunkCombination.isSubset(set)) {
+										if (isSubset(chunksSet, set)) {
 											array.push(set);
 										}
 									}
 								}
 							}
-							combinationsCache.set(chunkCombination, array);
+							for (const chunk of singleChunkSets) {
+								if (chunksSet.has(chunk)) {
+									array.push(chunk);
+								}
+							}
+							combinationsCache.set(key, array);
 							return array;
 						};
 					};
 
 					const getCombinationsFactory = memoize(() => {
-						return createGetCombinations(getChunkCombinationsByCount());
+						const { chunkSetsInGraph, singleChunkSets } = getChunkSetsInGraph();
+						return createGetCombinations(
+							chunkSetsInGraph,
+							singleChunkSets,
+							getChunkSetsByCount()
+						);
 					});
 					const getCombinations = key => getCombinationsFactory()(key);
 
 					const getExportsCombinationsFactory = memoize(() => {
-						return createGetCombinations(getExportsChunkCombinationsByCount());
+						const { chunkSetsInGraph, singleChunkSets } =
+							getExportsChunkSetsInGraph();
+						return createGetCombinations(
+							chunkSetsInGraph,
+							singleChunkSets,
+							getExportsChunkSetsByCount()
+						);
 					});
 					const getExportsCombinations = key =>
 						getExportsCombinationsFactory()(key);
 
-					/** @type {WeakMap<ChunkCombination, WeakMap<ChunkFilterFunction, ChunkCombination>>} */
+					/**
+					 * @typedef {Object} SelectedChunksResult
+					 * @property {Chunk[]} chunks the list of chunks
+					 * @property {bigint | Chunk} key a key of the list
+					 */
+
+					/** @type {WeakMap<Set<Chunk> | Chunk, WeakMap<ChunkFilterFunction, SelectedChunksResult>>} */
 					const selectedChunksCacheByChunksSet = new WeakMap();
 
 					/**
-					 * get chunks by applying the filter function to the list
+					 * get list and key by applying the filter function to the list
 					 * It is cached for performance reasons
-					 * @param {ChunkCombination} chunks list of chunks
+					 * @param {Set<Chunk> | Chunk} chunks list of chunks
 					 * @param {ChunkFilterFunction} chunkFilter filter function for chunks
-					 * @returns {ChunkCombination} selected chunks
+					 * @returns {SelectedChunksResult} list and key
 					 */
 					const getSelectedChunks = (chunks, chunkFilter) => {
 						let entry = selectedChunksCacheByChunksSet.get(chunks);
@@ -889,16 +1015,22 @@ module.exports = class SplitChunksPlugin {
 							entry = new WeakMap();
 							selectedChunksCacheByChunksSet.set(chunks, entry);
 						}
-						/** @type {ChunkCombination} */
+						/** @type {SelectedChunksResult} */
 						let entry2 = entry.get(chunkFilter);
 						if (entry2 === undefined) {
-							/** @type {ChunkCombination} */
-							let selectedChunks = ChunkCombination.empty;
-							for (const chunk of chunks.chunksIterable) {
-								if (chunkFilter(chunk))
-									selectedChunks = selectedChunks.with(chunk);
+							/** @type {Chunk[]} */
+							const selectedChunks = [];
+							if (chunks instanceof Chunk) {
+								if (chunkFilter(chunks)) selectedChunks.push(chunks);
+							} else {
+								for (const chunk of chunks) {
+									if (chunkFilter(chunk)) selectedChunks.push(chunk);
+								}
 							}
-							entry2 = selectedChunks;
+							entry2 = {
+								chunks: selectedChunks,
+								key: getKey(selectedChunks)
+							};
 							entry.set(chunkFilter, entry2);
 						}
 						return entry2;
@@ -917,7 +1049,8 @@ module.exports = class SplitChunksPlugin {
 					/**
 					 * @param {CacheGroup} cacheGroup the current cache group
 					 * @param {number} cacheGroupIndex the index of the cache group of ordering
-					 * @param {ChunkCombination} selectedChunks chunks selected for this module
+					 * @param {Chunk[]} selectedChunks chunks selected for this module
+					 * @param {bigint | Chunk} selectedChunksKey a key of selectedChunks
 					 * @param {Module} module the current module
 					 * @returns {void}
 					 */
@@ -925,20 +1058,25 @@ module.exports = class SplitChunksPlugin {
 						cacheGroup,
 						cacheGroupIndex,
 						selectedChunks,
+						selectedChunksKey,
 						module
 					) => {
 						// Break if minimum number of chunks is not reached
-						if (selectedChunks.size < cacheGroup.minChunks) return;
+						if (selectedChunks.length < cacheGroup.minChunks) return;
 						// Determine name for split chunk
 						const name = cacheGroup.getName(
 							module,
-							selectedChunks.getChunks(),
+							selectedChunks,
 							cacheGroup.key
 						);
 						// Check if the name is ok
 						const existingChunk = compilation.namedChunks.get(name);
 						if (existingChunk) {
-							const parentValidationKey = `${name}|${selectedChunks.debugId}`;
+							const parentValidationKey = `${name}|${
+								typeof selectedChunksKey === "bigint"
+									? selectedChunksKey
+									: selectedChunksKey.debugId
+							}`;
 							const valid = alreadyValidatedParents.get(parentValidationKey);
 							if (valid === false) return;
 							if (valid === undefined) {
@@ -947,7 +1085,7 @@ module.exports = class SplitChunksPlugin {
 								let isInAllParents = true;
 								/** @type {Set<ChunkGroup>} */
 								const queue = new Set();
-								for (const chunk of selectedChunks.chunksIterable) {
+								for (const chunk of selectedChunks) {
 									for (const group of chunk.groupsIterable) {
 										queue.add(group);
 									}
@@ -993,7 +1131,9 @@ module.exports = class SplitChunksPlugin {
 						// This automatically merges equal names
 						const key =
 							cacheGroup.key +
-							(name ? ` name:${name}` : ` chunks:${selectedChunks.debugId}`);
+							(name
+								? ` name:${name}`
+								: ` chunks:${keyToString(selectedChunksKey)}`);
 						// Add module to maps
 						let info = chunksInfoMap.get(key);
 						if (info === undefined) {
@@ -1008,9 +1148,9 @@ module.exports = class SplitChunksPlugin {
 									cacheGroupIndex,
 									name,
 									sizes: {},
-									chunks: ChunkCombination.empty,
+									chunks: new Set(),
 									reuseableChunks: new Set(),
-									chunkCombinations: new Set()
+									chunksKeys: new Set()
 								})
 							);
 						}
@@ -1021,10 +1161,12 @@ module.exports = class SplitChunksPlugin {
 								info.sizes[type] = (info.sizes[type] || 0) + module.size(type);
 							}
 						}
-						const oldChunksKeysSize = info.chunkCombinations.size;
-						info.chunkCombinations.add(selectedChunks);
-						if (oldChunksKeysSize !== info.chunkCombinations.size) {
-							info.chunks = info.chunks.withAll(selectedChunks);
+						const oldChunksKeysSize = info.chunksKeys.size;
+						info.chunksKeys.add(selectedChunksKey);
+						if (oldChunksKeysSize !== info.chunksKeys.size) {
+							for (const chunk of selectedChunks) {
+								info.chunks.add(chunk);
+							}
 						}
 					};
 
@@ -1045,56 +1187,50 @@ module.exports = class SplitChunksPlugin {
 							continue;
 						}
 
-						const chunkCombination =
-							chunkGraph.getModuleChunkCombination(module);
+						// 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<Set<Chunk> | Chunk>} */
+							const set = new Set();
+							const groupedByUsedExports = groupedByExportsMap.get(module);
+							for (const chunks of groupedByUsedExports) {
+								const chunksKey = getKey(chunks);
+								for (const comb of getExportsCombinations(chunksKey))
+									set.add(comb);
+							}
+							return set;
+						});
 
 						let cacheGroupIndex = 0;
 						for (const cacheGroupSource of cacheGroups) {
 							const cacheGroup = this._getCacheGroup(cacheGroupSource);
 
-							// Break if minimum number of chunks is not reached
-							if (chunkCombination.size < cacheGroup.minChunks) continue;
-
-							/** @type {Iterable<ChunkCombination>} */
-							let combs;
-							if (cacheGroup.usedExports) {
-								// fill the groupedByExportsMap
-								getExportsChunkCombinationsInGraph();
-								/** @type {Set<ChunkCombination>} */
-								const set = new Set();
-								const groupedByUsedExports = groupedByExportsMap.get(module);
-								for (const chunkCombination of groupedByUsedExports) {
-									const preSelectedChunks = getSelectedChunks(
-										chunkCombination,
-										cacheGroup.chunksFilter
-									);
-									// Break if minimum number of chunks is not reached
-									if (preSelectedChunks.size < cacheGroup.minChunks) continue;
-
-									for (const comb of getExportsCombinations(preSelectedChunks))
-										set.add(comb);
-								}
-								combs = set;
-							} else {
-								const preSelectedChunks = getSelectedChunks(
-									chunkCombination,
-									cacheGroup.chunksFilter
-								);
-								// Break if minimum number of chunks is not reached
-								if (preSelectedChunks.size < cacheGroup.minChunks) continue;
-
-								combs = getCombinations(preSelectedChunks);
-							}
+							const combs = cacheGroup.usedExports
+								? getCombsByUsedExports()
+								: getCombs();
 							// For all combination of chunk selection
-							for (const selectedChunks of combs) {
+							for (const chunkCombination of combs) {
 								// Break if minimum number of chunks is not reached
-								const count = chunkCombination.size;
+								const count =
+									chunkCombination instanceof Chunk ? 1 : chunkCombination.size;
 								if (count < cacheGroup.minChunks) continue;
+								// Select chunks by configuration
+								const { chunks: selectedChunks, key: selectedChunksKey } =
+									getSelectedChunks(chunkCombination, cacheGroup.chunksFilter);
 
 								addModuleToChunksInfoMap(
 									cacheGroup,
 									cacheGroupIndex,
 									selectedChunks,
+									selectedChunksKey,
 									module
 								);
 							}
@@ -1141,6 +1277,14 @@ module.exports = class SplitChunksPlugin {
 					for (const [key, info] of chunksInfoMap) {
 						if (removeMinSizeViolatingModules(info)) {
 							chunksInfoMap.delete(key);
+						} else if (
+							!checkMinSizeReduction(
+								info.sizes,
+								info.cacheGroup.minSizeReduction,
+								info.chunks.size
+							)
+						) {
+							chunksInfoMap.delete(key);
 						}
 					}
 
@@ -1186,12 +1330,12 @@ module.exports = class SplitChunksPlugin {
 							const chunkByName = compilation.namedChunks.get(chunkName);
 							if (chunkByName !== undefined) {
 								newChunk = chunkByName;
-								const newChunks = item.chunks.without(newChunk);
-								isExistingChunk = newChunks !== item.chunks;
-								if (isExistingChunk) item.chunks = newChunks;
+								const oldSize = item.chunks.size;
+								item.chunks.delete(newChunk);
+								isExistingChunk = item.chunks.size !== oldSize;
 							}
 						} else if (item.cacheGroup.reuseExistingChunk) {
-							outer: for (const chunk of item.chunks.chunksIterable) {
+							outer: for (const chunk of item.chunks) {
 								if (
 									chunkGraph.getNumberOfChunkModules(chunk) !==
 									item.modules.size
@@ -1225,7 +1369,7 @@ module.exports = class SplitChunksPlugin {
 								}
 							}
 							if (newChunk) {
-								item.chunks = item.chunks.without(newChunk);
+								item.chunks.delete(newChunk);
 								chunkName = undefined;
 								isExistingChunk = true;
 								isReusedWithAllModules = true;
@@ -1236,7 +1380,7 @@ module.exports = class SplitChunksPlugin {
 							item.cacheGroup._conditionalEnforce &&
 							checkMinSize(item.sizes, item.cacheGroup.enforceSizeThreshold);
 
-						let usedChunks = item.chunks;
+						const usedChunks = new Set(item.chunks);
 
 						// Check if maxRequests condition can be fulfilled
 						if (
@@ -1244,7 +1388,7 @@ module.exports = class SplitChunksPlugin {
 							(Number.isFinite(item.cacheGroup.maxInitialRequests) ||
 								Number.isFinite(item.cacheGroup.maxAsyncRequests))
 						) {
-							for (const chunk of usedChunks.chunksIterable) {
+							for (const chunk of usedChunks) {
 								// respect max requests
 								const maxRequests = chunk.isOnlyInitial()
 									? item.cacheGroup.maxInitialRequests
@@ -1258,28 +1402,30 @@ module.exports = class SplitChunksPlugin {
 									isFinite(maxRequests) &&
 									getRequests(chunk) >= maxRequests
 								) {
-									usedChunks = usedChunks.without(chunk);
+									usedChunks.delete(chunk);
 								}
 							}
 						}
 
-						outer: for (const chunk of usedChunks.chunksIterable) {
+						outer: for (const chunk of usedChunks) {
 							for (const module of item.modules) {
 								if (chunkGraph.isModuleInChunk(module, chunk)) continue outer;
 							}
-							usedChunks = usedChunks.without(chunk);
+							usedChunks.delete(chunk);
 						}
 
 						// Were some (invalid) chunks removed from usedChunks?
 						// => readd all modules to the queue, as things could have been changed
-						if (usedChunks !== item.chunks) {
-							if (isExistingChunk) usedChunks = usedChunks.with(newChunk);
+						if (usedChunks.size < item.chunks.size) {
+							if (isExistingChunk) usedChunks.add(newChunk);
 							if (usedChunks.size >= item.cacheGroup.minChunks) {
+								const chunksArr = Array.from(usedChunks);
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
 										item.cacheGroup,
 										item.cacheGroupIndex,
-										usedChunks,
+										chunksArr,
+										getKey(usedChunks),
 										module
 									);
 								}
@@ -1293,7 +1439,7 @@ module.exports = class SplitChunksPlugin {
 							item.cacheGroup._validateRemainingSize &&
 							usedChunks.size === 1
 						) {
-							const [chunk] = usedChunks.chunksIterable;
+							const [chunk] = usedChunks;
 							let chunkSizes = Object.create(null);
 							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
 								if (!item.modules.has(module)) {
@@ -1327,7 +1473,7 @@ module.exports = class SplitChunksPlugin {
 							newChunk = compilation.addChunk(chunkName);
 						}
 						// Walk through all chunks
-						for (const chunk of usedChunks.chunksIterable) {
+						for (const chunk of usedChunks) {
 							// Add graph connections for splitted chunk
 							chunk.split(newChunk);
 						}
@@ -1357,14 +1503,14 @@ module.exports = class SplitChunksPlugin {
 								// Add module to new chunk
 								chunkGraph.connectChunkAndModule(newChunk, module);
 								// Remove module from used chunks
-								for (const chunk of usedChunks.chunksIterable) {
+								for (const chunk of usedChunks) {
 									chunkGraph.disconnectChunkAndModule(chunk, module);
 								}
 							}
 						} else {
 							// Remove all modules from used chunks
 							for (const module of item.modules) {
-								for (const chunk of usedChunks.chunksIterable) {
+								for (const chunk of usedChunks) {
 									chunkGraph.disconnectChunkAndModule(chunk, module);
 								}
 							}
@@ -1406,7 +1552,7 @@ module.exports = class SplitChunksPlugin {
 
 						// remove all modules from other entries and update size
 						for (const [key, info] of chunksInfoMap) {
-							if (info.chunks.hasSharedChunks(usedChunks)) {
+							if (isOverlap(info.chunks, usedChunks)) {
 								// update modules and total size
 								// may remove it from the map when < minSize
 								let updated = false;
@@ -1426,7 +1572,14 @@ module.exports = class SplitChunksPlugin {
 										chunksInfoMap.delete(key);
 										continue;
 									}
-									if (removeMinSizeViolatingModules(info)) {
+									if (
+										removeMinSizeViolatingModules(info) ||
+										!checkMinSizeReduction(
+											info.sizes,
+											info.cacheGroup.minSizeReduction,
+											info.chunks.size
+										)
+									) {
 										chunksInfoMap.delete(key);
 										continue;
 									}