webpack 5.59.0 → 5.94.0

package/lib/util/identifier.js

@@ -11,10 +11,14 @@ const SEGMENTS_SPLIT_REGEXP = /([|!])/;
 const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
 
 /**
- * @typedef {Object} MakeRelativePathsCache
+ * @typedef {object} MakeRelativePathsCache
  * @property {Map<string, Map<string, string>>=} relativePaths
  */
 
+/**
+ * @param {string} relativePath relative path
+ * @returns {string} request
+ */
 const relativePathToRequest = relativePath => {
 	if (relativePath === "") return "./.";
 	if (relativePath === "..") return "../.";
@@ -81,16 +85,92 @@ const requestToAbsolute = (context, relativePath) => {
 	return relativePath;
 };
 
-const makeCacheable = fn => {
-	/** @type {WeakMap<object, Map<string, Map<string, string>>>} */
+/**
+ * @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 => {
+	/**
+	 * @template T
+	 * @typedef {Map<string, T>} CacheItem
+	 */
+	/** @type {WeakMap<object, CacheItem<T>>} */
 	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
+	 * @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, T>} */
+		const map = new Map();
+		cache.set(associatedObjectForCache, map);
+		return map;
+	};
+
+	/** @type {MakeCacheableResult<T> & { bindCache: BindCache<T> }} */
+	const fn = (str, associatedObjectForCache) => {
+		if (!associatedObjectForCache) return realFn(str);
+		const cache = getCache(associatedObjectForCache);
+		const entry = cache.get(str);
+		if (entry !== undefined) return entry;
+		const result = realFn(str);
+		cache.set(str, result);
+		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;
+			const result = realFn(str);
+			cache.set(str, result);
+			return result;
+		};
+	};
+
+	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();
+
+	/** @type {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} */
 	const cachedFn = (context, identifier, associatedObjectForCache) => {
 		if (!associatedObjectForCache) return fn(context, identifier);
 
@@ -110,17 +190,13 @@ const makeCacheable = 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) {
@@ -149,21 +225,16 @@ const makeCacheable = 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) {
@@ -189,11 +260,10 @@ const makeCacheable = 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;
@@ -203,76 +273,74 @@ const makeCacheable = 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 = makeCacheable(_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 = makeCacheable(_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 = makeCacheable(_contextify);
-exports.contextify = contextify;
+const contextify = makeCacheableWithContext(_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 = makeCacheable(_absolutify);
-exports.absolutify = absolutify;
+const absolutify = makeCacheableWithContext(_absolutify);
+module.exports.absolutify = absolutify;
 
 const PATH_QUERY_FRAGMENT_REGEXP =
 	/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+const PATH_QUERY_REGEXP = /^((?:\0.|[^?\0])*)(\?.*)?$/;
 
 /** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
+/** @typedef {{ resource: string, path: string, query: string }} ParsedResourceWithoutFragment */
 
 /**
  * @param {string} str the path with query and fragment
  * @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"),
@@ -280,47 +348,26 @@ const _parseResource = str => {
 		fragment: match[3] || ""
 	};
 };
-exports.parseResource = (realFn => {
-	/** @type {WeakMap<object, Map<string, ParsedResource>>} */
-	const cache = new WeakMap();
-
-	const getCache = associatedObjectForCache => {
-		const entry = cache.get(associatedObjectForCache);
-		if (entry !== undefined) return entry;
-		/** @type {Map<string, ParsedResource>} */
-		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
-	 */
-	const fn = (str, associatedObjectForCache) => {
-		if (!associatedObjectForCache) return realFn(str);
-		const cache = getCache(associatedObjectForCache);
-		const entry = cache.get(str);
-		if (entry !== undefined) return entry;
-		const result = realFn(str);
-		cache.set(str, result);
-		return result;
-	};
+module.exports.parseResource = makeCacheable(_parseResource);
 
-	fn.bindCache = associatedObjectForCache => {
-		const cache = getCache(associatedObjectForCache);
-		return str => {
-			const entry = cache.get(str);
-			if (entry !== undefined) return entry;
-			const result = realFn(str);
-			cache.set(str, result);
-			return result;
-		};
+/**
+ * Parse resource, skips fragment part
+ * @param {string} str the path with query and fragment
+ * @returns {ParsedResourceWithoutFragment} parsed parts
+ */
+const _parseResourceWithoutFragment = 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") : ""
 	};
-
-	return fn;
-})(_parseResource);
+};
+module.exports.parseResourceWithoutFragment = makeCacheable(
+	_parseResourceWithoutFragment
+);
 
 /**
  * @param {string} filename the filename which should be undone
@@ -328,7 +375,7 @@ exports.parseResource = (realFn => {
  * @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(/[\\/]$/, "");
@@ -340,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 !== ".") {
@@ -351,6 +398,6 @@ exports.getUndoPath = (filename, outputPath, enforceRelative) => {
 	return depth > 0
 		? `${"../".repeat(depth)}${append}`
 		: enforceRelative
-		? `./${append}`
-		: append;
+			? `./${append}`
+			: append;
 };

package/lib/util/internalSerializables.js

@@ -45,6 +45,10 @@ module.exports = {
 		require("../dependencies/AMDRequireItemDependency"),
 	"dependencies/CachedConstDependency": () =>
 		require("../dependencies/CachedConstDependency"),
+	"dependencies/ExternalModuleDependency": () =>
+		require("../dependencies/ExternalModuleDependency"),
+	"dependencies/ExternalModuleInitFragment": () =>
+		require("../dependencies/ExternalModuleInitFragment"),
 	"dependencies/CreateScriptUrlDependency": () =>
 		require("../dependencies/CreateScriptUrlDependency"),
 	"dependencies/CommonJsRequireContextDependency": () =>
@@ -67,6 +71,16 @@ module.exports = {
 		require("../dependencies/ContextElementDependency"),
 	"dependencies/CriticalDependencyWarning": () =>
 		require("../dependencies/CriticalDependencyWarning"),
+	"dependencies/CssImportDependency": () =>
+		require("../dependencies/CssImportDependency"),
+	"dependencies/CssLocalIdentifierDependency": () =>
+		require("../dependencies/CssLocalIdentifierDependency"),
+	"dependencies/CssSelfLocalIdentifierDependency": () =>
+		require("../dependencies/CssSelfLocalIdentifierDependency"),
+	"dependencies/CssExportDependency": () =>
+		require("../dependencies/CssExportDependency"),
+	"dependencies/CssUrlDependency": () =>
+		require("../dependencies/CssUrlDependency"),
 	"dependencies/DelegatedSourceDependency": () =>
 		require("../dependencies/DelegatedSourceDependency"),
 	"dependencies/DllEntryDependency": () =>
@@ -93,6 +107,8 @@ module.exports = {
 		require("../dependencies/HarmonyImportSideEffectDependency"),
 	"dependencies/HarmonyImportSpecifierDependency": () =>
 		require("../dependencies/HarmonyImportSpecifierDependency"),
+	"dependencies/HarmonyEvaluatedImportSpecifierDependency": () =>
+		require("../dependencies/HarmonyEvaluatedImportSpecifierDependency"),
 	"dependencies/ImportContextDependency": () =>
 		require("../dependencies/ImportContextDependency"),
 	"dependencies/ImportDependency": () =>
@@ -116,6 +132,8 @@ module.exports = {
 		require("../dependencies/ImportMetaHotAcceptDependency"),
 	"dependencies/ImportMetaHotDeclineDependency": () =>
 		require("../dependencies/ImportMetaHotDeclineDependency"),
+	"dependencies/ImportMetaContextDependency": () =>
+		require("../dependencies/ImportMetaContextDependency"),
 	"dependencies/ProvidedDependency": () =>
 		require("../dependencies/ProvidedDependency"),
 	"dependencies/PureExpressionDependency": () =>
@@ -175,6 +193,8 @@ module.exports = {
 	ModuleParseError: () => require("../ModuleParseError"),
 	ModuleWarning: () => require("../ModuleWarning"),
 	NormalModule: () => require("../NormalModule"),
+	CssModule: () => require("../CssModule"),
+	RawDataUrlModule: () => require("../asset/RawDataUrlModule"),
 	RawModule: () => require("../RawModule"),
 	"sharing/ConsumeSharedModule": () =>
 		require("../sharing/ConsumeSharedModule"),
@@ -190,6 +210,8 @@ module.exports = {
 	"util/LazySet": () => require("../util/LazySet"),
 	UnhandledSchemeError: () => require("../UnhandledSchemeError"),
 	NodeStuffInWebError: () => require("../NodeStuffInWebError"),
+	EnvironmentNotSupportAsyncWarning: () =>
+		require("../EnvironmentNotSupportAsyncWarning"),
 	WebpackError: () => require("../WebpackError"),
 
 	"util/registerExternalSerializer": () => {

package/lib/util/makeSerializable.js

@@ -6,6 +6,8 @@
 
 const { register } = require("./serialization");
 
+/** @typedef {import("../serialization/ObjectMiddleware").Constructor} Constructor */
+
 class ClassSerializer {
 	constructor(Constructor) {
 		this.Constructor = Constructor;
@@ -25,6 +27,11 @@ class ClassSerializer {
 	}
 }
 
+/**
+ * @param {Constructor} Constructor the constructor
+ * @param {string} request the request which will be required when deserializing
+ * @param {string | null} [name] the name to make multiple serializer unique when sharing a request
+ */
 module.exports = (Constructor, request, name = null) => {
 	register(Constructor, request, name, new ClassSerializer(Constructor));
 };

package/lib/util/memoize.js

@@ -13,19 +13,19 @@
  */
 const memoize = fn => {
 	let cache = false;
-	/** @type {T} */
-	let result = undefined;
+	/** @type {T | undefined} */
+	let result;
 	return () => {
 		if (cache) {
-			return result;
-		} else {
-			result = fn();
-			cache = true;
-			// Allow to clean up memory for fn
-			// and all dependent resources
-			fn = undefined;
-			return result;
+			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

@@ -0,0 +1,76 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("eslint-scope").Reference} Reference */
+/** @typedef {import("eslint-scope").Variable} Variable */
+/** @typedef {import("../javascript/JavascriptParser").AnyNode} AnyNode */
+/** @typedef {import("../javascript/JavascriptParser").Program} Program */
+
+/**
+ * @param {Variable} variable variable
+ * @returns {Reference[]} references
+ */
+const getAllReferences = variable => {
+	let set = variable.references;
+	// Look for inner scope variables too (like in class Foo { t() { Foo } })
+	const identifiers = new Set(variable.identifiers);
+	for (const scope of variable.scope.childScopes) {
+		for (const innerVar of scope.variables) {
+			if (innerVar.identifiers.some(id => identifiers.has(id))) {
+				set = set.concat(innerVar.references);
+				break;
+			}
+		}
+	}
+	return set;
+};
+
+/**
+ * @param {Program | Program[]} ast ast
+ * @param {AnyNode} node node
+ * @returns {undefined | AnyNode[]} result
+ */
+const getPathInAst = (ast, node) => {
+	if (ast === node) {
+		return [];
+	}
+
+	const nr = node.range;
+
+	const enterNode = n => {
+		if (!n) return;
+		const r = n.range;
+		if (r && r[0] <= nr[0] && r[1] >= nr[1]) {
+			const path = getPathInAst(n, node);
+			if (path) {
+				path.push(n);
+				return path;
+			}
+		}
+	};
+
+	if (Array.isArray(ast)) {
+		for (let i = 0; i < ast.length; i++) {
+			const enterResult = enterNode(ast[i]);
+			if (enterResult !== undefined) return enterResult;
+		}
+	} else if (ast && typeof ast === "object") {
+		const keys = Object.keys(ast);
+		for (let i = 0; i < keys.length; i++) {
+			const value = ast[keys[i]];
+			if (Array.isArray(value)) {
+				const pathResult = getPathInAst(value, node);
+				if (pathResult !== undefined) return pathResult;
+			} else if (value && typeof value === "object") {
+				const enterResult = enterNode(value);
+				if (enterResult !== undefined) return enterResult;
+			}
+		}
+	}
+};
+
+module.exports = { getAllReferences, getPathInAst };

package/lib/util/nonNumericOnlyHash.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const A_CODE = "a".charCodeAt(0);
+
+/**
+ * @param {string} hash hash
+ * @param {number} hashLength hash length
+ * @returns {string} returns hash that has at least one non numeric char
+ */
+module.exports = (hash, hashLength) => {
+	if (hashLength < 1) return "";
+	const slice = hash.slice(0, hashLength);
+	if (/[^\d]/.test(slice)) return slice;
+	return `${String.fromCharCode(
+		A_CODE + (Number.parseInt(hash[0], 10) % 6)
+	)}${slice.slice(1)}`;
+};