webpack 5.97.1 → 5.104.1

package/lib/ids/DeterministicModuleIdsPlugin.js

@@ -9,9 +9,9 @@ const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
 const {
-	getUsedModuleIdsAndModules,
+	assignDeterministicIds,
 	getFullModuleName,
-	assignDeterministicIds
+	getUsedModuleIdsAndModules
 } = require("./IdHelpers");
 
 /** @typedef {import("../Compiler")} Compiler */
@@ -20,16 +20,18 @@ const {
 /**
  * @typedef {object} DeterministicModuleIdsPluginOptions
  * @property {string=} context context relative to which module identifiers are computed
- * @property {function(Module): boolean=} test selector function for modules
+ * @property {((module: Module) => boolean)=} test selector function for modules
  * @property {number=} maxLength maximum id length in digits (used as starting point)
  * @property {number=} salt hash salt for ids
  * @property {boolean=} fixedLength do not increase the maxLength to find an optimal id space size
  * @property {boolean=} failOnConflict throw an error when id conflicts occur (instead of rehashing)
  */
 
+const PLUGIN_NAME = "DeterministicModuleIdsPlugin";
+
 class DeterministicModuleIdsPlugin {
 	/**
-	 * @param {DeterministicModuleIdsPluginOptions} [options] options
+	 * @param {DeterministicModuleIdsPluginOptions=} options options
 	 */
 	constructor(options = {}) {
 		this.options = options;
@@ -41,56 +43,54 @@ class DeterministicModuleIdsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DeterministicModuleIdsPlugin",
-			compilation => {
-				compilation.hooks.moduleIds.tap("DeterministicModuleIdsPlugin", () => {
-					const chunkGraph = compilation.chunkGraph;
-					const context = this.options.context
-						? this.options.context
-						: compiler.context;
-					const maxLength = this.options.maxLength || 3;
-					const failOnConflict = this.options.failOnConflict || false;
-					const fixedLength = this.options.fixedLength || false;
-					const salt = this.options.salt || 0;
-					let conflicts = 0;
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.moduleIds.tap(PLUGIN_NAME, () => {
+				const chunkGraph = compilation.chunkGraph;
+				const context = this.options.context
+					? this.options.context
+					: compiler.context;
+				const maxLength = this.options.maxLength || 3;
+				const failOnConflict = this.options.failOnConflict || false;
+				const fixedLength = this.options.fixedLength || false;
+				const salt = this.options.salt || 0;
+				let conflicts = 0;
 
-					const [usedIds, modules] = getUsedModuleIdsAndModules(
-						compilation,
-						this.options.test
-					);
-					assignDeterministicIds(
-						modules,
-						module => getFullModuleName(module, context, compiler.root),
-						failOnConflict
-							? () => 0
-							: compareModulesByPreOrderIndexOrIdentifier(
-									compilation.moduleGraph
-								),
-						(module, id) => {
-							const size = usedIds.size;
-							usedIds.add(`${id}`);
-							if (size === usedIds.size) {
-								conflicts++;
-								return false;
-							}
-							chunkGraph.setModuleId(module, id);
-							return true;
-						},
-						[10 ** maxLength],
-						fixedLength ? 0 : 10,
-						usedIds.size,
-						salt
+				const [usedIds, modules] = getUsedModuleIdsAndModules(
+					compilation,
+					this.options.test
+				);
+				assignDeterministicIds(
+					modules,
+					(module) => getFullModuleName(module, context, compiler.root),
+					failOnConflict
+						? () => 0
+						: compareModulesByPreOrderIndexOrIdentifier(
+								compilation.moduleGraph
+							),
+					(module, id) => {
+						const size = usedIds.size;
+						usedIds.add(`${id}`);
+						if (size === usedIds.size) {
+							conflicts++;
+							return false;
+						}
+						chunkGraph.setModuleId(module, id);
+						return true;
+					},
+					[10 ** maxLength],
+					fixedLength ? 0 : 10,
+					usedIds.size,
+					salt
+				);
+				if (failOnConflict && conflicts) {
+					throw new Error(
+						`Assigning deterministic module ids has lead to ${conflicts} conflict${
+							conflicts > 1 ? "s" : ""
+						}.\nIncrease the 'maxLength' to increase the id space and make conflicts less likely (recommended when there are many conflicts or application is expected to grow), or add an 'salt' number to try another hash starting value in the same id space (recommended when there is only a single conflict).`
 					);
-					if (failOnConflict && conflicts)
-						throw new Error(
-							`Assigning deterministic module ids has lead to ${conflicts} conflict${
-								conflicts > 1 ? "s" : ""
-							}.\nIncrease the 'maxLength' to increase the id space and make conflicts less likely (recommended when there are many conflicts or application is expected to grow), or add an 'salt' number to try another hash starting value in the same id space (recommended when there is only a single conflict).`
-						);
-				});
-			}
-		);
+				}
+			});
+		});
 	}
 }
 

