webpack 5.97.1 → 5.104.1

package/lib/optimize/SplitChunksPlugin.js

@@ -12,8 +12,8 @@ const { requestToId } = require("../ids/IdHelpers");
 const { isSubset } = require("../util/SetHelpers");
 const SortableSet = require("../util/SortableSet");
 const {
-	compareModulesByIdentifier,
-	compareIterables
+	compareIterables,
+	compareModulesByIdentifier
 } = require("../util/comparators");
 const createHash = require("../util/createHash");
 const deterministicGrouping = require("../util/deterministicGrouping");
@@ -25,37 +25,46 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksGetCacheGroups} OptimizationSplitChunksGetCacheGroups */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksSizes} OptimizationSplitChunksSizes */
-/** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("../config/defaults").OutputNormalizedWithDefaults} OutputOptions */
+/** @typedef {import("../Chunk").ChunkName} ChunkName */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
 
-/** @typedef {Record<string, number>} SplitChunksSizes */
-
 /**
- * @callback ChunkFilterFunction
+ * @callback ChunkFilterFn
  * @param {Chunk} chunk
  * @returns {boolean | undefined}
  */
 
+/** @typedef {number} Priority */
+/** @typedef {number} Size */
+/** @typedef {number} CountOfChunk */
+/** @typedef {number} CountOfRequest */
+
 /**
  * @callback CombineSizeFunction
- * @param {number} a
- * @param {number} b
- * @returns {number}
+ * @param {Size} a
+ * @param {Size} b
+ * @returns {Size}
  */
 
+/** @typedef {SourceType[]} SourceTypes */
+/** @typedef {SourceType[]} DefaultSizeTypes */
+/** @typedef {Record<SourceType, Size>} SplitChunksSizes */
+
 /**
  * @typedef {object} CacheGroupSource
- * @property {string=} key
- * @property {number=} priority
- * @property {GetName=} getName
- * @property {ChunkFilterFunction=} chunksFilter
+ * @property {string} key
+ * @property {Priority=} priority
+ * @property {GetNameFn=} getName
+ * @property {ChunkFilterFn=} chunksFilter
  * @property {boolean=} enforce
  * @property {SplitChunksSizes} minSize
  * @property {SplitChunksSizes} minSizeReduction
@@ -63,9 +72,9 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxAsyncSize
  * @property {SplitChunksSizes} maxInitialSize
- * @property {number=} minChunks
- * @property {number=} maxAsyncRequests
- * @property {number=} maxInitialRequests
+ * @property {CountOfChunk=} minChunks
+ * @property {CountOfRequest=} maxAsyncRequests
+ * @property {CountOfRequest=} maxInitialRequests
  * @property {TemplatePath=} filename
  * @property {string=} idHint
  * @property {string=} automaticNameDelimiter
@@ -76,20 +85,20 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /**
  * @typedef {object} CacheGroup
  * @property {string} key
- * @property {number=} priority
- * @property {GetName=} getName
- * @property {ChunkFilterFunction=} chunksFilter
+ * @property {Priority} priority
+ * @property {GetNameFn=} getName
+ * @property {ChunkFilterFn} chunksFilter
  * @property {SplitChunksSizes} minSize
  * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxAsyncSize
  * @property {SplitChunksSizes} maxInitialSize
- * @property {number=} minChunks
- * @property {number=} maxAsyncRequests
- * @property {number=} maxInitialRequests
+ * @property {CountOfChunk} minChunks
+ * @property {CountOfRequest} maxAsyncRequests
+ * @property {CountOfRequest} maxInitialRequests
  * @property {TemplatePath=} filename
- * @property {string=} idHint
+ * @property {string} idHint
  * @property {string} automaticNameDelimiter
  * @property {boolean} reuseExistingChunk
  * @property {boolean} usedExports
@@ -101,7 +110,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 
 /**
  * @typedef {object} FallbackCacheGroup
- * @property {ChunkFilterFunction} chunksFilter
+ * @property {ChunkFilterFn} chunksFilter
  * @property {SplitChunksSizes} minSize
  * @property {SplitChunksSizes} maxAsyncSize
  * @property {SplitChunksSizes} maxInitialSize
@@ -118,55 +127,58 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @callback GetCacheGroups
  * @param {Module} module
  * @param {CacheGroupsContext} context
- * @returns {CacheGroupSource[]}
+ * @returns {CacheGroupSource[] | null}
  */
 
 /**
- * @callback GetName
- * @param {Module=} module
- * @param {Chunk[]=} chunks
- * @param {string=} key
- * @returns {string=}
+ * @callback GetNameFn
+ * @param {Module} module
+ * @param {Chunk[]} chunks
+ * @param {string} key
+ * @returns {string | undefined}
  */
 
 /**
  * @typedef {object} SplitChunksOptions
- * @property {ChunkFilterFunction} chunksFilter
- * @property {string[]} defaultSizeTypes
+ * @property {ChunkFilterFn} chunksFilter
+ * @property {DefaultSizeTypes} defaultSizeTypes
  * @property {SplitChunksSizes} minSize
  * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxInitialSize
  * @property {SplitChunksSizes} maxAsyncSize
- * @property {number} minChunks
- * @property {number} maxAsyncRequests
- * @property {number} maxInitialRequests
+ * @property {CountOfChunk} minChunks
+ * @property {CountOfRequest} maxAsyncRequests
+ * @property {CountOfRequest} maxInitialRequests
  * @property {boolean} hidePathInfo
- * @property {TemplatePath} filename
+ * @property {TemplatePath=} filename
  * @property {string} automaticNameDelimiter
  * @property {GetCacheGroups} getCacheGroups
- * @property {GetName} getName
+ * @property {GetNameFn} getName
  * @property {boolean} usedExports
  * @property {FallbackCacheGroup} fallbackCacheGroup
  */
 
