webpack 5.81.0 → 5.82.0

package/lib/util/deprecation.js

@@ -178,6 +178,14 @@ exports.createArrayToSetDeprecationSet = name => {
 	return SetDeprecatedArray;
 };
 
+/**
+ * @template T
+ * @param {Object} obj object
+ * @param {string} name property name
+ * @param {string} code deprecation code
+ * @param {string} note additional note
+ * @returns {Object} frozen object with deprecation when modifying
+ */
 exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
 	const message = `${name} will be frozen in future, all modifications are deprecated.${
 		note && `\n${note}`

package/lib/util/identifier.js

@@ -15,6 +15,10 @@ const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
  * @property {Map<string, Map<string, string>>=} relativePaths
  */
 
+/**
+ * @param {string} relativePath relative path
+ * @returns {string} request
+ */
 const relativePathToRequest = relativePath => {
 	if (relativePath === "") return "./.";
 	if (relativePath === "..") return "../.";

package/lib/util/numberHash.js

@@ -5,41 +5,95 @@
 
 "use strict";
 
+/**
+ * The maximum safe integer value for 32-bit integers.
+ * @type {number}
+ */
 const SAFE_LIMIT = 0x80000000;
+
+/**
+ * The maximum safe integer value for 32-bit integers minus one. This is used
+ * in the algorithm to ensure that intermediate hash values do not exceed the
+ * 32-bit integer limit.
+ * @type {number}
+ */
 const SAFE_PART = SAFE_LIMIT - 1;
+
+/**
+ * The number of 32-bit integers used to store intermediate hash values.
+ * @type {number}
+ */
 const COUNT = 4;
+
+/**
+ * An array used to store intermediate hash values during the calculation.
+ * @type {number[]}
+ */
 const arr = [0, 0, 0, 0, 0];
+
+/**
+ * An array of prime numbers used in the hash calculation.
+ * @type {number[]}
+ */
 const primes = [3, 7, 17, 19];
 
+/**
+ * Computes a hash value for the given string and range. This hashing algorithm is a modified
+ * version of the [FNV-1a algorithm](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function).
+ * It is optimized for speed and does **not** generate a cryptographic hash value.
+ *
+ * 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); // 57
+ * numberHash("hello world"); // 990
+ * ```
+ *
+ */
 module.exports = (str, range) => {
+	/**
+	 * Initialize the array with zeros before it is used
+	 * to store intermediate hash values.
+	 */
 	arr.fill(0);
+	// For each character in the string
 	for (let i = 0; i < str.length; i++) {
+		// Get the character code.
 		const c = str.charCodeAt(i);
-		for (let j = 0; j < COUNT; j++) {
-			const p = (j + COUNT - 1) % COUNT;
-			arr[j] = (arr[j] + c * primes[j] + arr[p]) & SAFE_PART;
-		}
-		for (let j = 0; j < COUNT; j++) {
-			const q = arr[j] % COUNT;
-			arr[j] = arr[j] ^ (arr[q] >> 1);
-		}
+
+		// For each 32-bit integer used to store the hash value
+		// add the character code to the current hash value and multiply by the prime number and
+		// add the previous 32-bit integer.
+		arr[0] = (arr[0] + c * primes[0] + arr[3]) & SAFE_PART;
+		arr[1] = (arr[1] + c * primes[1] + arr[0]) & SAFE_PART;
+		arr[2] = (arr[2] + c * primes[2] + arr[1]) & SAFE_PART;
+		arr[3] = (arr[3] + c * primes[3] + arr[2]) & SAFE_PART;
+
+		// For each 32-bit integer used to store the hash value
+		// XOR the current hash value with the value of the next 32-bit integer.
+		arr[0] = arr[0] ^ (arr[arr[0] % COUNT] >> 1);
+		arr[1] = arr[1] ^ (arr[arr[1] % COUNT] >> 1);
+		arr[2] = arr[2] ^ (arr[arr[2] % COUNT] >> 1);
+		arr[3] = arr[3] ^ (arr[arr[3] % COUNT] >> 1);
 	}
+
 	if (range <= SAFE_PART) {
-		let sum = 0;
-		for (let j = 0; j < COUNT; j++) {
-			sum = (sum + arr[j]) % range;
-		}
-		return sum;
+		return (arr[0] + arr[1] + arr[2] + arr[3]) % range;
 	} else {
-		let sum1 = 0;
-		let sum2 = 0;
+		// Calculate the range extension.
 		const rangeExt = Math.floor(range / SAFE_LIMIT);
-		for (let j = 0; j < COUNT; j += 2) {
-			sum1 = (sum1 + arr[j]) & SAFE_PART;
-		}
-		for (let j = 1; j < COUNT; j += 2) {
-			sum2 = (sum2 + arr[j]) % rangeExt;
-		}
+
+		const sum1 = (arr[0] + arr[2]) & SAFE_PART;
+		const sum2 = (arr[0] + arr[2]) % rangeExt;
+
 		return (sum2 * SAFE_LIMIT + sum1) % range;
 	}
 };

package/lib/util/propertyAccess.js

@@ -60,6 +60,11 @@ const RESERVED_IDENTIFIER = new Set([
 	"false"
 ]);
 
+/**
+ * @param {ArrayLike<string>} properties properties
+ * @param {number} start start index
+ * @returns {string} chain of property accesses
+ */
 const propertyAccess = (properties, start = 0) => {
 	let str = "";
 	for (let i = start; i < properties.length; i++) {

package/lib/wasm/EnableWasmLoadingPlugin.js

@@ -12,6 +12,10 @@
 /** @type {WeakMap<Compiler, Set<WasmLoadingType>>} */
 const enabledTypes = new WeakMap();
 
+/**
+ * @param {Compiler} compiler compiler instance
+ * @returns {Set<WasmLoadingType>} enabled types
+ */
 const getEnabledTypes = compiler => {
 	let set = enabledTypes.get(compiler);
 	if (set === undefined) {

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -85,6 +85,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 			}
 		}
 
+		/** @type {Array<string>} */
 		const promises = [];
 
 		const importStatements = Array.from(

package/lib/wasm-async/AsyncWebAssemblyParser.js

@@ -47,7 +47,7 @@ class WebAssemblyParser extends Parser {
 		// parse it
 		const program = decode(source, decoderOpts);
 		const module = program.body[0];
-
+		/** @type {Array<string>} */
 		const exports = [];
 		t.traverse(module, {
 			ModuleExport({ node }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.81.0",
+  "version": "5.82.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",