webpack 5.93.0 → 5.95.0

package/lib/util/URLAbsoluteSpecifier.js

@@ -36,7 +36,7 @@ function getScheme(specifier) {
 		(start < aLowerCaseCharCode || start > zLowerCaseCharCode) &&
 		(start < aUpperCaseCharCode || start > zUpperCaseCharCode)
 	) {
-		return undefined;
+		return;
 	}
 
 	let i = 1;
@@ -49,12 +49,12 @@ function getScheme(specifier) {
 		ch === plusCharCode ||
 		ch === hyphenCharCode
 	) {
-		if (++i === specifier.length) return undefined;
+		if (++i === specifier.length) return;
 		ch = specifier.charCodeAt(i);
 	}
 
 	// Scheme must end with colon
-	if (ch !== colonCharCode) return undefined;
+	if (ch !== colonCharCode) return;
 
 	// Check for Windows absolute path
 	// https://url.spec.whatwg.org/#url-miscellaneous
@@ -67,7 +67,7 @@ function getScheme(specifier) {
 			nextChar === hashCharCode ||
 			nextChar === queryCharCode
 		) {
-			return undefined;
+			return;
 		}
 	}
 
@@ -80,8 +80,8 @@ function getScheme(specifier) {
  */
 function getProtocol(specifier) {
 	const scheme = getScheme(specifier);
-	return scheme === undefined ? undefined : scheme + ":";
+	return scheme === undefined ? undefined : `${scheme}:`;
 }
 
-exports.getScheme = getScheme;
-exports.getProtocol = getProtocol;
+module.exports.getScheme = getScheme;
+module.exports.getProtocol = getProtocol;

package/lib/util/WeakTupleMap.js

@@ -83,7 +83,7 @@ class WeakTupleMap {
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
 			node = node._peek(args[i]);
-			if (node === undefined) return undefined;
+			if (node === undefined) return;
 		}
 		return node._getValue();
 	}
@@ -158,12 +158,11 @@ class WeakTupleMap {
 	 */
 	_peek(thing) {
 		if (isWeakKey(thing)) {
-			if ((this.f & 4) !== 4) return undefined;
+			if ((this.f & 4) !== 4) return;
 			return /** @type {W<T, V>} */ (this.w).get(thing);
-		} else {
-			if ((this.f & 2) !== 2) return undefined;
-			return /** @type {M<T, V>} */ (this.m).get(thing);
 		}
+		if ((this.f & 2) !== 2) return;
+		return /** @type {M<T, V>} */ (this.m).get(thing);
 	}
 
 	/**
@@ -190,25 +189,24 @@ class WeakTupleMap {
 			/** @type {W<T, V>} */
 			(this.w).set(thing, newNode);
 			return newNode;
-		} else {
-			if ((this.f & 2) !== 2) {
-				const newMap = new Map();
-				this.f |= 2;
-				const newNode = new WeakTupleMap();
-				(this.m = newMap).set(thing, newNode);
-				return newNode;
-			}
-			const entry =
-				/** @type {M<T, V>} */
-				(this.m).get(thing);
-			if (entry !== undefined) {
-				return entry;
-			}
+		}
+		if ((this.f & 2) !== 2) {
+			const newMap = new Map();
+			this.f |= 2;
 			const newNode = new WeakTupleMap();
-			/** @type {M<T, V>} */
-			(this.m).set(thing, newNode);
+			(this.m = newMap).set(thing, newNode);
 			return newNode;
 		}
+		const entry =
+			/** @type {M<T, V>} */
+			(this.m).get(thing);
+		if (entry !== undefined) {
+			return entry;
+		}
+		const newNode = new WeakTupleMap();
+		/** @type {M<T, V>} */
+		(this.m).set(thing, newNode);
+		return newNode;
 	}
 }
 

package/lib/util/binarySearchBounds.js

@@ -22,7 +22,6 @@
  * ```js
  * function P(a,l,h,y,c){var i=l-1;while(l<=h){var m=(l+h)>>>1,x=a[m];if(c(x,y)<=0){i=m;l=m+1}else{h=m-1}}return i};
  * ```