package/lib/ids/HashedModuleIdsPlugin.js

@@ -5,28 +5,31 @@
 
 "use strict";
 
+const { DEFAULTS } = require("../config/defaults");
 const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
 const createSchemaValidation = require("../util/create-schema-validation");
 const createHash = require("../util/createHash");
 const {
-	getUsedModuleIdsAndModules,
-	getFullModuleName
+	getFullModuleName,
+	getUsedModuleIdsAndModules
 } = require("./IdHelpers");
 
-/** @typedef {import("../../declarations/plugins/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
+/** @typedef {import("../../declarations/plugins/ids/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
 /** @typedef {import("../Compiler")} Compiler */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/HashedModuleIdsPlugin.check.js"),
-	() => require("../../schemas/plugins/HashedModuleIdsPlugin.json"),
+	require("../../schemas/plugins/ids/HashedModuleIdsPlugin.check"),
+	() => require("../../schemas/plugins/ids/HashedModuleIdsPlugin.json"),
 	{
 		name: "Hashed Module Ids Plugin",
 		baseDataPath: "options"
 	}
 );
 
+const PLUGIN_NAME = "HashedModuleIdsPlugin";
+
 class HashedModuleIdsPlugin {
 	/**
 	 * @param {HashedModuleIdsPluginOptions=} options options object
@@ -34,10 +37,10 @@ class HashedModuleIdsPlugin {
 	constructor(options = {}) {
 		validate(options);
 
-		/** @type {HashedModuleIdsPluginOptions} */
+		/** @type {Required<Omit<HashedModuleIdsPluginOptions, "context">> & { context?: string | undefined }} */
 		this.options = {
 			context: undefined,
-			hashFunction: "md4",
+			hashFunction: DEFAULTS.HASH_FUNCTION,
 			hashDigest: "base64",
 			hashDigestLength: 4,
 			...options
@@ -51,8 +54,8 @@ class HashedModuleIdsPlugin {
 	 */
 	apply(compiler) {
 		const options = this.options;
-		compiler.hooks.compilation.tap("HashedModuleIdsPlugin", compilation => {
-			compilation.hooks.moduleIds.tap("HashedModuleIdsPlugin", () => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.moduleIds.tap(PLUGIN_NAME, () => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.options.context
 					? this.options.context
@@ -70,12 +73,11 @@ class HashedModuleIdsPlugin {
 						)
 					);
 					hash.update(ident || "");
-					const hashId = /** @type {string} */ (
-						hash.digest(options.hashDigest)
-					);
+					const hashId = hash.digest(options.hashDigest);
 					let len = options.hashDigestLength;
-					while (usedIds.has(hashId.slice(0, len)))
+					while (usedIds.has(hashId.slice(0, len))) {
 						/** @type {number} */ (len)++;
+					}
 					const moduleId = hashId.slice(0, len);
 					chunkGraph.setModuleId(module, moduleId);
 					usedIds.add(moduleId);

package/lib/ids/IdHelpers.js

@@ -14,6 +14,8 @@ const numberHash = require("../util/numberHash");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 
 /**
  * @param {string} str string to hash
@@ -24,7 +26,7 @@ const numberHash = require("../util/numberHash");
 const getHash = (str, len, hashFunction) => {
 	const hash = createHash(hashFunction);
 	hash.update(str);
-	const digest = /** @type {string} */ (hash.digest("hex"));
+	const digest = hash.digest("hex");
 	return digest.slice(0, len);
 };
 
@@ -32,7 +34,7 @@ const getHash = (str, len, hashFunction) => {
  * @param {string} str the string
  * @returns {string} string prefixed by an underscore if it is a number
  */
-const avoidNumber = str => {
+const avoidNumber = (str) => {
 	// max length of a number is 21 chars, bigger numbers a written as "...e+xx"
 	if (str.length > 21) return str;
 	const firstChar = str.charCodeAt(0);
@@ -53,9 +55,8 @@ const avoidNumber = str => {
  * @param {string} request the request
  * @returns {string} id representation
  */
-const requestToId = request =>
+const requestToId = (request) =>
 	request.replace(/^(\.\.?\/)+/, "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
-module.exports.requestToId = requestToId;
 
 /**
  * @param {string} string the string
@@ -75,27 +76,27 @@ const shortenLongString = (string, delimiter, hashFunction) => {
 /**
  * @param {Module} module the module
  * @param {string} context context directory
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short module name
  */
 const getShortModuleName = (module, context, associatedObjectForCache) => {
 	const libIdent = module.libIdent({ context, associatedObjectForCache });
 	if (libIdent) return avoidNumber(libIdent);
 	const nameForCondition = module.nameForCondition();
-	if (nameForCondition)
+	if (nameForCondition) {
 		return avoidNumber(
 			makePathsRelative(context, nameForCondition, associatedObjectForCache)
 		);
+	}
 	return "";
 };
-module.exports.getShortModuleName = getShortModuleName;
 
 /**
  * @param {string} shortName the short name
  * @param {Module} module the module
  * @param {string} context context directory
  * @param {string | Hash} hashFunction hash function to use
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} long module name
  */
 const getLongModuleName = (
@@ -108,17 +109,15 @@ const getLongModuleName = (
 	const fullName = getFullModuleName(module, context, associatedObjectForCache);
 	return `${shortName}?${getHash(fullName, 4, hashFunction)}`;
 };
-module.exports.getLongModuleName = getLongModuleName;
 
 /**
  * @param {Module} module the module
  * @param {string} context context directory
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} full module name
  */
 const getFullModuleName = (module, context, associatedObjectForCache) =>
 	makePathsRelative(context, module.identifier(), associatedObjectForCache);
-module.exports.getFullModuleName = getFullModuleName;
 
 /**
  * @param {Chunk} chunk the chunk
@@ -126,7 +125,7 @@ module.exports.getFullModuleName = getFullModuleName;
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
  * @param {string | Hash} hashFunction hash function to use
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
 const getShortChunkName = (
@@ -138,17 +137,15 @@ const getShortChunkName = (
 	associatedObjectForCache
 ) => {
 	const modules = chunkGraph.getChunkRootModules(chunk);
-	const shortModuleNames = modules.map(m =>
+	const shortModuleNames = modules.map((m) =>
 		requestToId(getShortModuleName(m, context, associatedObjectForCache))
 	);
 	chunk.idNameHints.sort();
-	const chunkName = Array.from(chunk.idNameHints)
-		.concat(shortModuleNames)
+	const chunkName = [...chunk.idNameHints, ...shortModuleNames]
 		.filter(Boolean)
 		.join(delimiter);
 	return shortenLongString(chunkName, delimiter, hashFunction);
 };
-module.exports.getShortChunkName = getShortChunkName;
 
 /**
  * @param {Chunk} chunk the chunk
@@ -156,7 +153,7 @@ module.exports.getShortChunkName = getShortChunkName;
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
  * @param {string | Hash} hashFunction hash function to use
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
 const getLongChunkName = (
@@ -168,28 +165,30 @@ const getLongChunkName = (
 	associatedObjectForCache
 ) => {
 	const modules = chunkGraph.getChunkRootModules(chunk);
-	const shortModuleNames = modules.map(m =>
+	const shortModuleNames = modules.map((m) =>
 		requestToId(getShortModuleName(m, context, associatedObjectForCache))
 	);
-	const longModuleNames = modules.map(m =>
+	const longModuleNames = modules.map((m) =>
 		requestToId(
 			getLongModuleName("", m, context, hashFunction, associatedObjectForCache)
 		)
 	);
 	chunk.idNameHints.sort();
-	const chunkName = Array.from(chunk.idNameHints)
-		.concat(shortModuleNames, longModuleNames)
+	const chunkName = [
+		...chunk.idNameHints,
+		...shortModuleNames,
+		...longModuleNames
+	]
 		.filter(Boolean)
 		.join(delimiter);
 	return shortenLongString(chunkName, delimiter, hashFunction);
 };
-module.exports.getLongChunkName = getLongChunkName;
 
 /**
  * @param {Chunk} chunk the chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {string} context context directory
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} full chunk name
  */
 const getFullChunkName = (
@@ -200,12 +199,11 @@ const getFullChunkName = (
 ) => {
 	if (chunk.name) return chunk.name;
 	const modules = chunkGraph.getChunkRootModules(chunk);
-	const fullModuleNames = modules.map(m =>
+	const fullModuleNames = modules.map((m) =>
 		makePathsRelative(context, m.identifier(), associatedObjectForCache)
 	);
 	return fullModuleNames.join();
 };
-module.exports.getFullChunkName = getFullChunkName;
 
 /**
  * @template K
@@ -224,17 +222,19 @@ const addToMapOfItems = (map, key, value) => {
 	array.push(value);
 };
 
+/** @typedef {Set<string>} UsedModuleIds */
+
 /**
  * @param {Compilation} compilation the compilation
- * @param {function(Module): boolean=} filter filter modules
- * @returns {[Set<string>, Module[]]} used module ids as strings and modules without id matching the filter
+ * @param {((module: Module) => boolean)=} filter filter modules
+ * @returns {[UsedModuleIds, Module[]]} used module ids as strings and modules without id matching the filter
  */
 const getUsedModuleIdsAndModules = (compilation, filter) => {
 	const chunkGraph = compilation.chunkGraph;
 
 	const modules = [];
 
-	/** @type {Set<string>} */
+	/** @type {UsedModuleIds} */
 	const usedIds = new Set();
 	if (compilation.usedModuleIds) {
 		for (const id of compilation.usedModuleIds) {
@@ -249,7 +249,9 @@ const getUsedModuleIdsAndModules = (compilation, filter) => {
 			usedIds.add(String(moduleId));
 		} else if (
 			(!filter || filter(module)) &&
-			chunkGraph.getNumberOfModuleChunks(module) !== 0
+			(chunkGraph.getNumberOfModuleChunks(module) !== 0 ||
+				// CSS modules need IDs even when not in chunks, for generating CSS class names(i.e. [id]-[local])
+				/** @type {BuildMeta} */ (module.buildMeta).isCSSModule)
 		) {
 			modules.push(module);
 		}
@@ -257,14 +259,15 @@ const getUsedModuleIdsAndModules = (compilation, filter) => {
 
 	return [usedIds, modules];
 };
-module.exports.getUsedModuleIdsAndModules = getUsedModuleIdsAndModules;
+
+/** @typedef {Set<string>} UsedChunkIds */
 
 /**
  * @param {Compilation} compilation the compilation
- * @returns {Set<string>} used chunk ids as strings
+ * @returns {UsedChunkIds} used chunk ids as strings
  */
-const getUsedChunkIds = compilation => {
-	/** @type {Set<string>} */
+const getUsedChunkIds = (compilation) => {
+	/** @type {UsedChunkIds} */
 	const usedIds = new Set();
 	if (compilation.usedChunkIds) {
 		for (const id of compilation.usedChunkIds) {
@@ -281,16 +284,15 @@ const getUsedChunkIds = compilation => {
 
 	return usedIds;
 };
-module.exports.getUsedChunkIds = getUsedChunkIds;
 
 /**
  * @template T
  * @param {Iterable<T>} items list of items to be named
- * @param {function(T): string} getShortName get a short name for an item
- * @param {function(T, string): string} getLongName get a long name for an item
- * @param {function(T, T): -1|0|1} comparator order of items
+ * @param {(item: T) => string} getShortName get a short name for an item
+ * @param {(item: T, name: string) => string} getLongName get a long name for an item
+ * @param {(a: T, b: T) => -1 | 0 | 1} comparator order of items
  * @param {Set<string>} usedIds already used ids, will not be assigned
- * @param {function(T, string): void} assignName assign a name to an item
+ * @param {(item: T, name: string) => void} assignName assign a name to an item
  * @returns {T[]} list of items without a name
  */
 const assignNames = (
@@ -301,7 +303,12 @@ const assignNames = (
 	usedIds,
 	assignName
 ) => {
-	/** @type {Map<string, T[]>} */
+	/**
+	 * @template T
+	 * @typedef {Map<string, T[]>} MapToItem
+	 */
+
+	/** @type {MapToItem<T>} */
 	const nameToItems = new Map();
 
 	for (const item of items) {
@@ -309,7 +316,7 @@ const assignNames = (
 		addToMapOfItems(nameToItems, name, item);
 	}
 
-	/** @type {Map<string, T[]>} */
+	/** @type {MapToItem<T>} */
 	const nameToItems2 = new Map();
 
 	for (const [name, items] of nameToItems) {
@@ -349,14 +356,13 @@ const assignNames = (
 	unnamedItems.sort(comparator);
 	return unnamedItems;
 };
-module.exports.assignNames = assignNames;
 
 /**
  * @template T
  * @param {T[]} items list of items to be named
- * @param {function(T): string} getName get a name for an item
- * @param {function(T, T): -1|0|1} comparator order of items
- * @param {function(T, number): boolean} assignId assign an id to an item
+ * @param {(item: T) => string} getName get a name for an item
+ * @param {(a: T, n: T) => -1 | 0 | 1} comparator order of items
+ * @param {(item: T, id: number) => boolean} assignId assign an id to an item
  * @param {number[]} ranges usable ranges for ids
  * @param {number} expandFactor factor to create more ranges
  * @param {number} extraSpace extra space to allocate, i. e. when some ids are already used
@@ -403,10 +409,9 @@ const assignDeterministicIds = (
 		} while (!assignId(item, id));
 	}
 };
-module.exports.assignDeterministicIds = assignDeterministicIds;
 
 /**
- * @param {Set<string>} usedIds used ids
+ * @param {UsedModuleIds} usedIds used ids
  * @param {Iterable<Module>} modules the modules
  * @param {Compilation} compilation the compilation
  * @returns {void}
@@ -420,7 +425,7 @@ const assignAscendingModuleIds = (usedIds, modules, compilation) => {
 		/**
 		 * @param {Module} module the module
 		 */
-		assignId = module => {
+		assignId = (module) => {
 			if (chunkGraph.getModuleId(module) === null) {
 				while (usedIds.has(String(nextId))) nextId++;
 				chunkGraph.setModuleId(module, nextId++);
@@ -430,7 +435,7 @@ const assignAscendingModuleIds = (usedIds, modules, compilation) => {
 		/**
 		 * @param {Module} module the module
 		 */
-		assignId = module => {
+		assignId = (module) => {
 			if (chunkGraph.getModuleId(module) === null) {
 				chunkGraph.setModuleId(module, nextId++);
 			}
@@ -440,7 +445,6 @@ const assignAscendingModuleIds = (usedIds, modules, compilation) => {
 		assignId(module);
 	}
 };
-module.exports.assignAscendingModuleIds = assignAscendingModuleIds;
 
 /**
  * @param {Iterable<Chunk>} chunks the chunks
@@ -470,4 +474,17 @@ const assignAscendingChunkIds = (chunks, compilation) => {
 		}
 	}
 };
+
 module.exports.assignAscendingChunkIds = assignAscendingChunkIds;
+module.exports.assignAscendingModuleIds = assignAscendingModuleIds;
+module.exports.assignDeterministicIds = assignDeterministicIds;
+module.exports.assignNames = assignNames;
+module.exports.getFullChunkName = getFullChunkName;
+module.exports.getFullModuleName = getFullModuleName;
+module.exports.getLongChunkName = getLongChunkName;
+module.exports.getLongModuleName = getLongModuleName;
+module.exports.getShortChunkName = getShortChunkName;
+module.exports.getShortModuleName = getShortModuleName;
+module.exports.getUsedChunkIds = getUsedChunkIds;
+module.exports.getUsedModuleIdsAndModules = getUsedModuleIdsAndModules;
+module.exports.requestToId = requestToId;

package/lib/ids/NamedChunkIdsPlugin.js

@@ -7,24 +7,23 @@
 
 const { compareChunksNatural } = require("../util/comparators");
 const {
-	getShortChunkName,
-	getLongChunkName,
+	assignAscendingChunkIds,
 	assignNames,
-	getUsedChunkIds,
-	assignAscendingChunkIds
+	getLongChunkName,
+	getShortChunkName,
+	getUsedChunkIds
 } = require("./IdHelpers");
 
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
-/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
 
 /**
  * @typedef {object} NamedChunkIdsPluginOptions
- * @property {string} [context] context
- * @property {string} [delimiter] delimiter
+ * @property {string=} context context
+ * @property {string=} delimiter delimiter
  */
 
+const PLUGIN_NAME = "NamedChunkIdsPlugin";
+
 class NamedChunkIdsPlugin {
 	/**
 	 * @param {NamedChunkIdsPluginOptions=} options options
@@ -40,24 +39,22 @@ class NamedChunkIdsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("NamedChunkIdsPlugin", compilation => {
-			const hashFunction =
-				/** @type {NonNullable<Output["hashFunction"]>} */
-				(compilation.outputOptions.hashFunction);
-			compilation.hooks.chunkIds.tap("NamedChunkIdsPlugin", chunks => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			const hashFunction = compilation.outputOptions.hashFunction;
+			compilation.hooks.chunkIds.tap(PLUGIN_NAME, (chunks) => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.context ? this.context : compiler.context;
 				const delimiter = this.delimiter;
 
 				const unnamedChunks = assignNames(
-					Array.from(chunks).filter(chunk => {
+					[...chunks].filter((chunk) => {
 						if (chunk.name) {
 							chunk.id = chunk.name;
 							chunk.ids = [chunk.name];
 						}
 						return chunk.id === null;
 					}),
-					chunk =>
+					(chunk) =>
 						getShortChunkName(
 							chunk,
 							chunkGraph,
@@ -66,7 +63,7 @@ class NamedChunkIdsPlugin {
 							hashFunction,
 							compiler.root
 						),
-					chunk =>
+					(chunk) =>
 						getLongChunkName(
 							chunk,
 							chunkGraph,