webpack 5.92.1 → 5.94.0

package/lib/util/identifier.js

@@ -85,24 +85,48 @@ const requestToAbsolute = (context, relativePath) => {
 	return relativePath;
 };
 
+/**
+ * @template T
+ * @typedef {function(string, object=): T} MakeCacheableResult
+ */
+
+/**
+ * @template T
+ * @typedef {function(string): T} BindCacheResultFn
+ */
+
+/**
+ * @template T
+ * @typedef {function(object): BindCacheResultFn<T>} BindCache
+ */
+
+/**
+ * @template T
+ * @param {(function(string): T)} realFn real function
+ * @returns {MakeCacheableResult<T> & { bindCache: BindCache<T> }} cacheable function
+ */
 const makeCacheable = realFn => {
-	/** @type {WeakMap<object, Map<string, ParsedResource>>} */
+	/**
+	 * @template T
+	 * @typedef {Map<string, T>} CacheItem
+	 */
+	/** @type {WeakMap<object, CacheItem<T>>} */
 	const cache = new WeakMap();
 
+	/**
+	 * @param {object} associatedObjectForCache an object to which the cache will be attached
+	 * @returns {CacheItem<T>} cache item
+	 */
 	const getCache = associatedObjectForCache => {
 		const entry = cache.get(associatedObjectForCache);
 		if (entry !== undefined) return entry;
-		/** @type {Map<string, ParsedResource>} */
+		/** @type {Map<string, T>} */
 		const map = new Map();
 		cache.set(associatedObjectForCache, map);
 		return map;
 	};
 
-	/**
-	 * @param {string} str the path with query and fragment
-	 * @param {object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {ParsedResource} parsed parts
-	 */
+	/** @type {MakeCacheableResult<T> & { bindCache: BindCache<T> }} */
 	const fn = (str, associatedObjectForCache) => {
 		if (!associatedObjectForCache) return realFn(str);
 		const cache = getCache(associatedObjectForCache);
@@ -113,8 +137,13 @@ const makeCacheable = realFn => {
 		return result;
 	};
 
+	/** @type {BindCache<T>} */
 	fn.bindCache = associatedObjectForCache => {
 		const cache = getCache(associatedObjectForCache);
+		/**
+		 * @param {string} str string
+		 * @returns {T} value
+		 */
 		return str => {
 			const entry = cache.get(str);
 			if (entry !== undefined) return entry;
@@ -127,16 +156,21 @@ const makeCacheable = realFn => {
 	return fn;
 };
 
+/** @typedef {function(string, string, object=): string} MakeCacheableWithContextResult */
+/** @typedef {function(string, string): string} BindCacheForContextResultFn */
+/** @typedef {function(string): string} BindContextCacheForContextResultFn */
+/** @typedef {function(object=): BindCacheForContextResultFn} BindCacheForContext */
+/** @typedef {function(string, object=): BindContextCacheForContextResultFn} BindContextCacheForContext */
+
+/**
+ * @param {function(string, string): string} fn function
+ * @returns {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} cacheable function with context
+ */
 const makeCacheableWithContext = fn => {
 	/** @type {WeakMap<object, Map<string, Map<string, string>>>} */
 	const cache = new WeakMap();
 
-	/**
-	 * @param {string} context context used to create relative path
-	 * @param {string} identifier identifier used to create relative path
-	 * @param {object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {string} the returned relative path
-	 */
+	/** @type {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} */
 	const cachedFn = (context, identifier, associatedObjectForCache) => {
 		if (!associatedObjectForCache) return fn(context, identifier);
 
@@ -156,17 +190,13 @@ const makeCacheableWithContext = fn => {
 
 		if (cachedResult !== undefined) {
 			return cachedResult;
-		} else {
-			const result = fn(context, identifier);
-			innerSubCache.set(identifier, result);
-			return result;
 		}
+		const result = fn(context, identifier);
+		innerSubCache.set(identifier, result);
+		return result;
 	};
 
-	/**
-	 * @param {object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {function(string, string): string} cached function
-	 */
+	/** @type {BindCacheForContext} */
 	cachedFn.bindCache = associatedObjectForCache => {
 		let innerCache;
 		if (associatedObjectForCache) {
@@ -195,21 +225,16 @@ const makeCacheableWithContext = fn => {
 
 			if (cachedResult !== undefined) {
 				return cachedResult;
-			} else {
-				const result = fn(context, identifier);
-				innerSubCache.set(identifier, result);
-				return result;
 			}
+			const result = fn(context, identifier);
+			innerSubCache.set(identifier, result);
+			return result;
 		};
 
 		return boundFn;
 	};
 
-	/**
-	 * @param {string} context context used to create relative path
-	 * @param {object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {function(string): string} cached function
-	 */
+	/** @type {BindContextCacheForContext} */
 	cachedFn.bindContextCache = (context, associatedObjectForCache) => {
 		let innerSubCache;
 		if (associatedObjectForCache) {
@@ -235,11 +260,10 @@ const makeCacheableWithContext = fn => {
 			const cachedResult = innerSubCache.get(identifier);
 			if (cachedResult !== undefined) {
 				return cachedResult;
-			} else {
-				const result = fn(context, identifier);
-				innerSubCache.set(identifier, result);
-				return result;
 			}
+			const result = fn(context, identifier);
+			innerSubCache.set(identifier, result);
+			return result;
 		};
 
 		return boundFn;
@@ -249,64 +273,58 @@ const makeCacheableWithContext = fn => {
 };
 
 /**
- *
  * @param {string} context context for relative path
  * @param {string} identifier identifier for path
  * @returns {string} a converted relative path
  */
-const _makePathsRelative = (context, identifier) => {
-	return identifier
+const _makePathsRelative = (context, identifier) =>
+	identifier
 		.split(SEGMENTS_SPLIT_REGEXP)
 		.map(str => absoluteToRequest(context, str))
 		.join("");
-};
 
-exports.makePathsRelative = makeCacheableWithContext(_makePathsRelative);
+module.exports.makePathsRelative = makeCacheableWithContext(_makePathsRelative);
 
 /**
- *
  * @param {string} context context for relative path
  * @param {string} identifier identifier for path
  * @returns {string} a converted relative path
  */
-const _makePathsAbsolute = (context, identifier) => {
-	return identifier
+const _makePathsAbsolute = (context, identifier) =>
+	identifier
 		.split(SEGMENTS_SPLIT_REGEXP)
 		.map(str => requestToAbsolute(context, str))
 		.join("");
-};
 
-exports.makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);
+module.exports.makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);
 
 /**
  * @param {string} context absolute context path
  * @param {string} request any request string may containing absolute paths, query string, etc.
  * @returns {string} a new request string avoiding absolute paths when possible
  */
-const _contextify = (context, request) => {
-	return request
+const _contextify = (context, request) =>
+	request
 		.split("!")
 		.map(r => absoluteToRequest(context, r))
 		.join("!");
-};
 
 const contextify = makeCacheableWithContext(_contextify);
-exports.contextify = contextify;
+module.exports.contextify = contextify;
 
 /**
  * @param {string} context absolute context path
  * @param {string} request any request string
  * @returns {string} a new request string using absolute paths when possible
  */
-const _absolutify = (context, request) => {
-	return request
+const _absolutify = (context, request) =>
+	request
 		.split("!")
 		.map(r => requestToAbsolute(context, r))
 		.join("!");
-};
 
 const absolutify = makeCacheableWithContext(_absolutify);
-exports.absolutify = absolutify;
+module.exports.absolutify = absolutify;
 
 const PATH_QUERY_FRAGMENT_REGEXP =
 	/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
@@ -320,7 +338,9 @@ const PATH_QUERY_REGEXP = /^((?:\0.|[^?\0])*)(\?.*)?$/;
  * @returns {ParsedResource} parsed parts
  */
 const _parseResource = str => {
-	const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+	const match =
+		/** @type {[string, string, string | undefined, string | undefined]} */
+		(/** @type {unknown} */ (PATH_QUERY_FRAGMENT_REGEXP.exec(str)));
 	return {
 		resource: str,
 		path: match[1].replace(/\0(.)/g, "$1"),
@@ -328,7 +348,7 @@ const _parseResource = str => {
 		fragment: match[3] || ""
 	};
 };
-exports.parseResource = makeCacheable(_parseResource);
+module.exports.parseResource = makeCacheable(_parseResource);
 
 /**
  * Parse resource, skips fragment part
@@ -336,14 +356,16 @@ exports.parseResource = makeCacheable(_parseResource);
  * @returns {ParsedResourceWithoutFragment} parsed parts
  */
 const _parseResourceWithoutFragment = str => {
-	const match = PATH_QUERY_REGEXP.exec(str);
+	const match =
+		/** @type {[string, string, string | undefined]} */
+		(/** @type {unknown} */ (PATH_QUERY_REGEXP.exec(str)));
 	return {
 		resource: str,
 		path: match[1].replace(/\0(.)/g, "$1"),
 		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : ""
 	};
 };
-exports.parseResourceWithoutFragment = makeCacheable(
+module.exports.parseResourceWithoutFragment = makeCacheable(
 	_parseResourceWithoutFragment
 );
 
@@ -353,7 +375,7 @@ exports.parseResourceWithoutFragment = makeCacheable(
  * @param {boolean} enforceRelative true returns ./ for empty paths
  * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
  */
-exports.getUndoPath = (filename, outputPath, enforceRelative) => {
+module.exports.getUndoPath = (filename, outputPath, enforceRelative) => {
 	let depth = -1;
 	let append = "";
 	outputPath = outputPath.replace(/[\\/]$/, "");
@@ -365,8 +387,8 @@ exports.getUndoPath = (filename, outputPath, enforceRelative) => {
 				const i = outputPath.lastIndexOf("/");
 				const j = outputPath.lastIndexOf("\\");
 				const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
-				if (pos < 0) return outputPath + "/";
-				append = outputPath.slice(pos + 1) + "/" + append;
+				if (pos < 0) return `${outputPath}/`;
+				append = `${outputPath.slice(pos + 1)}/${append}`;
 				outputPath = outputPath.slice(0, pos);
 			}
 		} else if (part !== ".") {

package/lib/util/memoize.js

@@ -14,20 +14,18 @@
 const memoize = fn => {
 	let cache = false;
 	/** @type {T | undefined} */
-	let result = undefined;
+	let result;
 	return () => {
 		if (cache) {
 			return /** @type {T} */ (result);
-		} else {
-			result = fn();
-			cache = true;
-			// Allow to clean up memory for fn
-			// and all dependent resources
-			// eslint-disable-next-line no-warning-comments
-			// @ts-ignore
-			fn = undefined;
-			return /** @type {T} */ (result);
 		}
+
+		result = fn();
+		cache = true;
+		// Allow to clean up memory for fn
+		// and all dependent resources
+		fn = undefined;
+		return /** @type {T} */ (result);
 	};
 };
 

package/lib/util/mergeScope.js

@@ -42,18 +42,15 @@ const getPathInAst = (ast, node) => {
 	const nr = node.range;
 
 	const enterNode = n => {
-		if (!n) return undefined;
+		if (!n) return;
 		const r = n.range;
-		if (r) {
-			if (r[0] <= nr[0] && r[1] >= nr[1]) {
-				const path = getPathInAst(n, node);
-				if (path) {
-					path.push(n);
-					return path;
-				}
+		if (r && r[0] <= nr[0] && r[1] >= nr[1]) {
+			const path = getPathInAst(n, node);
+			if (path) {
+				path.push(n);
+				return path;
 			}
 		}
-		return undefined;
 	};
 
 	if (Array.isArray(ast)) {

package/lib/util/nonNumericOnlyHash.js

@@ -15,8 +15,8 @@ const A_CODE = "a".charCodeAt(0);
 module.exports = (hash, hashLength) => {
 	if (hashLength < 1) return "";
 	const slice = hash.slice(0, hashLength);
-	if (slice.match(/[^\d]/)) return slice;
+	if (/[^\d]/.test(slice)) return slice;
 	return `${String.fromCharCode(
-		A_CODE + (parseInt(hash[0], 10) % 6)
+		A_CODE + (Number.parseInt(hash[0], 10) % 6)
 	)}${slice.slice(1)}`;
 };

package/lib/util/numberHash.js

@@ -77,24 +77,19 @@ function fnv1a64(str) {
  *
  * We use `numberHash` in `lib/ids/IdHelpers.js` to generate hash values for the module identifier. The generated
  * hash is used as a prefix for the module id's to avoid collisions with other modules.
- *
  * @param {string} str The input string to hash.
  * @param {number} range The range of the hash value (0 to range-1).
  * @returns {number} - The computed hash value.
- *
  * @example
- *
  * ```js
  * const numberHash = require("webpack/lib/util/numberHash");
  * numberHash("hello", 1000); // 73
  * numberHash("hello world"); // 72
  * ```
- *
  */
 module.exports = (str, range) => {
 	if (range < FNV_64_THRESHOLD) {
 		return fnv1a32(str) % range;
-	} else {
-		return Number(fnv1a64(str) % BigInt(range));
 	}
+	return Number(fnv1a64(str) % BigInt(range));
 };

package/lib/util/objectToMap.js

@@ -6,7 +6,6 @@
 
 /**
  * Convert an object into an ES6 map
- *
  * @param {object} obj any object type that works with Object.entries()
  * @returns {Map<string, any>} an ES6 Map of KV pairs
  */

package/lib/util/propertyAccess.js

@@ -5,10 +5,7 @@
 
 "use strict";
 
-const {
-	SAFE_IDENTIFIER,
-	RESERVED_IDENTIFIER
-} = require("../util/propertyName");
+const { SAFE_IDENTIFIER, RESERVED_IDENTIFIER } = require("./propertyName");
 
 /**
  * @param {ArrayLike<string>} properties properties
@@ -19,7 +16,7 @@ const propertyAccess = (properties, start = 0) => {
 	let str = "";
 	for (let i = start; i < properties.length; i++) {
 		const p = properties[i];
-		if (`${+p}` === p) {
+		if (`${Number(p)}` === p) {
 			str += `[${p}]`;
 		} else if (SAFE_IDENTIFIER.test(p) && !RESERVED_IDENTIFIER.has(p)) {
 			str += `.${p}`;

package/lib/util/propertyName.js

@@ -64,16 +64,14 @@ const RESERVED_IDENTIFIER = new Set([
  * @summary Returns a valid JS property name for the given property.
  * Certain strings like "default", "null", and names with whitespace are not
  * valid JS property names, so they are returned as strings.
- *
  * @param {string} prop property name to analyze
  * @returns {string} valid JS property name
  */
 const propertyName = prop => {
 	if (SAFE_IDENTIFIER.test(prop) && !RESERVED_IDENTIFIER.has(prop)) {
 		return prop;
-	} else {
-		return JSON.stringify(prop);
 	}
+	return JSON.stringify(prop);
 };
 
 module.exports = { SAFE_IDENTIFIER, RESERVED_IDENTIFIER, propertyName };

package/lib/util/registerExternalSerializer.js

@@ -9,7 +9,7 @@ const { register } = require("./serialization");
 
 const Position = /** @type {TODO} */ (require("acorn")).Position;
 const SourceLocation = require("acorn").SourceLocation;
-const ValidationError = require("schema-utils/dist/ValidationError").default;
+const ValidationError = require("schema-utils").ValidationError;
 const {
 	CachedSource,
 	ConcatSource,