webpack 5.57.1 → 5.58.0

package/lib/optimize/SplitChunksPlugin.js

@@ -5,11 +5,10 @@
 
 "use strict";
 
-const Chunk = require("../Chunk");
+const ChunkCombination = require("../ChunkCombination");
 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,
@@ -26,6 +25,7 @@ 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 */
@@ -155,9 +155,9 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number} cacheGroupIndex
  * @property {string} name
  * @property {Record<string, number>} sizes
- * @property {Set<Chunk>} chunks
+ * @property {ChunkCombination} chunks
  * @property {Set<Chunk>} reuseableChunks
- * @property {Set<bigint | Chunk>} chunksKeys
+ * @property {Set<ChunkCombination>} chunkCombinations
  */
 
 const defaultGetName = /** @type {GetName} */ (() => {});
@@ -204,19 +204,6 @@ 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);
 
 /**
@@ -769,207 +756,132 @@ 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");
-					let index = ONE;
-					for (const chunk of chunks) {
-						chunkIndexMap.set(chunk, index);
-						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) {
-							key = key | chunkIndexMap.get(result.value);
-						}
-						return key;
-					};
-					const keyToString = key => {
-						if (typeof key === "bigint") return key.toString(16);
-						return chunkIndexMap.get(key).toString(16);
-					};
 
-					const getChunkSetsInGraph = memoize(() => {
-						/** @type {Map<bigint, Set<Chunk>>} */
-						const chunkSetsInGraph = new Map();
-						/** @type {Set<Chunk>} */
-						const singleChunkSets = new Set();
+					const getChunkCombinationsInGraph = memoize(() => {
+						/** @type {Set<ChunkCombination>} */
+						const chunkCombinationsInGraph = new Set();
 						for (const module of compilation.modules) {
-							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);
-							}
+							const chunkCombination =
+								chunkGraph.getModuleChunkCombination(module);
+							chunkCombinationsInGraph.add(chunkCombination);
 						}
-						return { chunkSetsInGraph, singleChunkSets };
+						return chunkCombinationsInGraph;
 					});
 
 					/**
 					 * @param {Module} module the module
-					 * @returns {Iterable<Chunk[]>} groups of chunks with equal exports
+					 * @returns {Iterable<ChunkCombination>} 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 list = groupedByUsedExports.get(key);
-							if (list !== undefined) {
-								list.push(chunk);
-							} else {
-								groupedByUsedExports.set(key, [chunk]);
-							}
+							const combination =
+								groupedByUsedExports.get(key) || ChunkCombination.empty;
+							groupedByUsedExports.set(key, combination.with(chunk));
 						}
 						return groupedByUsedExports.values();
 					};
 
-					/** @type {Map<Module, Iterable<Chunk[]>>} */
+					/** @type {Map<Module, Iterable<ChunkCombination>>} */
 					const groupedByExportsMap = new Map();
 
-					const getExportsChunkSetsInGraph = memoize(() => {
-						/** @type {Map<bigint, Set<Chunk>>} */
-						const chunkSetsInGraph = new Map();
-						/** @type {Set<Chunk>} */
-						const singleChunkSets = new Set();
+					const getExportsChunkCombinationsInGraph = memoize(() => {
+						/** @type {Set<ChunkCombination>} */
+						const chunkCombinationsInGraph = new Set();
 						for (const module of compilation.modules) {
 							const groupedChunks = Array.from(groupChunksByExports(module));
 							groupedByExportsMap.set(module, groupedChunks);
-							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));
-									}
-								}
+							for (const chunkCombination of groupedChunks) {
+								chunkCombinationsInGraph.add(chunkCombination);
 							}
 						}
-						return { chunkSetsInGraph, singleChunkSets };
+						return chunkCombinationsInGraph;
 					});
 
 					// group these set of chunks by count
 					// to allow to check less sets via isSubset
 					// (only smaller sets can be subset)