+/** @typedef {Set<Chunk>} ChunkSet  */
+
 /**
  * @typedef {object} ChunksInfoItem
  * @property {SortableSet<Module>} modules
  * @property {CacheGroup} cacheGroup
  * @property {number} cacheGroupIndex
- * @property {string} name
- * @property {Record<string, number>} sizes
- * @property {Set<Chunk>} chunks
- * @property {Set<Chunk>} reusableChunks
+ * @property {string=} name
+ * @property {SplitChunksSizes} sizes
+ * @property {ChunkSet} chunks
+ * @property {ChunkSet} reusableChunks
  * @property {Set<bigint | Chunk>} chunksKeys
  */
 
-const defaultGetName = /** @type {GetName} */ (() => {});
+/** @type {GetNameFn} */
+const defaultGetName = () => undefined;
 
 const deterministicGroupingForModules =
-	/** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */
+	/** @type {(options: DeterministicGroupingOptionsForModule) => DeterministicGroupingGroupedItemsForModule[]} */
 	(deterministicGrouping);
 
 /** @type {WeakMap<Module, string>} */
@@ -190,9 +202,9 @@ const hashFilename = (name, outputOptions) => {
 
 /**
  * @param {Chunk} chunk the chunk
- * @returns {number} the number of requests
+ * @returns {CountOfRequest} the number of requests
  */
-const getRequests = chunk => {
+const getRequests = (chunk) => {
 	let requests = 0;
 	for (const chunkGroup of chunk.groupsIterable) {
 		requests = Math.max(requests, chunkGroup.chunks.length);
@@ -204,7 +216,7 @@ const getRequests = chunk => {
  * @template {object} T
  * @template {object} R
  * @param {T} obj obj an object
- * @param {function(T[keyof T], keyof T): T[keyof T]} fn fn
+ * @param {(obj: T[keyof T], key: keyof T) => T[keyof T]} fn fn
  * @returns {T} result
  */
 const mapObject = (obj, fn) => {
@@ -269,26 +281,26 @@ const compareEntries = (a, b) => {
  * @param {Chunk} chunk the chunk
  * @returns {boolean} true, if the chunk is an entry chunk
  */
-const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
+const INITIAL_CHUNK_FILTER = (chunk) => chunk.canBeInitial();
 /**
  * @param {Chunk} chunk the chunk
  * @returns {boolean} true, if the chunk is an async chunk
  */
-const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
+const ASYNC_CHUNK_FILTER = (chunk) => !chunk.canBeInitial();
 /**
- * @param {Chunk} chunk the chunk
+ * @param {Chunk} _chunk the chunk
  * @returns {boolean} always true
  */
-const ALL_CHUNK_FILTER = chunk => true;
+const ALL_CHUNK_FILTER = (_chunk) => true;
 
 /**
  * @param {OptimizationSplitChunksSizes | undefined} value the sizes
- * @param {string[]} defaultSizeTypes the default size types
+ * @param {DefaultSizeTypes} defaultSizeTypes the default size types
  * @returns {SplitChunksSizes} normalized representation
  */
 const normalizeSizes = (value, defaultSizeTypes) => {
 	if (typeof value === "number") {
-		/** @type {Record<string, number>} */
+		/** @type {SplitChunksSizes} */
 		const o = {};
 		for (const sizeType of defaultSizeTypes) o[sizeType] = value;
 		return o;
@@ -315,8 +327,8 @@ const mergeSizes = (...sizes) => {
  * @param {SplitChunksSizes} sizes the sizes
  * @returns {boolean} true, if there are sizes > 0
  */
-const hasNonZeroSizes = sizes => {
-	for (const key of Object.keys(sizes)) {
+const hasNonZeroSizes = (sizes) => {
+	for (const key of /** @type {SourceType[]} */ (Object.keys(sizes))) {
 		if (sizes[key] > 0) return true;
 	}
 	return false;
@@ -329,8 +341,8 @@ const hasNonZeroSizes = sizes => {
  * @returns {SplitChunksSizes} the combine sizes
  */
 const combineSizes = (a, b, combine) => {
-	const aKeys = new Set(Object.keys(a));
-	const bKeys = new Set(Object.keys(b));
+	const aKeys = /** @type {Set<SourceType>} */ (new Set(Object.keys(a)));
+	const bKeys = /** @type {Set<SourceType>} */ (new Set(Object.keys(b)));
 	/** @type {SplitChunksSizes} */
 	const result = {};
 	for (const key of aKeys) {
@@ -350,7 +362,7 @@ const combineSizes = (a, b, combine) => {
  * @returns {boolean} true if there are sizes and all existing sizes are at least `minSize`
  */
 const checkMinSize = (sizes, minSize) => {
-	for (const key of Object.keys(minSize)) {
+	for (const key of /** @type {SourceType[]} */ (Object.keys(minSize))) {
 		const size = sizes[key];
 		if (size === undefined || size === 0) continue;
 		if (size < minSize[key]) return false;
@@ -361,11 +373,13 @@ const checkMinSize = (sizes, minSize) => {
 /**
  * @param {SplitChunksSizes} sizes the sizes
  * @param {SplitChunksSizes} minSizeReduction the min sizes
- * @param {number} chunkCount number of chunks
+ * @param {CountOfChunk} 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)) {
+	for (const key of /** @type {SourceType[]} */ (
+		Object.keys(minSizeReduction)
+	)) {
 		const size = sizes[key];
 		if (size === undefined || size === 0) continue;
 		if (size * chunkCount < minSizeReduction[key]) return false;
@@ -376,11 +390,12 @@ const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
 /**
  * @param {SplitChunksSizes} sizes the sizes
  * @param {SplitChunksSizes} minSize the min sizes
- * @returns {undefined | string[]} list of size types that are below min size
+ * @returns {undefined | SourceTypes} list of size types that are below min size
  */
 const getViolatingMinSizes = (sizes, minSize) => {
+	/** @type {SourceTypes | undefined} */
 	let list;
-	for (const key of Object.keys(minSize)) {
+	for (const key of /** @type {SourceType[]} */ (Object.keys(minSize))) {
 		const size = sizes[key];
 		if (size === undefined || size === 0) continue;
 		if (size < minSize[key]) {
@@ -393,34 +408,34 @@ const getViolatingMinSizes = (sizes, minSize) => {
 
 /**
  * @param {SplitChunksSizes} sizes the sizes
- * @returns {number} the total size
+ * @returns {Size} the total size
  */
-const totalSize = sizes => {
+const totalSize = (sizes) => {
 	let size = 0;
-	for (const key of Object.keys(sizes)) {
+	for (const key of /** @type {SourceType[]} */ (Object.keys(sizes))) {
 		size += sizes[key];
 	}
 	return size;
 };
 
 /**
- * @param {false|string|Function|undefined} name the chunk name
- * @returns {GetName | undefined} 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
  */
-const normalizeName = name => {
+const normalizeName = (name) => {
 	if (typeof name === "string") {
 		return () => name;
 	}
 	if (typeof name === "function") {
-		return /** @type {GetName} */ (name);
+		return /** @type {GetNameFn} */ (name);
 	}
 };
 
 /**
  * @param {OptimizationSplitChunksCacheGroup["chunks"]} chunks the chunk filter option
- * @returns {ChunkFilterFunction} the chunk filter function
+ * @returns {ChunkFilterFn | undefined} the chunk filter function
  */
-const normalizeChunksFilter = chunks => {
+const normalizeChunksFilter = (chunks) => {
 	if (chunks === "initial") {
 		return INITIAL_CHUNK_FILTER;
 	}
@@ -431,7 +446,7 @@ const normalizeChunksFilter = chunks => {
 		return ALL_CHUNK_FILTER;
 	}
 	if (chunks instanceof RegExp) {
-		return chunk => (chunk.name ? chunks.test(chunk.name) : false);
+		return (chunk) => (chunk.name ? chunks.test(chunk.name) : false);
 	}
 	if (typeof chunks === "function") {
 		return chunks;
@@ -439,8 +454,8 @@ const normalizeChunksFilter = chunks => {
 };
 
 /**
- * @param {GetCacheGroups | Record<string, false|string|RegExp|OptimizationSplitChunksGetCacheGroups|OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
- * @param {string[]} defaultSizeTypes the default size types
+ * @param {undefined | GetCacheGroups | Record<string, false | string | RegExp | OptimizationSplitChunksGetCacheGroups | OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
+ * @param {DefaultSizeTypes} defaultSizeTypes the default size types
  * @returns {GetCacheGroups} a function to get the cache groups
  */
 const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
@@ -448,7 +463,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 		return cacheGroups;
 	}
 	if (typeof cacheGroups === "object" && cacheGroups !== null) {
-		/** @type {(function(Module, CacheGroupsContext, CacheGroupSource[]): void)[]} */
+		/** @type {((module: Module, context: CacheGroupsContext, results: CacheGroupSource[]) => void)[]} */
 		const handlers = [];
 		for (const key of Object.keys(cacheGroups)) {
 			const option = cacheGroups[key];
@@ -516,7 +531,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 };
 
 /**
- * @param {undefined|boolean|string|RegExp|Function} test test option
+ * @param {OptimizationSplitChunksCacheGroup["test"]} test test option
  * @param {Module} module the module
  * @param {CacheGroupsContext} context context object
  * @returns {boolean} true, if the module should be selected
@@ -529,17 +544,17 @@ const checkTest = (test, module, context) => {
 	if (typeof test === "boolean") return test;
 	if (typeof test === "string") {
 		const name = module.nameForCondition();
-		return name && name.startsWith(test);
+		return name ? name.startsWith(test) : false;
 	}
 	if (test instanceof RegExp) {
 		const name = module.nameForCondition();
-		return name && test.test(name);
+		return name ? test.test(name) : false;
 	}
 	return false;
 };
 
 /**
- * @param {undefined|string|RegExp|Function} test type option
+ * @param {OptimizationSplitChunksCacheGroup["type"]} test type option
  * @param {Module} module the module
  * @returns {boolean} true, if the module should be selected
  */
@@ -560,7 +575,7 @@ const checkModuleType = (test, module) => {
 };
 
 /**
- * @param {undefined|string|RegExp|Function} test type option
+ * @param {OptimizationSplitChunksCacheGroup["layer"]} test type option
  * @param {Module} module the module
  * @returns {boolean} true, if the module should be selected
  */
@@ -571,11 +586,11 @@ const checkModuleLayer = (test, module) => {
 	}
 	if (typeof test === "string") {
 		const layer = module.layer;
-		return test === "" ? !layer : layer && layer.startsWith(test);
+		return test === "" ? !layer : layer ? layer.startsWith(test) : false;
 	}
 	if (test instanceof RegExp) {
 		const layer = module.layer;
-		return test.test(layer);
+		return layer ? test.test(layer) : false;
 	}
 	return false;
 };
@@ -583,7 +598,7 @@ const checkModuleLayer = (test, module) => {
 /**
  * @param {OptimizationSplitChunksCacheGroup} options the group options
  * @param {string} key key of cache group
- * @param {string[]} defaultSizeTypes the default size types
+ * @param {DefaultSizeTypes} defaultSizeTypes the default size types
  * @returns {CacheGroupSource} the normalized cached group
  */
 const createCacheGroupSource = (options, key, defaultSizeTypes) => {
@@ -628,6 +643,8 @@ const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 	};
 };
 
+const PLUGIN_NAME = "SplitChunksPlugin";
+
 module.exports = class SplitChunksPlugin {
 	/**
 	 * @param {OptimizationSplitChunksOptions=} options plugin options
@@ -647,7 +664,9 @@ module.exports = class SplitChunksPlugin {
 
 		/** @type {SplitChunksOptions} */
 		this.options = {
-			chunksFilter: normalizeChunksFilter(options.chunks || "all"),
+			chunksFilter:
+				/** @type {ChunkFilterFn} */
+				(normalizeChunksFilter(options.chunks || "all")),
 			defaultSizeTypes,
 			minSize,
 			minSizeReduction,
@@ -676,13 +695,19 @@ module.exports = class SplitChunksPlugin {
 				options.cacheGroups,
 				defaultSizeTypes
 			),
-			getName: options.name ? normalizeName(options.name) : defaultGetName,
-			automaticNameDelimiter: options.automaticNameDelimiter,
-			usedExports: options.usedExports,
+			getName: options.name
+				? /** @type {GetNameFn} */ (normalizeName(options.name))
+				: defaultGetName,
+			automaticNameDelimiter: options.automaticNameDelimiter || "-",
+			usedExports: options.usedExports || false,
 			fallbackCacheGroup: {
-				chunksFilter: normalizeChunksFilter(
-					fallbackCacheGroup.chunks || options.chunks || "all"
-				),
+				chunksFilter:
+					/** @type {ChunkFilterFn} */
+					(
+						normalizeChunksFilter(
+							fallbackCacheGroup.chunks || options.chunks || "all"
+						)
+					),
 				minSize: mergeSizes(
 					normalizeSizes(fallbackCacheGroup.minSize, defaultSizeTypes),
 					minSize
@@ -733,6 +758,7 @@ module.exports = class SplitChunksPlugin {
 			cacheGroupSource.enforceSizeThreshold,
 			cacheGroupSource.enforce ? undefined : this.options.enforceSizeThreshold
 		);
+		/** @type {CacheGroup} */
 		const cacheGroup = {
 			key: cacheGroupSource.key,
 			priority: cacheGroupSource.priority || 0,
@@ -810,18 +836,18 @@ module.exports = class SplitChunksPlugin {
 			compiler.context,
 			compiler.root
 		);
-		compiler.hooks.thisCompilation.tap("SplitChunksPlugin", compilation => {
-			const logger = compilation.getLogger("webpack.SplitChunksPlugin");
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 			let alreadyOptimized = false;
-			compilation.hooks.unseal.tap("SplitChunksPlugin", () => {
+			compilation.hooks.unseal.tap(PLUGIN_NAME, () => {
 				alreadyOptimized = false;
 			});
 			compilation.hooks.optimizeChunks.tap(
 				{
-					name: "SplitChunksPlugin",
+					name: PLUGIN_NAME,
 					stage: STAGE_ADVANCED
 				},
-				chunks => {
+				(chunks) => {
 					if (alreadyOptimized) return;
 					alreadyOptimized = true;
 					logger.time("prepare");
@@ -839,13 +865,13 @@ module.exports = class SplitChunksPlugin {
 							chunk,
 							index | BigInt((Math.random() * 0x7fffffff) | 0)
 						);
-						index = index << ONE;
+						index <<= ONE;
 					}
 					/**
 					 * @param {Iterable<Chunk>} chunks list of chunks
 					 * @returns {bigint | Chunk} key of the chunks
 					 */
-					const getKey = chunks => {
+					const getKey = (chunks) => {
 						const iterator = chunks[Symbol.iterator]();
 						let result = iterator.next();
 						if (result.done) return ZERO;
@@ -853,10 +879,11 @@ module.exports = class SplitChunksPlugin {
 						result = iterator.next();
 						if (result.done) return first;
 						let key =
-							chunkIndexMap.get(first) | chunkIndexMap.get(result.value);
+							/** @type {bigint} */ (chunkIndexMap.get(first)) |
+							/** @type {bigint} */ (chunkIndexMap.get(result.value));
 						while (!(result = iterator.next()).done) {
 							const raw = chunkIndexMap.get(result.value);
-							key = key ^ raw;
+							key ^= /** @type {bigint} */ (raw);
 						}
 						return key;
 					};
@@ -864,15 +891,15 @@ module.exports = class SplitChunksPlugin {
 					 * @param {bigint | Chunk} key key of the chunks
 					 * @returns {string} stringified key
 					 */
-					const keyToString = key => {
+					const keyToString = (key) => {
 						if (typeof key === "bigint") return key.toString(16);
-						return chunkIndexMap.get(key).toString(16);
+						return /** @type {bigint} */ (chunkIndexMap.get(key)).toString(16);
 					};
 
 					const getChunkSetsInGraph = memoize(() => {
-						/** @type {Map<bigint, Set<Chunk>>} */
+						/** @type {Map<bigint, ChunkSet>} */
 						const chunkSetsInGraph = new Map();
-						/** @type {Set<Chunk>} */
+						/** @type {ChunkSet} */
 						const singleChunkSets = new Set();
 						for (const module of compilation.modules) {
 							const chunks = chunkGraph.getModuleChunksIterable(module);
@@ -892,7 +919,7 @@ module.exports = class SplitChunksPlugin {
 					 * @param {Module} module the module
 					 * @returns {Iterable<Chunk[]>} groups of chunks with equal exports
 					 */
-					const groupChunksByExports = module => {
+					const groupChunksByExports = (module) => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
 						const groupedByUsedExports = new Map();
 						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
@@ -910,19 +937,21 @@ module.exports = class SplitChunksPlugin {
 					/** @type {Map<Module, Iterable<Chunk[]>>} */
 					const groupedByExportsMap = new Map();
 
+					/** @typedef {Map<bigint | Chunk, ChunkSet>} ChunkSetsInGraph */
+
 					const getExportsChunkSetsInGraph = memoize(() => {
-						/** @type {Map<bigint, Set<Chunk>>} */
+						/** @type {ChunkSetsInGraph} */
 						const chunkSetsInGraph = new Map();
-						/** @type {Set<Chunk>} */
+						/** @type {ChunkSet} */
 						const singleChunkSets = new Set();
 						for (const module of compilation.modules) {
-							const groupedChunks = Array.from(groupChunksByExports(module));
+							const groupedChunks = [...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));
+									const chunksKey = getKey(chunks);
 									if (!chunkSetsInGraph.has(chunksKey)) {
 										chunkSetsInGraph.set(chunksKey, new Set(chunks));
 									}
@@ -932,15 +961,17 @@ module.exports = class SplitChunksPlugin {
 						return { chunkSetsInGraph, singleChunkSets };
 					});
 
+					/** @typedef {Map<CountOfChunk, ChunkSet[]>} ChunkSetsByCount */
+
 					// group these set of chunks by count
 					// to allow to check less sets via isSubset
 					// (only smaller sets can be subset)
 					/**
-					 * @param {IterableIterator<Set<Chunk>>} chunkSets set of sets of chunks
-					 * @returns {Map<number, Array<Set<Chunk>>>} map of sets of chunks by count
+					 * @param {IterableIterator<ChunkSet>} chunkSets set of sets of chunks
+					 * @returns {ChunkSetsByCount} map of sets of chunks by count
 					 */
-					const groupChunkSetsByCount = chunkSets => {
-						/** @type {Map<number, Array<Set<Chunk>>>} */
+					const groupChunkSetsByCount = (chunkSets) => {
+						/** @type {ChunkSetsByCount} */
 						const chunkSetsByCount = new Map();
 						for (const chunksSet of chunkSets) {
 							const count = chunksSet.size;
@@ -964,16 +995,24 @@ module.exports = class SplitChunksPlugin {
 						)
 					);
 
+					/** @typedef {(ChunkSet | Chunk)[]} Combinations */
+
 					// Create a list of possible 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
+					 */
 					const createGetCombinations = (
 						chunkSets,
 						singleChunkSets,
 						chunkSetsByCount
 					) => {
-						/** @type {Map<bigint | Chunk, (Set<Chunk> | Chunk)[]>} */
+						/** @type {Map<bigint | Chunk, Combinations>} */
 						const combinationsCache = new Map();
 
-						return key => {
+						return (key) => {
 							const cacheEntry = combinationsCache.get(key);
 							if (cacheEntry !== undefined) return cacheEntry;
 							if (key instanceof Chunk) {
@@ -981,8 +1020,10 @@ module.exports = class SplitChunksPlugin {
 								combinationsCache.set(key, result);
 								return result;
 							}
-							const chunksSet = chunkSets.get(key);
-							/** @type {(Set<Chunk> | Chunk)[]} */
+							const chunksSet =
+								/** @type {ChunkSet} */
+								(chunkSets.get(key));
+							/** @type {Combinations} */
 							const array = [chunksSet];
 							for (const [count, setArray] of chunkSetsByCount) {
 								// "equal" is not needed because they would have been merge in the first step
@@ -1012,7 +1053,12 @@ module.exports = class SplitChunksPlugin {
 							getChunkSetsByCount()
 						);
 					});
-					const getCombinations = key => getCombinationsFactory()(key);
+
+					/**
+					 * @param {bigint | Chunk} key key
+					 * @returns {Combinations} combinations by key
+					 */
+					const getCombinations = (key) => getCombinationsFactory()(key);
 
 					const getExportsCombinationsFactory = memoize(() => {
 						const { chunkSetsInGraph, singleChunkSets } =
@@ -1023,7 +1069,11 @@ module.exports = class SplitChunksPlugin {
 							getExportsChunkSetsByCount()
 						);
 					});
-					const getExportsCombinations = key =>
+					/**
+					 * @param {bigint | Chunk} key key
+					 * @returns {Combinations} exports combinations by key
+					 */
+					const getExportsCombinations = (key) =>
 						getExportsCombinationsFactory()(key);
 
 					/**
@@ -1032,14 +1082,14 @@ module.exports = class SplitChunksPlugin {
 					 * @property {bigint | Chunk} key a key of the list
 					 */
 
-					/** @type {WeakMap<Set<Chunk> | Chunk, WeakMap<ChunkFilterFunction, SelectedChunksResult>>} */
+					/** @type {WeakMap<ChunkSet | Chunk, WeakMap<ChunkFilterFn, SelectedChunksResult>>} */
 					const selectedChunksCacheByChunksSet = new WeakMap();
 
 					/**
 					 * get list and key by applying the filter function to the list
 					 * It is cached for performance reasons
-					 * @param {Set<Chunk> | Chunk} chunks list of chunks
-					 * @param {ChunkFilterFunction} chunkFilter filter function for chunks
+					 * @param {ChunkSet | Chunk} chunks list of chunks
+					 * @param {ChunkFilterFn} chunkFilter filter function for chunks
 					 * @returns {SelectedChunksResult} list and key
 					 */
 					const getSelectedChunks = (chunks, chunkFilter) => {
@@ -1098,11 +1148,12 @@ module.exports = class SplitChunksPlugin {
 						// Break if minimum number of chunks is not reached
 						if (selectedChunks.length < cacheGroup.minChunks) return;
 						// Determine name for split chunk
+
 						const name =
-							/** @type {string} */
-							(cacheGroup.getName(module, selectedChunks, cacheGroup.key));
+							/** @type {GetNameFn} */
+							(cacheGroup.getName)(module, selectedChunks, cacheGroup.key);
 						// Check if the name is ok
-						const existingChunk = compilation.namedChunks.get(name);
+						const existingChunk = name && compilation.namedChunks.get(name);
 						if (existingChunk) {
 							const parentValidationKey = `${name}|${
 								typeof selectedChunksKey === "bigint"
@@ -1140,7 +1191,7 @@ module.exports = class SplitChunksPlugin {
 										alreadyReportedErrors.add(name);
 										compilation.errors.push(
 											new WebpackError(
-												"SplitChunksPlugin\n" +
+												`${PLUGIN_NAME}\n` +
 													`Cache group "${cacheGroup.key}" conflicts with existing chunk.\n` +
 													`Both have the same name "${name}" and existing chunk is not a parent of the selected modules.\n` +
 													"Use a different name for the cache group or make sure that the existing chunk is a parent (e. g. via dependOn).\n" +
@@ -1167,7 +1218,7 @@ module.exports = class SplitChunksPlugin {
 								? ` name:${name}`
 								: ` chunks:${keyToString(selectedChunksKey)}`);
 						// Add module to maps
-						let info = /** @type {ChunksInfoItem} */ (chunksInfoMap.get(key));
+						let info = chunksInfoMap.get(key);
 						if (info === undefined) {
 							chunksInfoMap.set(
 								key,
@@ -1230,15 +1281,16 @@ module.exports = class SplitChunksPlugin {
 						const getCombsByUsedExports = memoize(() => {
 							// fill the groupedByExportsMap
 							getExportsChunkSetsInGraph();
-							/** @type {Set<Set<Chunk> | Chunk>} */
+							/** @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))
+								for (const comb of getExportsCombinations(chunksKey)) {
 									set.add(comb);
+								}
 							}
 							return set;
 						});
@@ -1260,7 +1312,8 @@ module.exports = class SplitChunksPlugin {
 								const { chunks: selectedChunks, key: selectedChunksKey } =
 									getSelectedChunks(
 										chunkCombination,
-										/** @type {ChunkFilterFunction} */ (cacheGroup.chunksFilter)
+										/** @type {ChunkFilterFn} */
+										(cacheGroup.chunksFilter)
 									);
 
 								addModuleToChunksInfoMap(
@@ -1281,12 +1334,12 @@ module.exports = class SplitChunksPlugin {
 
 					/**
 					 * @param {ChunksInfoItem} info entry
-					 * @param {string[]} sourceTypes source types to be removed
+					 * @param {SourceTypes} sourceTypes source types to be removed
 					 */
 					const removeModulesWithSourceType = (info, sourceTypes) => {
 						for (const module of info.modules) {
 							const types = module.getSourceTypes();
-							if (sourceTypes.some(type => types.has(type))) {
+							if (sourceTypes.some((type) => types.has(type))) {
 								info.modules.delete(module);
 								for (const type of types) {
 									info.sizes[type] -= module.size(type);
@@ -1299,7 +1352,7 @@ module.exports = class SplitChunksPlugin {
 					 * @param {ChunksInfoItem} info entry
 					 * @returns {boolean} true, if entry become empty
 					 */
-					const removeMinSizeViolatingModules = info => {
+					const removeMinSizeViolatingModules = (info) => {
 						if (!info.cacheGroup._validateSize) return false;
 						const violatingSizes = getViolatingMinSizes(
 							info.sizes,
@@ -1356,7 +1409,7 @@ module.exports = class SplitChunksPlugin {
 						const item = /** @type {ChunksInfoItem} */ (bestEntry);
 						chunksInfoMap.delete(/** @type {string} */ (bestEntryKey));
 
-						/** @type {Chunk["name"] | undefined} */
+						/** @type {ChunkName | undefined} */
 						let chunkName = item.name;
 						// Variable for the new chunk (lazy created)
 						/** @type {Chunk | undefined} */
@@ -1428,18 +1481,14 @@ module.exports = class SplitChunksPlugin {
 						) {
 							for (const chunk of usedChunks) {
 								// respect max requests
-								const maxRequests = /** @type {number} */ (
-									chunk.isOnlyInitial()
-										? item.cacheGroup.maxInitialRequests
-										: chunk.canBeInitial()
-											? Math.min(
-													/** @type {number} */
-													(item.cacheGroup.maxInitialRequests),
-													/** @type {number} */
-													(item.cacheGroup.maxAsyncRequests)
-												)
-											: item.cacheGroup.maxAsyncRequests
-								);
+								const maxRequests = chunk.isOnlyInitial()
+									? item.cacheGroup.maxInitialRequests
+									: chunk.canBeInitial()
+										? Math.min(
+												item.cacheGroup.maxInitialRequests,
+												item.cacheGroup.maxAsyncRequests
+											)
+										: item.cacheGroup.maxAsyncRequests;
 								if (
 									Number.isFinite(maxRequests) &&
 									getRequests(chunk) >= maxRequests
@@ -1459,13 +1508,11 @@ module.exports = class SplitChunksPlugin {
 						// 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)
+							if (isExistingChunk) {
 								usedChunks.add(/** @type {Chunk} */ (newChunk));
-							if (
-								/** @type {number} */ (usedChunks.size) >=
-								/** @type {number} */ (item.cacheGroup.minChunks)
-							) {
-								const chunksArr = Array.from(usedChunks);
+							}
+							if (usedChunks.size >= item.cacheGroup.minChunks) {
+								const chunksArr = [...usedChunks];
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
 										item.cacheGroup,
@@ -1591,7 +1638,7 @@ module.exports = class SplitChunksPlugin {
 									: item.cacheGroup.maxInitialSize,
 								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter,
 								keys: oldMaxSizeSettings
-									? oldMaxSizeSettings.keys.concat(item.cacheGroup.key)
+									? [...oldMaxSizeSettings.keys, item.cacheGroup.key]
 									: [item.cacheGroup.key]
 							});
 						}
@@ -1645,7 +1692,7 @@ module.exports = class SplitChunksPlugin {
 
 					// Make sure that maxSize is fulfilled
 					const { fallbackCacheGroup } = this.options;
-					for (const chunk of Array.from(compilation.chunks)) {
+					for (const chunk of compilation.chunks) {
 						const chunkConfig = maxSizeQueueMap.get(chunk);
 						const {
 							minSize,
@@ -1653,8 +1700,9 @@ module.exports = class SplitChunksPlugin {
 							maxInitialSize,
 							automaticNameDelimiter
 						} = chunkConfig || fallbackCacheGroup;
-						if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk))
+						if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk)) {
 							continue;
+						}
 						/** @type {SplitChunksSizes} */
 						let maxSize;
 						if (chunk.isOnlyInitial()) {
@@ -1667,7 +1715,9 @@ module.exports = class SplitChunksPlugin {
 						if (Object.keys(maxSize).length === 0) {
 							continue;
 						}
-						for (const key of Object.keys(maxSize)) {
+						for (const key of /** @type {SourceType[]} */ (
+							Object.keys(maxSize)
+						)) {
 							const maxSizeValue = maxSize[key];
 							const minSizeValue = minSize[key];
 							if (
@@ -1738,11 +1788,12 @@ module.exports = class SplitChunksPlugin {
 									hashFilename(name, outputOptions);
 							}
 							if (i !== results.length - 1) {
-								const newPart = compilation.addChunk(
-									/** @type {Chunk["name"]} */ (name)
-								);
+								const newPart = compilation.addChunk(name);
 								chunk.split(newPart);
 								newPart.chunkReason = chunk.chunkReason;
+								if (chunk.filenameTemplate) {
+									newPart.filenameTemplate = chunk.filenameTemplate;
+								}
 								// Add all modules to the new chunk
 								for (const module of group.items) {
 									if (!module.chunkCondition(newPart, compilation)) {
@@ -1755,7 +1806,7 @@ module.exports = class SplitChunksPlugin {
 								}
 							} else {
 								// change the chunk to be a part
-								chunk.name = /** @type {Chunk["name"]} */ (name);
+								chunk.name = name;
 							}
 						}
 					}