webpack 5.106.1 → 5.107.0

package/lib/util/identifier.js

@@ -11,6 +11,7 @@ const SEGMENTS_SPLIT_REGEXP = /([|!])/;
 const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
 
 /**
+ * Relative path to request.
  * @param {string} relativePath relative path
  * @returns {string} request
  */
@@ -22,6 +23,7 @@ const relativePathToRequest = (relativePath) => {
 };
 
 /**
+ * Absolute to request.
  * @param {string} context context for relative path
  * @param {string} maybeAbsolutePath path to make relative
  * @returns {string} relative path in request style
@@ -70,6 +72,7 @@ const absoluteToRequest = (context, maybeAbsolutePath) => {
 };
 
 /**
+ * Request to absolute.
  * @param {string} context context for relative path
  * @param {string} relativePath path
  * @returns {string} absolute path
@@ -84,27 +87,32 @@ const requestToAbsolute = (context, relativePath) => {
 /** @typedef {EXPECTED_OBJECT} AssociatedObjectForCache */
 
 /**
+ * Defines the make cacheable result type used by this module.
  * @template T
  * @typedef {(value: string, cache?: AssociatedObjectForCache) => T} MakeCacheableResult
  */
 
 /**
+ * Defines the bind cache result fn type used by this module.
  * @template T
  * @typedef {(value: string) => T} BindCacheResultFn
  */
 
 /**
+ * Defines the bind cache type used by this module.
  * @template T
  * @typedef {(cache: AssociatedObjectForCache) => BindCacheResultFn<T>} BindCache
  */
 
 /**
+ * Returns } cacheable function.
  * @template T
  * @param {((value: string) => T)} realFn real function
  * @returns {MakeCacheableResult<T> & { bindCache: BindCache<T> }} cacheable function
  */
 const makeCacheable = (realFn) => {
 	/**
+	 * Defines the cache item type used by this module.
 	 * @template T
 	 * @typedef {Map<string, T>} CacheItem
 	 */
@@ -112,6 +120,7 @@ const makeCacheable = (realFn) => {
 	const cache = new WeakMap();
 
 	/**
+	 * Returns cache item.
 	 * @param {AssociatedObjectForCache} associatedObjectForCache an object to which the cache will be attached
 	 * @returns {CacheItem<T>} cache item
 	 */
@@ -139,6 +148,7 @@ const makeCacheable = (realFn) => {
 	fn.bindCache = (associatedObjectForCache) => {
 		const cache = getCache(associatedObjectForCache);
 		/**
+		 * Returns value.
 		 * @param {string} str string
 		 * @returns {T} value
 		 */
@@ -161,6 +171,7 @@ const makeCacheable = (realFn) => {
 /** @typedef {(value: string, associatedObjectForCache?: AssociatedObjectForCache) => BindContextCacheForContextResultFn} BindContextCacheForContext */
 
 /**
+ * Creates cacheable with context.
  * @param {(context: string, identifier: string) => string} fn function
  * @returns {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} cacheable function with context
  */
@@ -211,6 +222,7 @@ const makeCacheableWithContext = (fn) => {
 		}
 
 		/**
+		 * Returns the returned relative path.
 		 * @param {string} context context used to create relative path
 		 * @param {string} identifier identifier used to create relative path
 		 * @returns {string} the returned relative path
@@ -256,6 +268,7 @@ const makeCacheableWithContext = (fn) => {
 		}
 
 		/**
+		 * Returns the returned relative path.
 		 * @param {string} identifier identifier used to create relative path
 		 * @returns {string} the returned relative path
 		 */
@@ -276,6 +289,7 @@ const makeCacheableWithContext = (fn) => {
 };
 
 /**
+ * Make paths relative.
  * @param {string} context context for relative path
  * @param {string} identifier identifier for path
  * @returns {string} a converted relative path
@@ -287,6 +301,7 @@ const _makePathsRelative = (context, identifier) =>
 		.join("");
 
 /**
+ * Make paths absolute.
  * @param {string} context context for relative path
  * @param {string} identifier identifier for path
  * @returns {string} a converted relative path
@@ -298,6 +313,7 @@ const _makePathsAbsolute = (context, identifier) =>
 		.join("");
 
 /**
+ * Returns a new request string avoiding absolute paths when possible.
  * @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
@@ -311,6 +327,7 @@ const _contextify = (context, request) =>
 const contextify = makeCacheableWithContext(_contextify);
 
 /**
+ * Returns a new request string using absolute paths when possible.
  * @param {string} context absolute context path
  * @param {string} request any request string
  * @returns {string} a new request string using absolute paths when possible
@@ -332,6 +349,7 @@ const ZERO_ESCAPE_REGEXP = /\0(.)/g;
 /** @typedef {{ resource: string, path: string, query: string }} ParsedResourceWithoutFragment */
 
 /**
+ * Returns parsed parts.
  * @param {string} str the path with query and fragment
  * @returns {ParsedResource} parsed parts
  */
@@ -428,6 +446,7 @@ const _parseResourceWithoutFragment = (str) => {
 };
 
 /**
+ * Returns repeated ../ to leave the directory of the provided filename to be back on output dir.
  * @param {string} filename the filename which should be undone
  * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
  * @param {boolean} enforceRelative true returns ./ for empty paths
@@ -460,9 +479,57 @@ const getUndoPath = (filename, outputPath, enforceRelative) => {
 			: append;
 };
 
+const HASH_REGEXP = /(?<!\0)#/g;
+
+/**
+ * Escape `#` characters that appear inside a path request's directory portion
+ * with the `\0#` escape recognized by enhanced-resolve, so a project located at
+ * a path like `/home/user/proj#1/` (or `./proj#1/`) resolves correctly. Applies
+ * to absolute paths (Unix or Windows) and relative paths (starting with `./` or
+ * `../`). Only triggers when a query string is present, because that is the case
+ * where the resolver's parseIdentifier fails (without a `?`, the resolver
+ * handles directory `#` via its own fallback). A `#` after the last path
+ * separator is left alone so that explicit fragment requests like
+ * `/abs/path/file.js#fragment` still behave the same. Bare module specifiers
+ * are not touched. Already-escaped `\0#` sequences are preserved so the
+ * explicit opt-out remains stable.
+ * @param {string} request request to potentially escape
+ * @returns {string} request with directory `#` characters escaped
+ */
+const escapeHashInPathRequest = (request) => {
+	if (request.length === 0) return request;
+	const queryStart = request.indexOf("?");
+	if (queryStart < 0) return request;
+	const hashStart = request.indexOf("#");
+	if (hashStart < 0 || hashStart >= queryStart) return request;
+	const c0 = request.charCodeAt(0);
+	const isAbsolute =
+		c0 === 47 /* "/" */ || WINDOWS_ABS_PATH_REGEXP.test(request);
+	let isRelative = false;
+	if (!isAbsolute && c0 === 46 /* "." */) {
+		const c1 = request.charCodeAt(1);
+		if (c1 === 47 || c1 === 92 /* "/" or "\" */) {
+			isRelative = true;
+		} else if (c1 === 46 /* "." */) {
+			const c2 = request.charCodeAt(2);
+			if (c2 === 47 || c2 === 92) isRelative = true;
+		}
+	}
+	if (!isAbsolute && !isRelative) return request;
+	const lastSep = Math.max(
+		request.lastIndexOf("/", queryStart - 1),
+		request.lastIndexOf("\\", queryStart - 1)
+	);
+	if (hashStart >= lastSep) return request;
+	const pathPart = request.slice(0, lastSep);
+	return pathPart.replace(HASH_REGEXP, "\0#") + request.slice(lastSep);
+};
+
 module.exports.absolutify = absolutify;
 module.exports.contextify = contextify;
+module.exports.escapeHashInPathRequest = escapeHashInPathRequest;
 module.exports.getUndoPath = getUndoPath;
+module.exports.makeCacheable = makeCacheable;
 module.exports.makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);
 module.exports.makePathsRelative = makeCacheableWithContext(_makePathsRelative);
 module.exports.parseResource = makeCacheable(_parseResource);

package/lib/util/internalSerializables.js

@@ -12,7 +12,6 @@
 // to process this
 module.exports = {
 	AsyncDependenciesBlock: () => require("../AsyncDependenciesBlock"),
-	CommentCompilationWarning: () => require("../CommentCompilationWarning"),
 	ContextModule: () => require("../ContextModule"),
 	"cache/PackFileCacheStrategy": () =>
 		require("../cache/PackFileCacheStrategy"),
@@ -109,6 +108,14 @@ module.exports = {
 		require("../dependencies/HarmonyImportSpecifierDependency"),
 	"dependencies/HarmonyEvaluatedImportSpecifierDependency": () =>
 		require("../dependencies/HarmonyEvaluatedImportSpecifierDependency"),
+	"dependencies/HtmlInlineScriptDependency": () =>
+		require("../dependencies/HtmlInlineScriptDependency"),
+	"dependencies/HtmlInlineStyleDependency": () =>
+		require("../dependencies/HtmlInlineStyleDependency"),
+	"dependencies/HtmlScriptSrcDependency": () =>
+		require("../dependencies/HtmlScriptSrcDependency"),
+	"dependencies/HtmlSourceDependency": () =>
+		require("../dependencies/HtmlSourceDependency"),
 	"dependencies/ImportContextDependency": () =>
 		require("../dependencies/ImportContextDependency"),
 	"dependencies/ImportDependency": () =>
@@ -179,23 +186,14 @@ module.exports = {
 	"json/JsonData": () => require("../json/JsonData"),
 	"optimize/ConcatenatedModule": () =>
 		require("../optimize/ConcatenatedModule"),
-	DelegatedModule: () => require("../DelegatedModule"),
+
 	DependenciesBlock: () => require("../DependenciesBlock"),
-	DllModule: () => require("../DllModule"),
 	ExternalModule: () => require("../ExternalModule"),
 	FileSystemInfo: () => require("../FileSystemInfo"),
 	InitFragment: () => require("../InitFragment"),
-	InvalidDependenciesModuleWarning: () =>
-		require("../InvalidDependenciesModuleWarning"),
-	Module: () => require("../Module"),
-	ModuleBuildError: () => require("../ModuleBuildError"),
-	ModuleDependencyWarning: () => require("../ModuleDependencyWarning"),
-	ModuleError: () => require("../ModuleError"),
 	ModuleGraph: () => require("../ModuleGraph"),
-	ModuleParseError: () => require("../ModuleParseError"),
-	ModuleWarning: () => require("../ModuleWarning"),
 	NormalModule: () => require("../NormalModule"),
-	CssModule: () => require("../CssModule"),
+	CssModule: () => require("../css/CssModule"),
 	RawDataUrlModule: () => require("../asset/RawDataUrlModule"),
 	RawModule: () => require("../RawModule"),
 	"sharing/ConsumeSharedModule": () =>
@@ -208,14 +206,32 @@ module.exports = {
 		require("../sharing/ProvideSharedDependency"),
 	"sharing/ProvideForSharedDependency": () =>
 		require("../sharing/ProvideForSharedDependency"),
-	UnsupportedFeatureWarning: () => require("../UnsupportedFeatureWarning"),
-	"util/LazySet": () => require("../util/LazySet"),
-	UnhandledSchemeError: () => require("../UnhandledSchemeError"),
-	NodeStuffInWebError: () => require("../NodeStuffInWebError"),
-	EnvironmentNotSupportAsyncWarning: () =>
-		require("../EnvironmentNotSupportAsyncWarning"),
-	WebpackError: () => require("../WebpackError"),
 
+	"errors/WebpackError": () => require("../errors/WebpackError"),
+	"errors/InvalidDependenciesModuleWarning": () =>
+		require("../errors/InvalidDependenciesModuleWarning"),
+	"errors/Module": () => require("../Module"),
+	"errors/ModuleParseError": () => require("../errors/ModuleParseError"),
+	"errors/ModuleWarning": () => require("../errors/ModuleWarning"),
+	"errors/ModuleBuildError": () => require("../errors/ModuleBuildError"),
+	"errors/ModuleDependencyWarning": () =>
+		require("../errors/ModuleDependencyWarning"),
+	"errors/ModuleError": () => require("../errors/ModuleError"),
+	"errors/UnhandledSchemeError": () =>
+		require("../errors/UnhandledSchemeError"),
+	"errors/UnsupportedFeatureWarning": () =>
+		require("../errors/UnsupportedFeatureWarning"),
+	"errors/EnvironmentNotSupportAsyncWarning": () =>
+		require("../errors/EnvironmentNotSupportAsyncWarning"),
+	"errors/CommentCompilationWarning": () =>
+		require("../errors/CommentCompilationWarning"),
+	"errors/NodeStuffInWebError": () => require("../errors/NodeStuffInWebError"),
+	"errors/JSONParseError": () => require("../errors/JSONParseError"),
+
+	"dll/DelegatedModule": () => require("../dll/DelegatedModule"),
+	"dll/DllModule": () => require("../dll/DllModule"),
+
+	"util/LazySet": () => require("../util/LazySet"),
 	"util/registerExternalSerializer": () => {
 		// already registered
 	}

package/lib/util/magicComment.js

@@ -9,17 +9,21 @@ const memoize = require("./memoize");
 
 const getVm = memoize(() => require("vm"));
 
-// regexp to match at least one "magic comment"
+module.exports.CompilerHintNotationRegExp = Object.freeze({
+	Pure: /^\s*(?:#|@)__PURE__\s*$/,
+	NoSideEffects: /^\s*[#@]__NO_SIDE_EFFECTS__\s*$/
+});
+
+/**
+ * regexp to match at least one "magic comment"
+ * @returns {import("vm").Context} magic comment context
+ */
 module.exports.createMagicCommentContext = () =>
 	getVm().createContext(undefined, {
 		name: "Webpack Magic Comment Parser",
 		codeGeneration: { strings: false, wasm: false }
 	});
+
 module.exports.webpackCommentRegExp = new RegExp(
 	/(^|\W)webpack[A-Z][A-Za-z]+:/
 );
-
-// regexp to match at least one "magic comment"
-/**
- * @returns {import("vm").Context} magic comment context
- */

package/lib/util/makeSerializable.js

@@ -12,15 +12,18 @@ const { register } = require("./serialization");
 
 /** @typedef {{ serialize: (context: ObjectSerializerContext) => void, deserialize: (context: ObjectDeserializerContext) => void }} SerializableClass */
 /**
+ * Defines the serializable class constructor type used by this module.
  * @template {SerializableClass} T
  * @typedef {(new (...params: EXPECTED_ANY[]) => T) & { deserialize?: (context: ObjectDeserializerContext) => T }} SerializableClassConstructor
  */
 
 /**
+ * Represents ClassSerializer.
  * @template {SerializableClass} T
  */
 class ClassSerializer {
 	/**
+	 * Creates an instance of ClassSerializer.
 	 * @param {SerializableClassConstructor<T>} Constructor constructor
 	 */
 	constructor(Constructor) {
@@ -28,6 +31,7 @@ class ClassSerializer {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {T} obj obj
 	 * @param {ObjectSerializerContext} context context
 	 */
@@ -36,6 +40,7 @@ class ClassSerializer {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 * @returns {T} obj
 	 */
@@ -50,6 +55,7 @@ class ClassSerializer {
 }
 
 /**
+ * Processes the provided constructor.
  * @template {Constructor} T
  * @param {T} Constructor the constructor
  * @param {string} request the request which will be required when deserializing

package/lib/util/memoize.js

@@ -5,11 +5,13 @@
 "use strict";
 
 /**
+ * Defines the function returning type used by this module.
  * @template T
  * @typedef {() => T} FunctionReturning
  */
 
 /**
+ * Returns new function.
  * @template T
  * @param {FunctionReturning<T>} fn memorized function
  * @returns {FunctionReturning<T>} new function

package/lib/util/mimeTypes.js

@@ -0,0 +1,176 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const { extname } = require("path");
+const db = require("mime-db");
+
+/**
+ * RegExp to match type in RFC 6838
+ *
+ * type-name = restricted-name
+ * subtype-name = restricted-name
+ * restricted-name = restricted-name-first *126restricted-name-chars
+ * restricted-name-first  = ALPHA / DIGIT
+ * restricted-name-chars  = ALPHA / DIGIT / "!" / "#" / "$" / "&" / "-" / "^" / "_"
+ * restricted-name-chars =/ "." ; Characters before first dot always specify a facet name
+ * restricted-name-chars =/ "+" ; Characters after last plus always specify a structured syntax suffix
+ * ALPHA =  %x41-5A / %x61-7A   ; A-Z / a-z
+ * DIGIT =  %x30-39             ; 0-9
+ */
+const TYPE_REGEXP =
+	/^ *(([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126})) *(?:;.*)?$/;
+const extensions = Object.create(null);
+const types = Object.create(null);
+
+// Score RFC facets (see https://tools.ietf.org/html/rfc6838#section-3)
+
+/** @type {Record<string, number>} */
+const FACET_SCORES = {
+	"prs.": 100,
+	"x-": 200,
+	"x.": 300,
+	"vnd.": 400,
+	default: 900
+};
+
+/** @typedef {"nginx" | "apache" | "iana" | "default"} SourceScore */
+
+// Score mime source (Logic originally from `jshttp/mime-types` module)
+/** @type {Record<SourceScore, number>} */
+const SOURCE_SCORES = {
+	nginx: 10,
+	apache: 20,
+	iana: 40,
+	default: 30
+};
+
+/** @type {Record<string, number>} */
+const TYPE_SCORES = {
+	// prefer application/xml over text/xml
+	// prefer application/rtf over text/rtf
+	application: 1,
+
+	// prefer font/woff over application/font-woff
+	font: 2,
+
+	// prefer video/mp4 over audio/mp4 over application/mp4
+	// See https://www.rfc-editor.org/rfc/rfc4337.html#section-2
+	audio: 2,
+	video: 3,
+
+	default: 0
+};
+
+/**
+ * @param {string} mimeType mime type
+ * @param {SourceScore=} source source
+ * @returns {number} min score
+ */
+function mimeScore(mimeType, source = "default") {
+	if (mimeType === "application/octet-stream") {
+		return 0;
+	}
+
+	const [type, subtype] = mimeType.split("/");
+
+	const facet = subtype.replace(/(\.|x-).*/, "$1");
+
+	const facetScore = FACET_SCORES[facet] || FACET_SCORES.default;
+	const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default;
+	const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default;
+
+	// All else being equal prefer shorter types
+	const lengthScore = 1 - mimeType.length / 100;
+
+	return facetScore + sourceScore + typeScore + lengthScore;
+}
+
+/**
+ * @param {string} ext extension
+ * @param {string} type0 the first type
+ * @param {string} type1 the second type
+ * @returns {string} preferred type
+ */
+const preferredType = (ext, type0, type1) => {
+	const score0 = type0 ? mimeScore(type0, db[type0].source) : 0;
+	const score1 = type1 ? mimeScore(type1, db[type1].source) : 0;
+
+	return score0 > score1 ? type0 : type1;
+};
+
+/**
+ * @param {Record<string, readonly string[]>} extensions extensions
+ * @param {Record<string, string>} types types
+ */
+const populate = (extensions, types) => {
+	for (const type of Object.keys(db)) {
+		const mime = db[type];
+		const foundExtensions = mime.extensions;
+
+		if (!foundExtensions || foundExtensions.length === 0) {
+			continue;
+		}
+
+		// mime -> extensions
+		extensions[type] = foundExtensions;
+
+		// extension -> mime
+		for (let i = 0; i < foundExtensions.length; i++) {
+			const extension = foundExtensions[i];
+
+			types[extension] = preferredType(extension, types[extension], type);
+		}
+	}
+};
+
+populate(extensions, types);
+
+/**
+ * Get the default extension for a MIME type.
+ * @param {string} type type
+ * @returns {undefined | string} resolve extension
+ */
+const extension = (type) => {
+	if (!type) {
+		return;
+	}
+
+	const match = TYPE_REGEXP.exec(type);
+
+	if (!match) {
+		return;
+	}
+
+	const possibleExtensions = extensions[match[1].toLowerCase()];
+
+	if (!possibleExtensions || possibleExtensions.length === 0) {
+		return;
+	}
+
+	return possibleExtensions[0];
+};
+
+/**
+ * Lookup the MIME type for a file path/extension.
+ * @param {string} path path
+ * @returns {undefined | string} resolved MIME type
+ */
+const lookup = (path) => {
+	if (!path) {
+		return;
+	}
+
+	// get the extension ("ext" or ".ext" or full path)
+	const extension = extname(`x.${path}`).toLowerCase().slice(1);
+
+	if (!extension) {
+		return;
+	}
+
+	return types[extension];
+};
+
+module.exports = { extension, lookup };

package/lib/util/nonNumericOnlyHash.js

@@ -8,6 +8,7 @@
 const A_CODE = "a".charCodeAt(0);
 
 /**
+ * Returns hash that has at least one non numeric char.
  * @param {string} hash hash
  * @param {number} hashLength hash length
  * @returns {string} returns hash that has at least one non numeric char

package/lib/util/parseJson.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const JSONParseError = require("../errors/JSONParseError");
+
+/** @typedef {import("../util/fs").JsonValue} JsonValue */
+
+// Inspired by https://github.com/npm/json-parse-even-better-errors
+
+// Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
+// because the buffer-to-string conversion in `fs.readFileSync()`
+// translates it to FEFF, the UTF-16 BOM.
+/**
+ * @param {string | Buffer} txt text
+ * @returns {string} text without BOM
+ */
+const stripBOM = (txt) => String(txt).replace(/^\uFEFF/, "");
+
+/**
+ * @template [R=JsonValue]
+ * @callback ParseJsonFn
+ * @param {string} raw text
+ * @param {(this: EXPECTED_ANY, key: string, value: EXPECTED_ANY) => EXPECTED_ANY=} reviver reviver
+ * @returns {R} parsed JSON
+ */
+
+/** @type {ParseJsonFn} */
+const parseJson = (raw, reviver) => {
+	const txt = stripBOM(raw);
+
+	try {
+		return JSON.parse(txt, reviver);
+	} catch (err) {
+		throw new JSONParseError(/** @type {Error} */ (err), raw, txt);
+	}
+};
+
+module.exports = parseJson;

package/lib/util/processAsyncTree.js

@@ -6,6 +6,10 @@
 "use strict";
 
 /**
+ * Walks a dynamically expanding async work tree with bounded concurrency.
+ * Each processed item may enqueue more items through `push`, allowing callers
+ * to model breadth-first or depth-first discovery without managing the queue
+ * themselves.
  * @template T
  * @template {Error} E
  * @param {Iterable<T>} items initial items
@@ -22,6 +26,8 @@ const processAsyncTree = (items, concurrency, processor, callback) => {
 	let processScheduled = true;
 
 	/**
+	 * Enqueues a newly discovered item and schedules queue processing when the
+	 * current concurrency budget allows more work to start.
 	 * @param {T} item item
 	 */
 	const push = (item) => {
@@ -33,6 +39,8 @@ const processAsyncTree = (items, concurrency, processor, callback) => {
 	};
 
 	/**
+	 * Handles completion of a single processor call, propagating the first
+	 * error and scheduling more queued work when possible.
 	 * @param {E | null | undefined} err error
 	 */
 	const processorCallback = (err) => {

package/lib/util/property.js

@@ -74,6 +74,7 @@ const propertyName = (prop) => {
 };
 
 /**
+ * Returns chain of property accesses.
  * @param {ArrayLike<string>} properties properties
  * @param {number} start start index
  * @returns {string} chain of property accesses