-					const groupChunkSetsByCount = chunkSets => {
-						/** @type {Map<number, Array<Set<Chunk>>>} */
-						const chunkSetsByCount = new Map();
-						for (const chunksSet of chunkSets) {
+					const groupChunkCombinationsByCount = chunkCombinations => {
+						/** @type {Map<number, ChunkCombination[]>} */
+						const chunkCombinationsByCount = new Map();
+						for (const chunksSet of chunkCombinations) {
 							const count = chunksSet.size;
-							let array = chunkSetsByCount.get(count);
+							let array = chunkCombinationsByCount.get(count);
 							if (array === undefined) {
 								array = [];
-								chunkSetsByCount.set(count, array);
+								chunkCombinationsByCount.set(count, array);
 							}
 							array.push(chunksSet);
 						}
-						return chunkSetsByCount;
+						return chunkCombinationsByCount;
 					};
-					const getChunkSetsByCount = memoize(() =>
-						groupChunkSetsByCount(
-							getChunkSetsInGraph().chunkSetsInGraph.values()
-						)
+					const getChunkCombinationsByCount = memoize(() =>
+						groupChunkCombinationsByCount(getChunkCombinationsInGraph())
 					);
-					const getExportsChunkSetsByCount = memoize(() =>
-						groupChunkSetsByCount(
-							getExportsChunkSetsInGraph().chunkSetsInGraph.values()
-						)
+					const getExportsChunkCombinationsByCount = memoize(() =>
+						groupChunkCombinationsByCount(getExportsChunkCombinationsInGraph())
 					);
 
-					// Create a list of possible combinations
-					const createGetCombinations = (
-						chunkSets,
-						singleChunkSets,
-						chunkSetsByCount
-					) => {
-						/** @type {Map<bigint | Chunk, (Set<Chunk> | Chunk)[]>} */
+					/**
+					 * 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[]>} */
 						const combinationsCache = new Map();
 
-						return key => {
-							const cacheEntry = combinationsCache.get(key);
+						/**
+						 * @param {ChunkCombination} chunkCombination chunkCombination
+						 * @returns {ChunkCombination[]} combinations
+						 */
+						return chunkCombination => {
+							const cacheEntry = combinationsCache.get(chunkCombination);
 							if (cacheEntry !== undefined) return cacheEntry;
-							if (key instanceof Chunk) {
-								const result = [key];
-								combinationsCache.set(key, result);
+							if (chunkCombination.size === 1) {
+								const result = [chunkCombination];
+								combinationsCache.set(chunkCombination, result);
 								return result;
 							}
-							const chunksSet = chunkSets.get(key);
-							/** @type {(Set<Chunk> | Chunk)[]} */
-							const array = [chunksSet];
-							for (const [count, setArray] of chunkSetsByCount) {
+							/** @type {ChunkCombination[]} */
+							const array = [chunkCombination];
+							for (const [count, setArray] of chunkCombinationsByCount) {
 								// "equal" is not needed because they would have been merge in the first step
-								if (count < chunksSet.size) {
+								if (count < chunkCombination.size) {
 									for (const set of setArray) {
-										if (isSubset(chunksSet, set)) {
+										if (chunkCombination.isSubset(set)) {
 											array.push(set);
 										}
 									}
 								}
 							}
-							for (const chunk of singleChunkSets) {
-								if (chunksSet.has(chunk)) {
-									array.push(chunk);
-								}
-							}
-							combinationsCache.set(key, array);
+							combinationsCache.set(chunkCombination, array);
 							return array;
 						};
 					};
 
 					const getCombinationsFactory = memoize(() => {
-						const { chunkSetsInGraph, singleChunkSets } = getChunkSetsInGraph();
-						return createGetCombinations(
-							chunkSetsInGraph,
-							singleChunkSets,
-							getChunkSetsByCount()
-						);
+						return createGetCombinations(getChunkCombinationsByCount());
 					});
 					const getCombinations = key => getCombinationsFactory()(key);
 
 					const getExportsCombinationsFactory = memoize(() => {
-						const { chunkSetsInGraph, singleChunkSets } =
-							getExportsChunkSetsInGraph();
-						return createGetCombinations(
-							chunkSetsInGraph,
-							singleChunkSets,
-							getExportsChunkSetsByCount()
-						);
+						return createGetCombinations(getExportsChunkCombinationsByCount());
 					});
 					const getExportsCombinations = key =>
 						getExportsCombinationsFactory()(key);
 
-					/**
-					 * @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>>} */
+					/** @type {WeakMap<ChunkCombination, WeakMap<ChunkFilterFunction, ChunkCombination>>} */
 					const selectedChunksCacheByChunksSet = new WeakMap();
 
 					/**
-					 * get list and key by applying the filter function to the list
+					 * get chunks by applying the filter function to the list
 					 * It is cached for performance reasons
-					 * @param {Set<Chunk> | Chunk} chunks list of chunks
+					 * @param {ChunkCombination} chunks list of chunks
 					 * @param {ChunkFilterFunction} chunkFilter filter function for chunks
-					 * @returns {SelectedChunksResult} list and key
+					 * @returns {ChunkCombination} selected chunks
 					 */
 					const getSelectedChunks = (chunks, chunkFilter) => {
 						let entry = selectedChunksCacheByChunksSet.get(chunks);
@@ -977,22 +889,16 @@ module.exports = class SplitChunksPlugin {
 							entry = new WeakMap();
 							selectedChunksCacheByChunksSet.set(chunks, entry);
 						}
-						/** @type {SelectedChunksResult} */
+						/** @type {ChunkCombination} */
 						let entry2 = entry.get(chunkFilter);
 						if (entry2 === undefined) {
-							/** @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);
-								}
+							/** @type {ChunkCombination} */
+							let selectedChunks = ChunkCombination.empty;
+							for (const chunk of chunks.chunksIterable) {
+								if (chunkFilter(chunk))
+									selectedChunks = selectedChunks.with(chunk);
 							}
-							entry2 = {
-								chunks: selectedChunks,
-								key: getKey(selectedChunks)
-							};
+							entry2 = selectedChunks;
 							entry.set(chunkFilter, entry2);
 						}
 						return entry2;
@@ -1011,8 +917,7 @@ module.exports = class SplitChunksPlugin {
 					/**
 					 * @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
-					 * @param {bigint | Chunk} selectedChunksKey a key of selectedChunks
+					 * @param {ChunkCombination} selectedChunks chunks selected for this module
 					 * @param {Module} module the current module
 					 * @returns {void}
 					 */
@@ -1020,25 +925,20 @@ module.exports = class SplitChunksPlugin {
 						cacheGroup,
 						cacheGroupIndex,
 						selectedChunks,
-						selectedChunksKey,
 						module
 					) => {
 						// Break if minimum number of chunks is not reached
-						if (selectedChunks.length < cacheGroup.minChunks) return;
+						if (selectedChunks.size < cacheGroup.minChunks) return;
 						// Determine name for split chunk
 						const name = cacheGroup.getName(
 							module,
-							selectedChunks,
+							selectedChunks.getChunks(),
 							cacheGroup.key
 						);
 						// Check if the name is ok
 						const existingChunk = compilation.namedChunks.get(name);
 						if (existingChunk) {
-							const parentValidationKey = `${name}|${
-								typeof selectedChunksKey === "bigint"
-									? selectedChunksKey
-									: selectedChunksKey.debugId
-							}`;
+							const parentValidationKey = `${name}|${selectedChunks.debugId}`;
 							const valid = alreadyValidatedParents.get(parentValidationKey);
 							if (valid === false) return;
 							if (valid === undefined) {
@@ -1047,7 +947,7 @@ module.exports = class SplitChunksPlugin {
 								let isInAllParents = true;
 								/** @type {Set<ChunkGroup>} */
 								const queue = new Set();
-								for (const chunk of selectedChunks) {
+								for (const chunk of selectedChunks.chunksIterable) {
 									for (const group of chunk.groupsIterable) {
 										queue.add(group);
 									}
@@ -1093,9 +993,7 @@ module.exports = class SplitChunksPlugin {
 						// This automatically merges equal names
 						const key =
 							cacheGroup.key +
-							(name
-								? ` name:${name}`
-								: ` chunks:${keyToString(selectedChunksKey)}`);
+							(name ? ` name:${name}` : ` chunks:${selectedChunks.debugId}`);
 						// Add module to maps
 						let info = chunksInfoMap.get(key);
 						if (info === undefined) {
@@ -1110,9 +1008,9 @@ module.exports = class SplitChunksPlugin {
 									cacheGroupIndex,
 									name,
 									sizes: {},
-									chunks: new Set(),
+									chunks: ChunkCombination.empty,
 									reuseableChunks: new Set(),
-									chunksKeys: new Set()
+									chunkCombinations: new Set()
 								})
 							);
 						}
@@ -1123,12 +1021,10 @@ module.exports = class SplitChunksPlugin {
 								info.sizes[type] = (info.sizes[type] || 0) + module.size(type);
 							}
 						}
-						const oldChunksKeysSize = info.chunksKeys.size;
-						info.chunksKeys.add(selectedChunksKey);
-						if (oldChunksKeysSize !== info.chunksKeys.size) {
-							for (const chunk of selectedChunks) {
-								info.chunks.add(chunk);
-							}
+						const oldChunksKeysSize = info.chunkCombinations.size;
+						info.chunkCombinations.add(selectedChunks);
+						if (oldChunksKeysSize !== info.chunkCombinations.size) {
+							info.chunks = info.chunks.withAll(selectedChunks);
 						}
 					};
 
@@ -1149,50 +1045,56 @@ 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<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;
-						});
+						const chunkCombination =
+							chunkGraph.getModuleChunkCombination(module);
 
 						let cacheGroupIndex = 0;
 						for (const cacheGroupSource of cacheGroups) {
 							const cacheGroup = this._getCacheGroup(cacheGroupSource);
 
-							const combs = cacheGroup.usedExports
-								? getCombsByUsedExports()
-								: getCombs();
+							// 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);
+							}
 							// For all combination of chunk selection
-							for (const chunkCombination of combs) {
+							for (const selectedChunks of combs) {
 								// Break if minimum number of chunks is not reached
-								const count =
-									chunkCombination instanceof Chunk ? 1 : chunkCombination.size;
+								const count = 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
 								);
 							}
@@ -1284,12 +1186,12 @@ module.exports = class SplitChunksPlugin {
 							const chunkByName = compilation.namedChunks.get(chunkName);
 							if (chunkByName !== undefined) {
 								newChunk = chunkByName;
-								const oldSize = item.chunks.size;
-								item.chunks.delete(newChunk);
-								isExistingChunk = item.chunks.size !== oldSize;
+								const newChunks = item.chunks.without(newChunk);
+								isExistingChunk = newChunks !== item.chunks;
+								if (isExistingChunk) item.chunks = newChunks;
 							}
 						} else if (item.cacheGroup.reuseExistingChunk) {
-							outer: for (const chunk of item.chunks) {
+							outer: for (const chunk of item.chunks.chunksIterable) {
 								if (
 									chunkGraph.getNumberOfChunkModules(chunk) !==
 									item.modules.size
@@ -1323,7 +1225,7 @@ module.exports = class SplitChunksPlugin {
 								}
 							}
 							if (newChunk) {
-								item.chunks.delete(newChunk);
+								item.chunks = item.chunks.without(newChunk);
 								chunkName = undefined;
 								isExistingChunk = true;
 								isReusedWithAllModules = true;
@@ -1334,7 +1236,7 @@ module.exports = class SplitChunksPlugin {
 							item.cacheGroup._conditionalEnforce &&
 							checkMinSize(item.sizes, item.cacheGroup.enforceSizeThreshold);
 
-						const usedChunks = new Set(item.chunks);
+						let usedChunks = item.chunks;
 
 						// Check if maxRequests condition can be fulfilled
 						if (
@@ -1342,7 +1244,7 @@ module.exports = class SplitChunksPlugin {
 							(Number.isFinite(item.cacheGroup.maxInitialRequests) ||
 								Number.isFinite(item.cacheGroup.maxAsyncRequests))
 						) {
-							for (const chunk of usedChunks) {
+							for (const chunk of usedChunks.chunksIterable) {
 								// respect max requests
 								const maxRequests = chunk.isOnlyInitial()
 									? item.cacheGroup.maxInitialRequests
@@ -1356,30 +1258,28 @@ module.exports = class SplitChunksPlugin {
 									isFinite(maxRequests) &&
 									getRequests(chunk) >= maxRequests
 								) {
-									usedChunks.delete(chunk);
+									usedChunks = usedChunks.without(chunk);
 								}
 							}
 						}
 
-						outer: for (const chunk of usedChunks) {
+						outer: for (const chunk of usedChunks.chunksIterable) {
 							for (const module of item.modules) {
 								if (chunkGraph.isModuleInChunk(module, chunk)) continue outer;
 							}
-							usedChunks.delete(chunk);
+							usedChunks = usedChunks.without(chunk);
 						}
 
 						// Were some (invalid) chunks removed from usedChunks?
 						// => readd all modules to the queue, as things could have been changed
-						if (usedChunks.size < item.chunks.size) {
-							if (isExistingChunk) usedChunks.add(newChunk);
+						if (usedChunks !== item.chunks) {
+							if (isExistingChunk) usedChunks = usedChunks.with(newChunk);
 							if (usedChunks.size >= item.cacheGroup.minChunks) {
-								const chunksArr = Array.from(usedChunks);
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
 										item.cacheGroup,
 										item.cacheGroupIndex,
-										chunksArr,
-										getKey(usedChunks),
+										usedChunks,
 										module
 									);
 								}
@@ -1393,7 +1293,7 @@ module.exports = class SplitChunksPlugin {
 							item.cacheGroup._validateRemainingSize &&
 							usedChunks.size === 1
 						) {
-							const [chunk] = usedChunks;
+							const [chunk] = usedChunks.chunksIterable;
 							let chunkSizes = Object.create(null);
 							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
 								if (!item.modules.has(module)) {
@@ -1427,7 +1327,7 @@ module.exports = class SplitChunksPlugin {
 							newChunk = compilation.addChunk(chunkName);
 						}
 						// Walk through all chunks
-						for (const chunk of usedChunks) {
+						for (const chunk of usedChunks.chunksIterable) {
 							// Add graph connections for splitted chunk
 							chunk.split(newChunk);
 						}
@@ -1457,14 +1357,14 @@ module.exports = class SplitChunksPlugin {
 								// Add module to new chunk
 								chunkGraph.connectChunkAndModule(newChunk, module);
 								// Remove module from used chunks
-								for (const chunk of usedChunks) {
+								for (const chunk of usedChunks.chunksIterable) {
 									chunkGraph.disconnectChunkAndModule(chunk, module);
 								}
 							}
 						} else {
 							// Remove all modules from used chunks
 							for (const module of item.modules) {
-								for (const chunk of usedChunks) {
+								for (const chunk of usedChunks.chunksIterable) {
 									chunkGraph.disconnectChunkAndModule(chunk, module);
 								}
 							}
@@ -1506,7 +1406,7 @@ module.exports = class SplitChunksPlugin {
 
 						// remove all modules from other entries and update size
 						for (const [key, info] of chunksInfoMap) {
-							if (isOverlap(info.chunks, usedChunks)) {
+							if (info.chunks.hasSharedChunks(usedChunks)) {
 								// update modules and total size
 								// may remove it from the map when < minSize
 								let updated = false;

package/lib/schemes/FileUriPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { URL, fileURLToPath } = require("url");
+const { NormalModule } = require("..");
 
 /** @typedef {import("../Compiler")} Compiler */
 
@@ -32,6 +33,14 @@ class FileUriPlugin {
 						resourceData.resource = path + query + fragment;
 						return true;
 					});
+				const hooks = NormalModule.getCompilationHooks(compilation);
+				hooks.readResource
+					.for(undefined)
+					.tapAsync("FileUriPlugin", (loaderContext, callback) => {
+						const { resourcePath } = loaderContext;
+						loaderContext.addDependency(resourcePath);
+						loaderContext.fs.readFile(resourcePath, callback);
+					});
 			}
 		);
 	}