webpack 5.106.0 → 5.106.2

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

package/lib/util/magicComment.js

@@ -21,5 +21,6 @@ module.exports.webpackCommentRegExp = new RegExp(
 
 // regexp to match at least one "magic comment"
 /**
+ * Returns magic comment context.
  * @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,112 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/** @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/, "");
+
+class JSONParseError extends SyntaxError {
+	/**
+	 * @param {Error} err err
+	 * @param {EXPECTED_ANY} raw raw
+	 * @param {string} txt text
+	 * @param {number=} context context
+	 * @param {EXPECTED_FUNCTION=} caller caller
+	 */
+	constructor(err, raw, txt, context = 20, caller = parseJson) {
+		let originalMessage = err.message;
+		/** @type {string} */
+		let message;
+		/** @type {number} */
+		let position;
+
+		if (typeof raw !== "string") {
+			message = `Cannot parse ${Array.isArray(raw) && raw.length === 0 ? "an empty array" : String(raw)}`;
+			position = 0;
+		} else if (!txt) {
+			message = `${originalMessage} while parsing empty string`;
+			position = 0;
+		} else {
+			// Node 20 puts single quotes around the token and a comma after it
+			const UNEXPECTED_TOKEN = /^Unexpected token '?(.)'?(,)? /i;
+			const badTokenMatch = originalMessage.match(UNEXPECTED_TOKEN);
+			const badIndexMatch = originalMessage.match(/ position\s+(\d+)/i);
+
+			if (badTokenMatch) {
+				const h = badTokenMatch[1].charCodeAt(0).toString(16).toUpperCase();
+				const hex = `0x${h.length % 2 ? "0" : ""}${h}`;
+
+				originalMessage = originalMessage.replace(
+					UNEXPECTED_TOKEN,
+					`Unexpected token ${JSON.stringify(badTokenMatch[1])} (${hex})$2 `
+				);
+			}
+
+			/** @type {number | undefined} */
+			let errIdx;
+
+			if (badIndexMatch) {
+				errIdx = Number(badIndexMatch[1]);
+			} else if (
+				// doesn't happen in Node 22+
+				/^Unexpected end of JSON.*/i.test(originalMessage)
+			) {
+				errIdx = txt.length - 1;
+			}
+
+			if (errIdx === undefined) {
+				message = `${originalMessage} while parsing '${txt.slice(0, context * 2)}'`;
+				position = 0;
+			} else {
+				const start = errIdx <= context ? 0 : errIdx - context;
+				const end =
+					errIdx + context >= txt.length ? txt.length : errIdx + context;
+				const slice = `${start ? "..." : ""}${txt.slice(start, end)}${end === txt.length ? "" : "..."}`;
+
+				message = `${originalMessage} while parsing ${txt === slice ? "" : "near "}${JSON.stringify(slice)}`;
+				position = errIdx;
+			}
+		}
+
+		super(message);
+
+		this.name = "JSONParseError";
+		this.systemError = err;
+		this.position = position;
+
+		Error.captureStackTrace(this, caller || this.constructor);
+	}
+}
+
+/**
+ * @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

package/lib/util/registerExternalSerializer.js

@@ -33,6 +33,7 @@ register(
 	"webpack-sources/CachedSource",
 	new (class CachedSourceSerializer {
 		/**
+		 * Serializes this instance into the provided serializer context.
 		 * @param {CachedSource} source the cached source to be serialized
 		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
@@ -47,6 +48,7 @@ register(
 		}
 
 		/**
+		 * Restores this instance from the provided deserializer context.
 		 * @param {ObjectDeserializerContext} context context
 		 * @returns {CachedSource} cached source
 		 */