- *
  * @param {string} funcName The name of the function to be compiled.
  * @param {string} predicate The predicate / comparison operator to be used in the binary search.
  * @param {boolean} reversed Whether the search should be reversed.
@@ -43,7 +42,7 @@ const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
 	];
 
 	if (earlyOut) {
-		if (predicate.indexOf("c") < 0) {
+		if (!predicate.includes("c")) {
 			code.push(";if(x===y){return m}else if(x<=y){");
 		} else {
 			code.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){");
@@ -70,7 +69,6 @@ const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
  * A(): Performs a binary search on an array using the comparison operator specified.
  * P(): Performs a binary search on an array using a _custom comparison function_
  * `c(x,y)` **and** comparison operator specified by `predicate`.
- *
  * @param {BinarySearchPredicate} predicate The predicate / comparison operator to be used in the binary search.
  * @param {boolean} reversed Whether the search should be reversed.
  * @param {SearchPredicateSuffix} suffix The suffix to be used in the function name.
@@ -78,17 +76,11 @@ const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
  * @returns {Function} The compiled binary search function.
  */
 const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
-	const arg1 = compileSearch(
-		"A",
-		"x" + predicate + "y",
-		reversed,
-		["y"],
-		earlyOut
-	);
+	const arg1 = compileSearch("A", `x${predicate}y`, reversed, ["y"], earlyOut);
 
 	const arg2 = compileSearch(
 		"P",
-		"c(x,y)" + predicate + "0",
+		`c(x,y)${predicate}0`,
 		reversed,
 		["y", "c"],
 		earlyOut
@@ -97,6 +89,7 @@ const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
 	const fnHeader = "function dispatchBinarySearch";
 
 	const fnBody =
+		// eslint-disable-next-line no-multi-str
 		"(a,y,c,l,h){\
 if(typeof(c)==='function'){\
 return P(a,(l===void 0)?0:l|0,(h===void 0)?a.length-1:h|0,y,c)\
@@ -107,13 +100,13 @@ return dispatchBinarySearch";
 
 	const fnArgList = [arg1, arg2, fnHeader, suffix, fnBody, suffix];
 	const fnSource = fnArgList.join("");
+	// eslint-disable-next-line no-new-func
 	const result = new Function(fnSource);
 	return result();
 };
 
 /**
  * These functions are used to perform binary searches on arrays.
- *
  * @example
  * ```js
  * const { gt, le} = require("./binarySearchBounds");

package/lib/util/chainedImports.js

@@ -23,7 +23,7 @@
  * @param {Dependency} dependency dependency
  * @returns {{trimmedIds: string[], trimmedRange: Range}} computed trimmed ids and cumulative range of those ids
  */
-exports.getTrimmedIdsAndRange = (
+module.exports.getTrimmedIdsAndRange = (
 	untrimmedIds,
 	untrimmedRange,
 	ranges,

package/lib/util/cleverMerge.js

@@ -23,15 +23,17 @@ const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
  *  // when same arguments passed, gets the result from WeakMap and returns it.
  * cachedCleverMerge({a: 1}, {a: 2})
  * {a: 2}
- * @param {T} first first object
- * @param {O} second second object
+ * @param {T | null | undefined} first first object
+ * @param {O | null | undefined} second second object
  * @returns {T & O | T | O} merged object of first and second object
  */
 const cachedCleverMerge = (first, second) => {
-	if (second === undefined) return first;
-	if (first === undefined) return second;
-	if (typeof second !== "object" || second === null) return second;
-	if (typeof first !== "object" || first === null) return first;
+	if (second === undefined) return /** @type {T} */ (first);
+	if (first === undefined) return /** @type {O} */ (second);
+	if (typeof second !== "object" || second === null)
+		return /** @type {O} */ (second);
+	if (typeof first !== "object" || first === null)
+		return /** @type {T} */ (first);
 
 	let innerCache = mergeCache.get(first);
 	if (innerCache === undefined) {
@@ -229,7 +231,7 @@ const getValueType = value => {
 	} else if (value === DELETE) {
 		return VALUE_TYPE_DELETE;
 	} else if (Array.isArray(value)) {
-		if (value.lastIndexOf("...") !== -1) return VALUE_TYPE_ARRAY_EXTEND;
+		if (value.includes("...")) return VALUE_TYPE_ARRAY_EXTEND;
 		return VALUE_TYPE_ATOM;
 	} else if (
 		typeof value === "object" &&
@@ -550,21 +552,21 @@ const resolveByProperty = (obj, byProperty, ...values) => {
 	if (typeof obj !== "object" || obj === null || !(byProperty in obj)) {
 		return obj;
 	}
-	const { [byProperty]: _byValue, ..._remaining } = /** @type {object} */ (obj);
+	const { [byProperty]: _byValue, ..._remaining } = obj;
 	const remaining = /** @type {T} */ (_remaining);
-	const byValue = /** @type {Record<string, T> | function(...any[]): T} */ (
-		_byValue
-	);
+	const byValue =
+		/** @type {Record<string, T> | function(...any[]): T} */
+		(_byValue);
 	if (typeof byValue === "object") {
 		const key = values[0];
 		if (key in byValue) {
 			return cachedCleverMerge(remaining, byValue[key]);
 		} else if ("default" in byValue) {
 			return cachedCleverMerge(remaining, byValue.default);
-		} else {
-			return /** @type {T} */ (remaining);
 		}
+		return remaining;
 	} else if (typeof byValue === "function") {
+		// eslint-disable-next-line prefer-spread
 		const result = byValue.apply(null, values);
 		return cachedCleverMerge(
 			remaining,
@@ -573,9 +575,9 @@ const resolveByProperty = (obj, byProperty, ...values) => {
 	}
 };
 
-exports.cachedSetProperty = cachedSetProperty;
-exports.cachedCleverMerge = cachedCleverMerge;
-exports.cleverMerge = cleverMerge;
-exports.resolveByProperty = resolveByProperty;
-exports.removeOperations = removeOperations;
-exports.DELETE = DELETE;
+module.exports.cachedSetProperty = cachedSetProperty;
+module.exports.cachedCleverMerge = cachedCleverMerge;
+module.exports.cleverMerge = cleverMerge;
+module.exports.resolveByProperty = resolveByProperty;
+module.exports.removeOperations = removeOperations;
+module.exports.DELETE = DELETE;

package/lib/util/comparators.js

@@ -10,14 +10,26 @@ const { compareRuntime } = require("./runtime");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 
-/** @template T @typedef {function(T, T): -1|0|1} Comparator */
-/** @template TArg @template T @typedef {function(TArg, T, T): -1|0|1} RawParameterizedComparator */
-/** @template TArg @template T @typedef {function(TArg): Comparator<T>} ParameterizedComparator */
+/**
+ * @template T
+ * @typedef {function(T, T): -1|0|1} Comparator
+ */
+/**
+ * @template TArg
+ * @template T
+ * @typedef {function(TArg, T, T): -1|0|1} RawParameterizedComparator
+ */
+/**
+ * @template TArg
+ * @template T
+ * @typedef {function(TArg): Comparator<T>} ParameterizedComparator
+ */
 
 /**
  * @template T
@@ -46,21 +58,16 @@ const createCachedParameterizedComparator = fn => {
  * @param {Chunk} b chunk
  * @returns {-1|0|1} compare result
  */
-exports.compareChunksById = (a, b) => {
-	return compareIds(
-		/** @type {ChunkId} */ (a.id),
-		/** @type {ChunkId} */ (b.id)
-	);
-};
+module.exports.compareChunksById = (a, b) =>
+	compareIds(/** @type {ChunkId} */ (a.id), /** @type {ChunkId} */ (b.id));
 
 /**
  * @param {Module} a module
  * @param {Module} b module
  * @returns {-1|0|1} compare result
  */
-exports.compareModulesByIdentifier = (a, b) => {
-	return compareIds(a.identifier(), b.identifier());
-};
+module.exports.compareModulesByIdentifier = (a, b) =>
+	compareIds(a.identifier(), b.identifier());
 
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
@@ -68,11 +75,13 @@ exports.compareModulesByIdentifier = (a, b) => {
  * @param {Module} b module
  * @returns {-1|0|1} compare result
  */
-const compareModulesById = (chunkGraph, a, b) => {
-	return compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
-};
+const compareModulesById = (chunkGraph, a, b) =>
+	compareIds(
+		/** @type {ModuleId} */ (chunkGraph.getModuleId(a)),
+		/** @type {ModuleId} */ (chunkGraph.getModuleId(b))
+	);
 /** @type {ParameterizedComparator<ChunkGraph, Module>} */
-exports.compareModulesById =
+module.exports.compareModulesById =
 	createCachedParameterizedComparator(compareModulesById);
 
 /**
@@ -88,7 +97,7 @@ const compareNumbers = (a, b) => {
 	if (a > b) return 1;
 	return 0;
 };
-exports.compareNumbers = compareNumbers;
+module.exports.compareNumbers = compareNumbers;
 
 /**
  * @param {string} a string
@@ -160,7 +169,7 @@ const compareStringsNumeric = (a, b) => {
 
 	return 0;
 };
-exports.compareStringsNumeric = compareStringsNumeric;
+module.exports.compareStringsNumeric = compareStringsNumeric;
 
 /**
  * @param {ModuleGraph} moduleGraph the module graph
@@ -177,7 +186,7 @@ const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	return compareIds(a.identifier(), b.identifier());
 };
 /** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPostOrderIndexOrIdentifier =
+module.exports.compareModulesByPostOrderIndexOrIdentifier =
 	createCachedParameterizedComparator(
 		compareModulesByPostOrderIndexOrIdentifier
 	);
@@ -197,7 +206,7 @@ const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	return compareIds(a.identifier(), b.identifier());
 };
 /** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPreOrderIndexOrIdentifier =
+module.exports.compareModulesByPreOrderIndexOrIdentifier =
 	createCachedParameterizedComparator(
 		compareModulesByPreOrderIndexOrIdentifier
 	);
@@ -209,14 +218,16 @@ exports.compareModulesByPreOrderIndexOrIdentifier =
  * @returns {-1|0|1} compare result
  */
 const compareModulesByIdOrIdentifier = (chunkGraph, a, b) => {
-	const cmp = compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
+	const cmp = compareIds(
+		/** @type {ModuleId} */ (chunkGraph.getModuleId(a)),
+		/** @type {ModuleId} */ (chunkGraph.getModuleId(b))
+	);
 	if (cmp !== 0) return cmp;
 	return compareIds(a.identifier(), b.identifier());
 };
 /** @type {ParameterizedComparator<ChunkGraph, Module>} */
-exports.compareModulesByIdOrIdentifier = createCachedParameterizedComparator(
-	compareModulesByIdOrIdentifier
-);
+module.exports.compareModulesByIdOrIdentifier =
+	createCachedParameterizedComparator(compareModulesByIdOrIdentifier);
 
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
@@ -224,11 +235,10 @@ exports.compareModulesByIdOrIdentifier = createCachedParameterizedComparator(
  * @param {Chunk} b chunk
  * @returns {-1|0|1} compare result
  */
-const compareChunks = (chunkGraph, a, b) => {
-	return chunkGraph.compareChunks(a, b);
-};
+const compareChunks = (chunkGraph, a, b) => chunkGraph.compareChunks(a, b);
 /** @type {ParameterizedComparator<ChunkGraph, Chunk>} */
-exports.compareChunks = createCachedParameterizedComparator(compareChunks);
+module.exports.compareChunks =
+	createCachedParameterizedComparator(compareChunks);
 
 /**
  * @param {string|number} a first id
@@ -244,7 +254,7 @@ const compareIds = (a, b) => {
 	return 0;
 };
 
-exports.compareIds = compareIds;
+module.exports.compareIds = compareIds;
 
 /**
  * @param {string} a first string
@@ -257,20 +267,16 @@ const compareStrings = (a, b) => {
 	return 0;
 };
 
-exports.compareStrings = compareStrings;
+module.exports.compareStrings = compareStrings;
 
 /**
  * @param {ChunkGroup} a first chunk group
  * @param {ChunkGroup} b second chunk group
  * @returns {-1|0|1} compare result
  */
-const compareChunkGroupsByIndex = (a, b) => {
-	return /** @type {number} */ (a.index) < /** @type {number} */ (b.index)
-		? -1
-		: 1;
-};
-
-exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
+const compareChunkGroupsByIndex = (a, b) =>
+	/** @type {number} */ (a.index) < /** @type {number} */ (b.index) ? -1 : 1;
+module.exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
 
 /**
  * @template K1 {Object}
@@ -294,7 +300,7 @@ class TwoKeyWeakMap {
 	get(key1, key2) {
 		const childMap = this._map.get(key1);
 		if (childMap === undefined) {
-			return undefined;
+			return;
 		}
 		return childMap.get(key2);
 	}
@@ -347,7 +353,7 @@ const concatComparators = (c1, c2, ...cRest) => {
 	concatComparatorsCache.set(c1, c2, result);
 	return result;
 };
-exports.concatComparators = concatComparators;
+module.exports.concatComparators = concatComparators;
 
 /**
  * @template A, B
@@ -380,17 +386,16 @@ const compareSelect = (getter, comparator) => {
 				return comparator(aValue, bValue);
 			}
 			return -1;
-		} else {
-			if (bValue !== undefined && bValue !== null) {
-				return 1;
-			}
-			return 0;
 		}
+		if (bValue !== undefined && bValue !== null) {
+			return 1;
+		}
+		return 0;
 	};
 	compareSelectCache.set(getter, comparator, result);
 	return result;
 };
-exports.compareSelect = compareSelect;
+module.exports.compareSelect = compareSelect;
 
 /** @type {WeakMap<Comparator<any>, Comparator<Iterable<any>>>} */
 const compareIteratorsCache = new WeakMap();
@@ -426,7 +431,7 @@ const compareIterables = elementComparator => {
 	compareIteratorsCache.set(elementComparator, result);
 	return result;
 };
-exports.compareIterables = compareIterables;
+module.exports.compareIterables = compareIterables;
 
 // TODO this is no longer needed when minimum node.js version is >= 12
 // since these versions ship with a stable sort function
@@ -435,7 +440,7 @@ exports.compareIterables = compareIterables;
  * @param {Iterable<T>} iterable original ordered list
  * @returns {Comparator<T>} comparator
  */
-exports.keepOriginalOrder = iterable => {
+module.exports.keepOriginalOrder = iterable => {
 	/** @type {Map<T, number>} */
 	const map = new Map();
 	let i = 0;
@@ -453,8 +458,8 @@ exports.keepOriginalOrder = iterable => {
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @returns {Comparator<Chunk>} comparator
  */
-exports.compareChunksNatural = chunkGraph => {
-	const cmpFn = exports.compareModulesById(chunkGraph);
+module.exports.compareChunksNatural = chunkGraph => {
+	const cmpFn = module.exports.compareModulesById(chunkGraph);
 	const cmpIterableFn = compareIterables(cmpFn);
 	return concatComparators(
 		compareSelect(
@@ -479,9 +484,9 @@ exports.compareChunksNatural = chunkGraph => {
  * @param {DependencyLocation} b A location node
  * @returns {-1|0|1} sorting comparator value
  */
-exports.compareLocations = (a, b) => {
-	let isObjectA = typeof a === "object" && a !== null;
-	let isObjectB = typeof b === "object" && b !== null;
+module.exports.compareLocations = (a, b) => {
+	const isObjectA = typeof a === "object" && a !== null;
+	const isObjectB = typeof b === "object" && b !== null;
 	if (!isObjectA || !isObjectB) {
 		if (isObjectA) return 1;
 		if (isObjectB) return -1;

package/lib/util/compileBooleanMatcher.js

@@ -9,16 +9,14 @@
  * @param {string} str string
  * @returns {string} quoted meta
  */
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
+const quoteMeta = str => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 
 /**
  * @param {string} str string
  * @returns {string} string
  */
 const toSimpleString = str => {
-	if (`${+str}` === str) {
+	if (`${Number(str)}` === str) {
 		return str;
 	}
 	return JSON.stringify(str);
@@ -52,9 +50,8 @@ const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
 	const negativeRegexp = itemsToRegexp(negativeItems);
 	if (positiveRegexp.length <= negativeRegexp.length) {
 		return value => `/^${positiveRegexp}$/.test(${value})`;
-	} else {
-		return value => `!/^${negativeRegexp}$/.test(${value})`;
 	}
+	return value => `!/^${negativeRegexp}$/.test(${value})`;
 };
 
 /**

package/lib/util/conventions.js

@@ -12,7 +12,7 @@
  * @param {CssGeneratorExportsConvention | undefined} convention convention
  * @returns {string[]} results
  */
-exports.cssExportConvention = (input, convention) => {
+module.exports.cssExportConvention = (input, convention) => {
 	const set = new Set();
 	if (typeof convention === "function") {
 		set.add(convention(input));
@@ -20,20 +20,20 @@ exports.cssExportConvention = (input, convention) => {
 		switch (convention) {
 			case "camel-case": {
 				set.add(input);
-				set.add(exports.camelCase(input));
+				set.add(module.exports.camelCase(input));
 				break;
 			}
 			case "camel-case-only": {
-				set.add(exports.camelCase(input));
+				set.add(module.exports.camelCase(input));
 				break;
 			}
 			case "dashes": {
 				set.add(input);
-				set.add(exports.dashesCamelCase(input));
+				set.add(module.exports.dashesCamelCase(input));
 				break;
 			}
 			case "dashes-only": {
-				set.add(exports.dashesCamelCase(input));
+				set.add(module.exports.dashesCamelCase(input));
 				break;
 			}
 			case "as-is": {
@@ -50,18 +50,15 @@ exports.cssExportConvention = (input, convention) => {
  * @param {string} input input
  * @returns {string} result
  */
-exports.dashesCamelCase = input => {
-	return input.replace(/-+(\w)/g, (match, firstLetter) =>
-		firstLetter.toUpperCase()
-	);
-};
+module.exports.dashesCamelCase = input =>
+	input.replace(/-+(\w)/g, (match, firstLetter) => firstLetter.toUpperCase());
 
 // Copy from css-loader
 /**
  * @param {string} input input
  * @returns {string} result
  */
-exports.camelCase = input => {
+module.exports.camelCase = input => {
 	let result = input.trim();
 
 	if (result.length === 0) {

package/lib/util/createHash.js

@@ -128,26 +128,29 @@ class DebugHash extends Hash {
 	 * @returns {string|Buffer} digest
 	 */
 	digest(encoding) {
-		return Buffer.from("@webpack-debug-digest@" + this.string).toString("hex");
+		return Buffer.from(`@webpack-debug-digest@${this.string}`).toString("hex");
 	}
 }
 
 /** @type {typeof import("crypto") | undefined} */
-let crypto = undefined;
+let crypto;
 /** @type {typeof import("./hash/xxhash64") | undefined} */
-let createXXHash64 = undefined;
+let createXXHash64;
 /** @type {typeof import("./hash/md4") | undefined} */
-let createMd4 = undefined;
+let createMd4;
 /** @type {typeof import("./hash/BatchedHash") | undefined} */
-let BatchedHash = undefined;
+let BatchedHash;
+
+/** @typedef {string | typeof Hash} Algorithm */
 
 /**
  * Creates a hash by name or function
- * @param {string | typeof Hash} algorithm the algorithm name or a constructor creating a hash
+ * @param {Algorithm} algorithm the algorithm name or a constructor creating a hash
  * @returns {Hash} the hash
  */
 module.exports = algorithm => {
 	if (typeof algorithm === "function") {
+		// eslint-disable-next-line new-cap
 		return new BulkUpdateDecorator(() => new algorithm());
 	}
 	switch (algorithm) {