webpack 5.76.1 → 5.88.0

package/lib/stats/DefaultStatsPresetPlugin.js

@@ -47,6 +47,8 @@ const NAMED_PRESETS = {
 		orphanModules: true,
 		runtimeModules: true,
 		exclude: false,
+		errorsSpace: Infinity,
+		warningsSpace: Infinity,
 		modulesSpace: Infinity,
 		chunkModulesSpace: Infinity,
 		assetsSpace: Infinity,
@@ -73,6 +75,8 @@ const NAMED_PRESETS = {
 		logging: true,
 		runtimeModules: true,
 		exclude: false,
+		errorsSpace: 1000,
+		warningsSpace: 1000,
 		modulesSpace: 1000,
 		assetsSpace: 1000,
 		reasonsSpace: 1000
@@ -82,6 +86,8 @@ const NAMED_PRESETS = {
 		version: true,
 		timings: true,
 		modules: true,
+		errorsSpace: 0,
+		warningsSpace: 0,
 		modulesSpace: 0,
 		assets: true,
 		assetsSpace: 0,
@@ -95,6 +101,7 @@ const NAMED_PRESETS = {
 		all: false,
 		errors: true,
 		errorsCount: true,
+		errorsSpace: Infinity,
 		moduleTrace: true,
 		logging: "error"
 	},
@@ -102,8 +109,10 @@ const NAMED_PRESETS = {
 		all: false,
 		errors: true,
 		errorsCount: true,
+		errorsSpace: Infinity,
 		warnings: true,
 		warningsCount: true,
+		warningsSpace: Infinity,
 		logging: "warn"
 	},
 	summary: {

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -10,7 +10,14 @@
 /** @typedef {import("./StatsPrinter").StatsPrinterContext} StatsPrinterContext */
 
 const DATA_URI_CONTENT_LENGTH = 16;
+const MAX_MODULE_IDENTIFIER_LENGTH = 80;
 
+/**
+ * @param {number} n a number
+ * @param {string} singular singular
+ * @param {string} plural plural
+ * @returns {string} if n is 1, singular, else plural
+ */
 const plural = (n, singular, plural) => (n === 1 ? singular : plural);
 
 /**
@@ -28,6 +35,10 @@ const printSizes = (sizes, { formatSize = n => `${n}` }) => {
 	}
 };
 
+/**
+ * @param {string} resource resource
+ * @returns {string} resource name for display
+ */
 const getResourceName = resource => {
 	const dataUrl = /^data:[^,]+,/.exec(resource);
 	if (!dataUrl) return resource;
@@ -40,11 +51,33 @@ const getResourceName = resource => {
 	)}..`;
 };
 
+/**
+ * @param {string} name module name
+ * @returns {[string,string]} prefix and module name
+ */
 const getModuleName = name => {
 	const [, prefix, resource] = /^(.*!)?([^!]*)$/.exec(name);
+
+	if (resource.length > MAX_MODULE_IDENTIFIER_LENGTH) {
+		const truncatedResource = `${resource.slice(
+			0,
+			Math.min(
+				resource.length - /* '...(truncated)'.length */ 14,
+				MAX_MODULE_IDENTIFIER_LENGTH
+			)
+		)}...(truncated)`;
+
+		return [prefix, getResourceName(truncatedResource)];
+	}
+
 	return [prefix, getResourceName(resource)];
 };
 
+/**
+ * @param {string} str string
+ * @param {function(string): string} fn function to apply to each line
+ * @returns {string} joined string
+ */
 const mapLines = (str, fn) => str.split("\n").map(fn).join("\n");
 
 /**
@@ -57,6 +90,12 @@ const isValidId = id => {
 	return typeof id === "number" || id;
 };
 
+/**
+ * @template T
+ * @param {Array<T>} list of items
+ * @param {number} count number of items to show
+ * @returns {string} string representation of list
+ */
 const moreCount = (list, count) => {
 	return list && list.length > 0 ? `+ ${count}` : `${count}`;
 };
@@ -589,6 +628,8 @@ const SIMPLE_PRINTERS = {
 	"error.message": (message, { bold, formatError }) =>
 		message.includes("\u001b[") ? message : bold(formatError(message)),
 	"error.details": (details, { formatError }) => formatError(details),
+	"error.filteredDetails": filteredDetails =>
+		filteredDetails ? `+ ${filteredDetails} hidden lines` : undefined,
 	"error.stack": stack => stack,
 	"error.moduleTrace": moduleTrace => undefined,
 	"error.separator!": () => "\n",
@@ -689,6 +730,8 @@ const ERROR_PREFERRED_ORDER = [
 	"separator!",
 	"details",
 	"separator!",
+	"filteredDetails",
+	"separator!",
 	"stack",
 	"separator!",
 	"missing",

package/lib/util/AsyncQueue.js

@@ -70,7 +70,7 @@ class AsyncQueue {
 		this._entries = new Map();
 		/** @type {ArrayQueue<AsyncQueueEntry<T, K, R>>} */
 		this._queued = new ArrayQueue();
-		/** @type {AsyncQueue<any, any, any>[]} */
+		/** @type {AsyncQueue<any, any, any>[] | undefined} */
 		this._children = undefined;
 		this._activeTasks = 0;
 		this._willEnsureProcessing = false;
@@ -159,7 +159,9 @@ class AsyncQueue {
 	 */
 	invalidate(item) {
 		const key = this._getKey(item);
-		const entry = this._entries.get(key);
+		const entry =
+			/** @type {AsyncQueueEntry<T, K, R>} */
+			(this._entries.get(key));
 		this._entries.delete(key);
 		if (entry.state === QUEUED_STATE) {
 			this._queued.delete(entry);

package/lib/util/LazySet.js

@@ -87,7 +87,7 @@ class LazySet {
 
 	/**
 	 * @param {T} item an item
-	 * @returns {this} itself
+	 * @returns {LazySet<T>} itself
 	 */
 	add(item) {
 		this._set.add(item);
@@ -96,7 +96,7 @@ class LazySet {
 
 	/**
 	 * @param {Iterable<T> | LazySet<T>} iterable a immutable iterable or another immutable LazySet which will eventually be merged into the Set
-	 * @returns {this} itself
+	 * @returns {LazySet<T>} itself
 	 */
 	addAll(iterable) {
 		if (this._deopt) {
@@ -187,12 +187,20 @@ class LazySet {
 		return "LazySet";
 	}
 
+	/**
+	 * @param {import("../serialization/ObjectMiddleware").ObjectSerializerContext} context context
+	 */
 	serialize({ write }) {
 		if (this._needMerge) this._merge();
 		write(this._set.size);
 		for (const item of this._set) write(item);
 	}
 
+	/**
+	 * @template T
+	 * @param {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} context context
+	 * @returns {LazySet<T>} lazy set
+	 */
 	static deserialize({ read }) {
 		const count = read();
 		const items = [];

package/lib/util/MapHelpers.js

@@ -6,16 +6,30 @@
 "use strict";
 
 /**
+ * getOrInsert is a helper function for maps that allows you to get a value
+ * from a map if it exists, or insert a new value if it doesn't. If it value doesn't
+ * exist, it will be computed by the provided function.
+ *
  * @template K
  * @template V
- * @param {Map<K, V>} map a map
- * @param {K} key the key
- * @param {function(): V} computer compute value
- * @returns {V} value
+ * @param {Map<K, V>} map The map object to check
+ * @param {K} key The key to check
+ * @param {function(): V} computer function which will compute the value if it doesn't exist
+ * @returns {V} The value from the map, or the computed value
+ *
+ * @example
+ * ```js
+ * const map = new Map();
+ * const value = getOrInsert(map, "key", () => "value");
+ * console.log(value); // "value"
+ * ```
  */
-exports.provide = (map, key, computer) => {
+exports.getOrInsert = (map, key, computer) => {
+	// Grab key from map
 	const value = map.get(key);
+	// If the value already exists, return it
 	if (value !== undefined) return value;
+	// Otherwise compute the value, set it in the map, and return it
 	const newValue = computer();
 	map.set(key, newValue);
 	return newValue;

package/lib/util/ParallelismFactorCalculator.js

@@ -7,12 +7,22 @@
 
 const binarySearchBounds = require("../util/binarySearchBounds");
 
+/** @typedef {function(number): void} Callback */
+
 class ParallelismFactorCalculator {
 	constructor() {
+		/** @type {number[]} */
 		this._rangePoints = [];
+		/** @type {Callback[]} */
 		this._rangeCallbacks = [];
 	}
 
+	/**
+	 * @param {number} start range start
+	 * @param {number} end range end
+	 * @param {Callback} callback callback
+	 * @returns {void}
+	 */
 	range(start, end, callback) {
 		if (start === end) return callback(1);
 		this._rangePoints.push(start);

package/lib/util/Semaphore.js

@@ -44,7 +44,7 @@ class Semaphore {
 		if (this.available > 0) {
 			if (this.waiters.length > 0) {
 				this.available--;
-				const callback = this.waiters.pop();
+				const callback = /** @type {(function(): void)} */ (this.waiters.pop());
 				callback();
 			}
 		}

package/lib/util/StackedCacheMap.js

@@ -83,6 +83,9 @@ class StackedCacheMap {
 		this.map.clear();
 	}
 
+	/**
+	 * @returns {number} size of the map
+	 */
 	get size() {
 		let size = this.map.size;
 		for (const map of this.stack) {
@@ -91,6 +94,9 @@ class StackedCacheMap {
 		return size;
 	}
 
+	/**
+	 * @returns {Iterator<[K, V]>} iterator
+	 */
 	[Symbol.iterator]() {
 		const iterators = this.stack.map(map => map[Symbol.iterator]());
 		let current = this.map[Symbol.iterator]();

package/lib/util/StringXor.js

@@ -5,12 +5,46 @@
 
 "use strict";
 
+/** @typedef {import("../util/Hash")} Hash */
+
+/**
+ * StringXor class provides methods for performing
+ * [XOR operations](https://en.wikipedia.org/wiki/Exclusive_or) on strings. In this context
+ * we operating on the character codes of two strings, which are represented as
+ * [Buffer](https://nodejs.org/api/buffer.html) objects.
+ *
+ * We use [StringXor in webpack](https://github.com/webpack/webpack/commit/41a8e2ea483a544c4ccd3e6217bdfb80daffca39)
+ * to create a hash of the current state of the compilation. By XOR'ing the Module hashes, it
+ * doesn't matter if the Module hashes are sorted or not. This is useful because it allows us to avoid sorting the
+ * Module hashes.
+ *
+ * @example
+ * ```js
+ * const xor = new StringXor();
+ * xor.add('hello');
+ * xor.add('world');
+ * console.log(xor.toString());
+ * ```
+ *
+ * @example
+ * ```js
+ * const xor = new StringXor();
+ * xor.add('foo');
+ * xor.add('bar');
+ * const hash = createHash('sha256');
+ * hash.update(xor.toString());
+ * console.log(hash.digest('hex'));
+ * ```
+ */
 class StringXor {
 	constructor() {
+		/** @type {Buffer|undefined} */
 		this._value = undefined;
 	}
 
 	/**
+	 * Adds a string to the current StringXor object.
+	 *
 	 * @param {string} str string
 	 * @returns {void}
 	 */
@@ -18,6 +52,10 @@ class StringXor {
 		const len = str.length;
 		const value = this._value;
 		if (value === undefined) {
+			/**
+			 * We are choosing to use Buffer.allocUnsafe() because it is often faster than Buffer.alloc() because
+			 * it allocates a new buffer of the specified size without initializing the memory.
+			 */
 			const newValue = (this._value = Buffer.allocUnsafe(len));
 			for (let i = 0; i < len; i++) {
 				newValue[i] = str.charCodeAt(i);
@@ -41,11 +79,24 @@ class StringXor {
 		}
 	}
 
+	/**
+	 * Returns a string that represents the current state of the StringXor object. We chose to use "latin1" encoding
+	 * here because "latin1" encoding is a single-byte encoding that can represent all characters in the
+	 * [ISO-8859-1 character set](https://en.wikipedia.org/wiki/ISO/IEC_8859-1). This is useful when working
+	 * with binary data that needs to be represented as a string.
+	 *
+	 * @returns {string} Returns a string that represents the current state of the StringXor object.
+	 */
 	toString() {
 		const value = this._value;
 		return value === undefined ? "" : value.toString("latin1");
 	}
 
+	/**
+	 * Updates the hash with the current state of the StringXor object.
+	 *
+	 * @param {Hash} hash Hash instance
+	 */
 	updateHash(hash) {
 		const value = this._value;
 		if (value !== undefined) hash.update(value);

package/lib/util/binarySearchBounds.js

@@ -8,6 +8,28 @@
 /* cspell:disable-next-line */
 // Refactor: Peter Somogyvari @petermetz
 
+/** @typedef {">=" | "<=" | "<" | ">" | "-" } BinarySearchPredicate */
+/** @typedef {"GE" | "GT" | "LT" | "LE" | "EQ" } SearchPredicateSuffix */
+
+/**
+ * Helper function for compiling binary search functions.
+ *
+ * The generated code uses a while loop to repeatedly divide the search interval
+ * in half until the desired element is found, or the search interval is empty.
+ *
+ * The following is an example of a generated function for calling `compileSearch("P", "c(x,y)<=0", true, ["y", "c"], false)`:
+ *
+ * ```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.
+ * @param {string[]} extraArgs Extra arguments to be passed to the function.
+ * @param {boolean=} earlyOut Whether the search should return as soon as a match is found.
+ * @returns {string} The compiled binary search function.
+ */
 const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
 	const code = [
 		"function ",
@@ -43,6 +65,18 @@ const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
 	return code.join("");
 };
 
+/**
+ * This helper functions generate code for two binary search functions:
+ * 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.
+ * @param {boolean=} earlyOut Whether the search should return as soon as a match is found.
+ * @returns {function} The compiled binary search function.
+ */
 const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
 	const arg1 = compileSearch(
 		"A",
@@ -77,6 +111,21 @@ return dispatchBinarySearch";
 	return result();
 };
 
+/**
+ * These functions are used to perform binary searches on arrays.
+ *
+ * @example
+ * ```js
+ * const { gt, le} = require("./binarySearchBounds");
+ * const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+ *
+ * // Find the index of the first element greater than 5
+ * const index1 = gt(arr, 5); // index1 === 3
+ *
+ * // Find the index of the first element less than or equal to 5
+ * const index2 = le(arr, 5); // index2 === 4
+ * ```
+ */
 module.exports = {
 	ge: compileBoundsSearch(">=", false, "GE"),
 	gt: compileBoundsSearch(">", false, "GT"),

package/lib/util/compileBooleanMatcher.js

@@ -5,10 +5,18 @@
 
 "use strict";
 
+/**
+ * @param {string} str string
+ * @returns {string} quoted meta
+ */
 const quoteMeta = str => {
 	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 };
 
+/**
+ * @param {string} str string
+ * @returns {string} string
+ */
 const toSimpleString = str => {
 	if (`${+str}` === str) {
 		return str;
@@ -49,19 +57,28 @@ const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
 	}
 };
 
+/**
+ * @param {Set<string>} itemsSet items set
+ * @param {(str: string) => string | false} getKey get key function
+ * @param {(str: Array<string>) => boolean} condition condition
+ * @returns {Array<Array<string>>} list of common items
+ */
 const popCommonItems = (itemsSet, getKey, condition) => {
+	/** @type {Map<string, Array<string>>} */
 	const map = new Map();
 	for (const item of itemsSet) {
 		const key = getKey(item);
 		if (key) {
 			let list = map.get(key);
 			if (list === undefined) {
+				/** @type {Array<string>} */
 				list = [];
 				map.set(key, list);
 			}
 			list.push(item);
 		}
 	}
+	/** @type {Array<Array<string>>} */
 	const result = [];
 	for (const list of map.values()) {
 		if (condition(list)) {
@@ -74,6 +91,10 @@ const popCommonItems = (itemsSet, getKey, condition) => {
 	return result;
 };
 
+/**
+ * @param {Array<string>} items items
+ * @returns {string} common prefix
+ */
 const getCommonPrefix = items => {
 	let prefix = items[0];
 	for (let i = 1; i < items.length; i++) {
@@ -88,6 +109,10 @@ const getCommonPrefix = items => {
 	return prefix;
 };
 
+/**
+ * @param {Array<string>} items items
+ * @returns {string} common suffix
+ */
 const getCommonSuffix = items => {
 	let suffix = items[0];
 	for (let i = 1; i < items.length; i++) {
@@ -102,10 +127,15 @@ const getCommonSuffix = items => {
 	return suffix;
 };
 
+/**
+ * @param {Array<string>} itemsArr array of items
+ * @returns {string} regexp
+ */
 const itemsToRegexp = itemsArr => {
 	if (itemsArr.length === 1) {
 		return quoteMeta(itemsArr[0]);
 	}
+	/** @type {Array<string>} */
 	const finishedItems = [];
 
 	// merge single char items: (a|b|c|d|ef) => ([abcd]|ef)
@@ -146,6 +176,7 @@ const itemsToRegexp = itemsArr => {
 
 	// special case for 2 items with common suffix
 	if (finishedItems.length === 0 && items.size === 2) {
+		/** @type {Iterator<string>} */
 		const it = items[Symbol.iterator]();
 		const a = it.next().value;
 		const b = it.next().value;

package/lib/util/createHash.js

@@ -11,11 +11,14 @@ const BULK_SIZE = 2000;
 
 // We are using an object instead of a Map as this will stay static during the runtime
 // so access to it can be optimized by v8
+/** @type {Object<string, Map<string, string>>} */
 const digestCaches = {};
 
+/** @typedef {function(): Hash} HashFactory */
+
 class BulkUpdateDecorator extends Hash {
 	/**
-	 * @param {Hash | function(): Hash} hashOrFactory function to create a hash
+	 * @param {Hash | HashFactory} hashOrFactory function to create a hash
 	 * @param {string=} hashKey key for caching
 	 */
 	constructor(hashOrFactory, hashKey) {
@@ -43,7 +46,8 @@ class BulkUpdateDecorator extends Hash {
 			typeof data !== "string" ||
 			data.length > BULK_SIZE
 		) {
-			if (this.hash === undefined) this.hash = this.hashFactory();
+			if (this.hash === undefined)
+				this.hash = /** @type {HashFactory} */ (this.hashFactory)();
 			if (this.buffer.length > 0) {
 				this.hash.update(this.buffer);
 				this.buffer = "";
@@ -52,7 +56,8 @@ class BulkUpdateDecorator extends Hash {
 		} else {
 			this.buffer += data;
 			if (this.buffer.length > BULK_SIZE) {
-				if (this.hash === undefined) this.hash = this.hashFactory();
+				if (this.hash === undefined)
+					this.hash = /** @type {HashFactory} */ (this.hashFactory)();
 				this.hash.update(this.buffer);
 				this.buffer = "";
 			}
@@ -77,7 +82,7 @@ class BulkUpdateDecorator extends Hash {
 			}
 			const cacheEntry = digestCache.get(buffer);
 			if (cacheEntry !== undefined) return cacheEntry;
-			this.hash = this.hashFactory();
+			this.hash = /** @type {HashFactory} */ (this.hashFactory)();
 		}
 		if (buffer.length > 0) {
 			this.hash.update(buffer);
@@ -107,10 +112,13 @@ class DebugHash extends Hash {
 	 */
 	update(data, inputEncoding) {
 		if (typeof data !== "string") data = data.toString("utf-8");
-		if (data.startsWith("debug-digest-")) {
-			data = Buffer.from(data.slice("debug-digest-".length), "hex").toString();
+		const prefix = Buffer.from("@webpack-debug-digest@").toString("hex");
+		if (data.startsWith(prefix)) {
+			data = Buffer.from(data.slice(prefix.length), "hex").toString();
 		}
-		this.string += `[${data}](${new Error().stack.split("\n", 3)[2]})\n`;
+		this.string += `[${data}](${
+			/** @type {string} */ (new Error().stack).split("\n", 3)[2]
+		})\n`;
 		return this;
 	}
 
@@ -120,18 +128,22 @@ class DebugHash extends Hash {
 	 * @returns {string|Buffer} digest
 	 */
 	digest(encoding) {
-		return "debug-digest-" + Buffer.from(this.string).toString("hex");
+		return Buffer.from("@webpack-debug-digest@" + this.string).toString("hex");
 	}
 }
 
+/** @type {typeof import("crypto") | undefined} */
 let crypto = undefined;
+/** @type {typeof import("./hash/xxhash64") | undefined} */
 let createXXHash64 = undefined;
+/** @type {typeof import("./hash/md4") | undefined} */
 let createMd4 = undefined;
+/** @type {typeof import("./hash/BatchedHash") | undefined} */
 let BatchedHash = undefined;
 
 /**
  * Creates a hash by name or function
- * @param {string | typeof Hash} algorithm the algorithm name or a constructor creating a hash
+ * @param {string | typeof Hash | undefined} algorithm the algorithm name or a constructor creating a hash
  * @returns {Hash} the hash
  */
 module.exports = algorithm => {
@@ -149,7 +161,9 @@ module.exports = algorithm => {
 					BatchedHash = require("./hash/BatchedHash");
 				}
 			}
-			return new BatchedHash(createXXHash64());
+			return new /** @type {typeof import("./hash/BatchedHash")} */ (
+				BatchedHash
+			)(createXXHash64());
 		case "md4":
 			if (createMd4 === undefined) {
 				createMd4 = require("./hash/md4");
@@ -157,14 +171,22 @@ module.exports = algorithm => {
 					BatchedHash = require("./hash/BatchedHash");
 				}
 			}
-			return new BatchedHash(createMd4());
+			return new /** @type {typeof import("./hash/BatchedHash")} */ (
+				BatchedHash
+			)(createMd4());
 		case "native-md4":
 			if (crypto === undefined) crypto = require("crypto");
-			return new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
+			return new BulkUpdateDecorator(
+				() => /** @type {typeof import("crypto")} */ (crypto).createHash("md4"),
+				"md4"
+			);
 		default:
 			if (crypto === undefined) crypto = require("crypto");
 			return new BulkUpdateDecorator(
-				() => crypto.createHash(algorithm),
+				() =>
+					/** @type {typeof import("crypto")} */ (crypto).createHash(
+						/** @type {string} */ (algorithm)
+					),
 				algorithm
 			);
 	}