@@ -64,6 +66,7 @@ register(
 	"webpack-sources/RawSource",
 	new (class RawSourceSerializer {
 		/**
+		 * Serializes this instance into the provided serializer context.
 		 * @param {RawSource} source the raw source to be serialized
 		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
@@ -74,6 +77,7 @@ register(
 		}
 
 		/**
+		 * Restores this instance from the provided deserializer context.
 		 * @param {ObjectDeserializerContext} context context
 		 * @returns {RawSource} raw source
 		 */
@@ -91,6 +95,7 @@ register(
 	"webpack-sources/ConcatSource",
 	new (class ConcatSourceSerializer {
 		/**
+		 * Serializes this instance into the provided serializer context.
 		 * @param {ConcatSource} source the concat source to be serialized
 		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
@@ -100,6 +105,7 @@ register(
 		}
 
 		/**
+		 * Restores this instance from the provided deserializer context.
 		 * @param {ObjectDeserializerContext} context context
 		 * @returns {ConcatSource} concat source
 		 */
@@ -117,6 +123,7 @@ register(
 	"webpack-sources/PrefixSource",
 	new (class PrefixSourceSerializer {
 		/**
+		 * Serializes this instance into the provided serializer context.
 		 * @param {PrefixSource} source the prefix source to be serialized
 		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
@@ -127,6 +134,7 @@ register(
 		}
 
 		/**
+		 * Restores this instance from the provided deserializer context.
 		 * @param {ObjectDeserializerContext} context context
 		 * @returns {PrefixSource} prefix source
 		 */
@@ -142,6 +150,7 @@ register(
 	"webpack-sources/ReplaceSource",
 	new (class ReplaceSourceSerializer {
 		/**
+		 * Serializes this instance into the provided serializer context.
 		 * @param {ReplaceSource} source the replace source to be serialized
 		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
@@ -162,6 +171,7 @@ register(
 		}
 
 		/**
+		 * Restores this instance from the provided deserializer context.
 		 * @param {ObjectDeserializerContext} context context
 		 * @returns {ReplaceSource} replace source
 		 */
@@ -193,6 +203,7 @@ register(
 	"webpack-sources/OriginalSource",
 	new (class OriginalSourceSerializer {
 		/**
+		 * Serializes this instance into the provided serializer context.
 		 * @param {OriginalSource} source the original source to be serialized
 		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
@@ -203,6 +214,7 @@ register(
 		}
 
 		/**
+		 * Restores this instance from the provided deserializer context.
 		 * @param {ObjectDeserializerContext} context context
 		 * @returns {OriginalSource} original source
 		 */
@@ -220,6 +232,7 @@ register(
 	"acorn/SourceLocation",
 	new (class SourceLocationSerializer {
 		/**
+		 * Serializes this instance into the provided serializer context.
 		 * @param {SourceLocation} loc the location to be serialized
 		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
@@ -232,6 +245,7 @@ register(
 		}
 
 		/**
+		 * Restores this instance from the provided deserializer context.
 		 * @param {ObjectDeserializerContext} context context
 		 * @returns {RealDependencyLocation} location
 		 */
@@ -256,6 +270,7 @@ register(
 	"acorn/Position",
 	new (class PositionSerializer {
 		/**
+		 * Serializes this instance into the provided serializer context.
 		 * @param {Position} pos the position to be serialized
 		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
@@ -266,6 +281,7 @@ register(
 		}
 
 		/**
+		 * Restores this instance from the provided deserializer context.
 		 * @param {ObjectDeserializerContext} context context
 		 * @returns {SourcePosition} position
 		 */
@@ -284,6 +300,7 @@ register(
 	"webpack-sources/SourceMapSource",
 	new (class SourceMapSourceSerializer {
 		/**
+		 * Serializes this instance into the provided serializer context.
 		 * @param {SourceMapSource} source the source map source to be serialized
 		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
@@ -293,6 +310,7 @@ register(
 		}
 
 		/**
+		 * Restores this instance from the provided deserializer context.
 		 * @param {ObjectDeserializerContext} context context
 		 * @returns {SourceMapSource} source source map source
 		 */
@@ -309,6 +327,7 @@ register(
 	"schema-utils/ValidationError",
 	new (class ValidationErrorSerializer {
 		/**
+		 * Serializes this instance into the provided serializer context.
 		 * @param {ValidationError} error the source map source to be serialized
 		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
@@ -324,6 +343,7 @@ register(
 		}
 
 		/**
+		 * Restores this instance from the provided deserializer context.
 		 * @param {ObjectDeserializerContext} context context
 		 * @returns {ValidationError} error
 		 */

package/lib/util/removeBOM.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /**
+ * Returns result without BOM.
  * @param {string | Buffer} strOrBuffer string or buffer
  * @returns {string | Buffer} result without BOM
  */