webpack 5.59.0 → 5.94.0

package/lib/hmr/LazyCompilationPlugin.js

@@ -10,6 +10,9 @@ const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Dependency = require("../Dependency");
 const Module = require("../Module");
 const ModuleFactory = require("../ModuleFactory");
+const {
+	WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const CommonJsRequireDependency = require("../dependencies/CommonJsRequireDependency");
@@ -24,15 +27,25 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
 /** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../dependencies/HarmonyImportDependency")} HarmonyImportDependency */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
-const IGNORED_DEPENDENCY_TYPES = new Set([
+/** @typedef {{ client: string, data: string, active: boolean }} ModuleResult */
+
+/**
+ * @typedef {object} BackendApi
+ * @property {function(function((Error | null)=) : void): void} dispose
+ * @property {function(Module): ModuleResult} module
+ */
+
+const HMR_DEPENDENCY_TYPES = new Set([
 	"import.meta.webpackHot.accept",
 	"import.meta.webpackHot.decline",
 	"module.hot.accept",
@@ -42,7 +55,7 @@ const IGNORED_DEPENDENCY_TYPES = new Set([
 /**
  * @param {undefined|string|RegExp|Function} test test option
  * @param {Module} module the module
- * @returns {boolean} true, if the module should be selected
+ * @returns {boolean | null | string} true, if the module should be selected
  */
 const checkTest = (test, module) => {
 	if (test === undefined) return true;
@@ -63,6 +76,9 @@ const checkTest = (test, module) => {
 const TYPES = new Set(["javascript"]);
 
 class LazyCompilationDependency extends Dependency {
+	/**
+	 * @param {LazyCompilationProxyModule} proxyModule proxy module
+	 */
 	constructor(proxyModule) {
 		super();
 		this.proxyModule = proxyModule;
@@ -87,8 +103,20 @@ class LazyCompilationDependency extends Dependency {
 registerNotSerializable(LazyCompilationDependency);
 
 class LazyCompilationProxyModule extends Module {
+	/**
+	 * @param {string} context context
+	 * @param {Module} originalModule an original module
+	 * @param {string} request request
+	 * @param {ModuleResult["client"]} client client
+	 * @param {ModuleResult["data"]} data data
+	 * @param {ModuleResult["active"]} active true when active, otherwise false
+	 */
 	constructor(context, originalModule, request, client, data, active) {
-		super("lazy-compilation-proxy", context, originalModule.layer);
+		super(
+			WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY,
+			context,
+			originalModule.layer
+		);
 		this.originalModule = originalModule;
 		this.request = request;
 		this.client = client;
@@ -100,7 +128,7 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
-		return `lazy-compilation-proxy|${this.originalModule.identifier()}`;
+		return `${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY}|${this.originalModule.identifier()}`;
 	}
 
 	/**
@@ -108,7 +136,7 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {string} a user readable identifier of the module
 	 */
 	readableIdentifier(requestShortener) {
-		return `lazy-compilation-proxy ${this.originalModule.readableIdentifier(
+		return `${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY} ${this.originalModule.readableIdentifier(
 			requestShortener
 		)}`;
 	}
@@ -135,12 +163,14 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {string | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
-		return `${this.originalModule.libIdent(options)}!lazy-compilation-proxy`;
+		return `${this.originalModule.libIdent(
+			options
+		)}!${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY}`;
 	}
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function(WebpackError=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -174,7 +204,7 @@ class LazyCompilationProxyModule extends Module {
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
 		return TYPES;
@@ -212,13 +242,13 @@ class LazyCompilationProxyModule extends Module {
 		]);
 		const keepActive = Template.asString([
 			`var dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
-				!!block
+				Boolean(block)
 			)}, module: module, onError: onError });`
 		]);
 		let source;
 		if (block) {
 			const dep = block.dependencies[0];
-			const module = moduleGraph.getModule(dep);
+			const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 			source = Template.asString([
 				client,
 				`module.exports = ${runtimeTemplate.moduleNamespacePromise({
@@ -247,7 +277,7 @@ class LazyCompilationProxyModule extends Module {
 			source = Template.asString([
 				client,
 				"var resolveSelf, onError;",
-				`module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });`,
+				"module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });",
 				"if (module.hot) {",
 				Template.indent([
 					"module.hot.accept();",
@@ -280,14 +310,13 @@ class LazyCompilationProxyModule extends Module {
 registerNotSerializable(LazyCompilationProxyModule);
 
 class LazyCompilationDependencyFactory extends ModuleFactory {
-	constructor(factory) {
+	constructor() {
 		super();
-		this._factory = factory;
 	}
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {
@@ -302,34 +331,34 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 
 class LazyCompilationPlugin {
 	/**
-	 * @param {Object} options options
-	 * @param {(function(Compiler, string, function(Error?, any?): void): void) | function(Compiler, string): Promise<any>} options.backend the backend
-	 * @param {string} options.client the client reference
+	 * @param {object} options options
+	 * @param {(function(Compiler, function(Error=, BackendApi?): void): void) | function(Compiler): Promise<BackendApi>} options.backend the backend
 	 * @param {boolean} options.entries true, when entries are lazy compiled
 	 * @param {boolean} options.imports true, when import() modules are lazy compiled
-	 * @param {RegExp | string | (function(Module): boolean)} options.test additional filter for lazy compiled entrypoint modules
+	 * @param {RegExp | string | (function(Module): boolean) | undefined} options.test additional filter for lazy compiled entrypoint modules
 	 */
-	constructor({ backend, client, entries, imports, test }) {
+	constructor({ backend, entries, imports, test }) {
 		this.backend = backend;
-		this.client = client;
 		this.entries = entries;
 		this.imports = imports;
 		this.test = test;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		/** @type {BackendApi} */
 		let backend;
 		compiler.hooks.beforeCompile.tapAsync(
 			"LazyCompilationPlugin",
 			(params, callback) => {
 				if (backend !== undefined) return callback();
-				const promise = this.backend(compiler, this.client, (err, result) => {
+				const promise = this.backend(compiler, (err, result) => {
 					if (err) return callback(err);
-					backend = result;
+					backend = /** @type {BackendApi} */ (result);
 					callback();
 				});
 				if (promise && promise.then) {
@@ -347,32 +376,56 @@ class LazyCompilationPlugin {
 					"LazyCompilationPlugin",
 					(originalModule, createData, resolveData) => {
 						if (
-							resolveData.dependencies.every(
+							resolveData.dependencies.every(dep =>
+								HMR_DEPENDENCY_TYPES.has(dep.type)
+							)
+						) {
+							// for HMR only resolving, try to determine if the HMR accept/decline refers to
+							// an import() or not
+							const hmrDep = resolveData.dependencies[0];
+							const originModule =
+								/** @type {Module} */
+								(compilation.moduleGraph.getParentModule(hmrDep));
+							const isReferringToDynamicImport = originModule.blocks.some(
+								block =>
+									block.dependencies.some(
+										dep =>
+											dep.type === "import()" &&
+											/** @type {HarmonyImportDependency} */ (dep).request ===
+												hmrDep.request
+									)
+							);
+							if (!isReferringToDynamicImport) return;
+						} else if (
+							!resolveData.dependencies.every(
 								dep =>
-									IGNORED_DEPENDENCY_TYPES.has(dep.type) ||
+									HMR_DEPENDENCY_TYPES.has(dep.type) ||
 									(this.imports &&
 										(dep.type === "import()" ||
 											dep.type === "import() context element")) ||
 									(this.entries && dep.type === "entry")
-							) &&
-							!/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client/.test(
+							)
+						)
+							return;
+						if (
+							/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test(
 								resolveData.request
-							) &&
-							checkTest(this.test, originalModule)
-						) {
-							const moduleInfo = backend.module(originalModule);
-							if (!moduleInfo) return;
-							const { client, data, active } = moduleInfo;
+							) ||
+							!checkTest(this.test, originalModule)
+						)
+							return;
+						const moduleInfo = backend.module(originalModule);
+						if (!moduleInfo) return;
+						const { client, data, active } = moduleInfo;
 
-							return new LazyCompilationProxyModule(
-								compiler.context,
-								originalModule,
-								resolveData.request,
-								client,
-								data,
-								active
-							);
-						}
+						return new LazyCompilationProxyModule(
+							compiler.context,
+							originalModule,
+							resolveData.request,
+							client,
+							data,
+							active
+						);
 					}
 				);
 				compilation.dependencyFactories.set(

package/lib/hmr/lazyCompilationBackend.js

@@ -5,22 +5,66 @@
 
 "use strict";
 
-const http = require("http");
-
+/** @typedef {import("http").IncomingMessage} IncomingMessage */
+/** @typedef {import("http").RequestListener} RequestListener */
+/** @typedef {import("http").ServerOptions} HttpServerOptions */
+/** @typedef {import("http").ServerResponse} ServerResponse */
+/** @typedef {import("https").ServerOptions} HttpsServerOptions */
+/** @typedef {import("net").AddressInfo} AddressInfo */
+/** @typedef {import("net").Server} Server */
+/** @typedef {import("../../declarations/WebpackOptions").LazyCompilationDefaultBackendOptions} LazyCompilationDefaultBackendOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("./LazyCompilationPlugin").BackendApi} BackendApi */
 
 /**
+ * @callback BackendHandler
  * @param {Compiler} compiler compiler
- * @param {string} client client reference
- * @param {function(Error?, any?): void} callback callback
+ * @param {function(Error | null, BackendApi=): void} callback callback
  * @returns {void}
  */
-module.exports = (compiler, client, callback) => {
+
+/**
+ * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
+ * @returns {BackendHandler} backend
+ */
+module.exports = options => (compiler, callback) => {
 	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
 	const activeModules = new Map();
 	const prefix = "/lazy-compilation-using-";
 
+	const isHttps =
+		options.protocol === "https" ||
+		(typeof options.server === "object" &&
+			("key" in options.server || "pfx" in options.server));
+
+	const createServer =
+		typeof options.server === "function"
+			? options.server
+			: (() => {
+					const http = isHttps ? require("https") : require("http");
+					return http.createServer.bind(
+						http,
+						/** @type {HttpServerOptions | HttpsServerOptions} */
+						(options.server)
+					);
+				})();
+	/** @type {function(Server): void} */
+	const listen =
+		typeof options.listen === "function"
+			? options.listen
+			: server => {
+					let listen = options.listen;
+					if (typeof listen === "object" && !("port" in listen))
+						listen = { ...listen, port: undefined };
+					server.listen(listen);
+				};
+
+	const protocol = options.protocol || (isHttps ? "https" : "http");
+
+	/** @type {RequestListener} */
 	const requestListener = (req, res) => {
+		if (req.url === undefined) return;
 		const keys = req.url.slice(prefix.length).split("@");
 		req.socket.on("close", () => {
 			setTimeout(() => {
@@ -38,7 +82,9 @@ module.exports = (compiler, client, callback) => {
 		req.socket.setNoDelay(true);
 		res.writeHead(200, {
 			"content-type": "text/event-stream",
-			"Access-Control-Allow-Origin": "*"
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Allow-Methods": "*",
+			"Access-Control-Allow-Headers": "*"
 		});
 		res.write("\n");
 		let moduleActivated = false;
@@ -52,7 +98,10 @@ module.exports = (compiler, client, callback) => {
 		}
 		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
 	};
-	const server = http.createServer(requestListener);
+
+	const server = /** @type {Server} */ (createServer());
+	server.on("request", requestListener);
+
 	let isClosing = false;
 	/** @type {Set<import("net").Socket>} */
 	const sockets = new Set();
@@ -63,42 +112,56 @@ module.exports = (compiler, client, callback) => {
 		});
 		if (isClosing) socket.destroy();
 	});
-	server.listen(err => {
-		if (err) return callback(err);
-		const addr = server.address();
-		if (typeof addr === "string") throw new Error("addr must not be a string");
-		const urlBase =
-			addr.address === "::" || addr.address === "0.0.0.0"
-				? `http://localhost:${addr.port}`
-				: addr.family === "IPv6"
-				? `http://[${addr.address}]:${addr.port}`
-				: `http://${addr.address}:${addr.port}`;
-		logger.log(
-			`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
-		);
-		callback(null, {
-			dispose(callback) {
-				isClosing = true;
-				// Removing the listener is a workaround for a memory leak in node.js
-				server.off("request", requestListener);
-				server.close(err => {
-					callback(err);
-				});
-				for (const socket of sockets) {
-					socket.destroy(new Error("Server is disposing"));
-				}
-			},
-			module(originalModule) {
-				const key = `${encodeURIComponent(
-					originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
-				).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
-				const active = activeModules.get(key) > 0;
-				return {
-					client: `${client}?${encodeURIComponent(urlBase + prefix)}`,
-					data: key,
-					active
-				};
-			}
-		});
+	server.on("clientError", e => {
+		if (e.message !== "Server is disposing") logger.warn(e);
 	});
+
+	server.on(
+		"listening",
+		/**
+		 * @param {Error} err error
+		 * @returns {void}
+		 */
+		err => {
+			if (err) return callback(err);
+			const _addr = server.address();
+			if (typeof _addr === "string")
+				throw new Error("addr must not be a string");
+			const addr = /** @type {AddressInfo} */ (_addr);
+			const urlBase =
+				addr.address === "::" || addr.address === "0.0.0.0"
+					? `${protocol}://localhost:${addr.port}`
+					: addr.family === "IPv6"
+						? `${protocol}://[${addr.address}]:${addr.port}`
+						: `${protocol}://${addr.address}:${addr.port}`;
+			logger.log(
+				`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
+			);
+			callback(null, {
+				dispose(callback) {
+					isClosing = true;
+					// Removing the listener is a workaround for a memory leak in node.js
+					server.off("request", requestListener);
+					server.close(err => {
+						callback(err);
+					});
+					for (const socket of sockets) {
+						socket.destroy(new Error("Server is disposing"));
+					}
+				},
+				module(originalModule) {
+					const key = `${encodeURIComponent(
+						originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
+					).replace(/%(2F|3A|24|26|2B|2C|3B|3D)/g, decodeURIComponent)}`;
+					const active = activeModules.get(key) > 0;
+					return {
+						client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
+						data: key,
+						active
+					};
+				}
+			});
+		}
+	);
+	listen(server);
 };

package/lib/ids/ChunkModuleIdRangePlugin.js

@@ -13,7 +13,18 @@ const {
 
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * @typedef {object} ChunkModuleIdRangePluginOptions
+ * @property {string} name the chunk name
+ * @property {("index" | "index2" | "preOrderIndex" | "postOrderIndex")=} order order
+ * @property {number=} start start id
+ * @property {number=} end end id
+ */
+
 class ChunkModuleIdRangePlugin {
+	/**
+	 * @param {ChunkModuleIdRangePluginOptions} options options object
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -59,9 +70,7 @@ class ChunkModuleIdRangePlugin {
 					chunkModules = chunkGraph.getOrderedChunkModules(chunk, cmpFn);
 				} else {
 					chunkModules = Array.from(modules)
-						.filter(m => {
-							return chunkGraph.isModuleInChunk(m, chunk);
-						})
+						.filter(m => chunkGraph.isModuleInChunk(m, chunk))
 						.sort(compareModulesByPreOrderIndexOrIdentifier(moduleGraph));
 				}
 

package/lib/ids/DeterministicChunkIdsPlugin.js

@@ -15,9 +15,18 @@ const {
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
+/**
+ * @typedef {object} DeterministicChunkIdsPluginOptions
+ * @property {string=} context context for ids
+ * @property {number=} maxLength maximum length of ids
+ */
+
 class DeterministicChunkIdsPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * @param {DeterministicChunkIdsPluginOptions} [options] options
+	 */
+	constructor(options = {}) {
+		this.options = options;
 	}
 
 	/**
@@ -42,9 +51,7 @@ class DeterministicChunkIdsPlugin {
 
 						const usedIds = getUsedChunkIds(compilation);
 						assignDeterministicIds(
-							Array.from(chunks).filter(chunk => {
-								return chunk.id === null;
-							}),
+							Array.from(chunks).filter(chunk => chunk.id === null),
 							chunk =>
 								getFullChunkName(chunk, chunkGraph, context, compiler.root),
 							compareNatural,
@@ -56,7 +63,7 @@ class DeterministicChunkIdsPlugin {
 								chunk.ids = [id];
 								return true;
 							},
-							[Math.pow(10, maxLength)],
+							[10 ** maxLength],
 							10,
 							usedIds.size
 						);

package/lib/ids/DeterministicModuleIdsPlugin.js

@@ -9,7 +9,7 @@ const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
 const {
-	getUsedModuleIds,
+	getUsedModuleIdsAndModules,
 	getFullModuleName,
 	assignDeterministicIds
 } = require("./IdHelpers");
@@ -17,9 +17,22 @@ const {
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
+/**
+ * @typedef {object} DeterministicModuleIdsPluginOptions
+ * @property {string=} context context relative to which module identifiers are computed
+ * @property {function(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)
+ */
+
 class DeterministicModuleIdsPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * @param {DeterministicModuleIdsPluginOptions} [options] options
+	 */
+	constructor(options = {}) {
+		this.options = options;
 	}
 
 	/**
@@ -31,40 +44,51 @@ class DeterministicModuleIdsPlugin {
 		compiler.hooks.compilation.tap(
 			"DeterministicModuleIdsPlugin",
 			compilation => {
-				compilation.hooks.moduleIds.tap(
-					"DeterministicModuleIdsPlugin",
-					modules => {
-						const chunkGraph = compilation.chunkGraph;
-						const context = this.options.context
-							? this.options.context
-							: compiler.context;
-						const maxLength = this.options.maxLength || 3;
+				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;
 
-						const usedIds = getUsedModuleIds(compilation);
-						assignDeterministicIds(
-							Array.from(modules).filter(module => {
-								if (!module.needId) return false;
-								if (chunkGraph.getNumberOfModuleChunks(module) === 0)
-									return false;
-								return chunkGraph.getModuleId(module) === null;
-							}),
-							module => getFullModuleName(module, context, compiler.root),
-							compareModulesByPreOrderIndexOrIdentifier(
-								compilation.moduleGraph
-							),
-							(module, id) => {
-								const size = usedIds.size;
-								usedIds.add(`${id}`);
-								if (size === usedIds.size) return false;
-								chunkGraph.setModuleId(module, id);
-								return true;
-							},
-							[Math.pow(10, maxLength)],
-							10,
-							usedIds.size
+					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).`
 						);
-					}
-				);
+				});
 			}
 		);
 	}