webpack 5.90.0 → 5.90.2

package/lib/optimize/MangleExportsPlugin.js

@@ -88,7 +88,11 @@ const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
 				used === UsageState.OnlyPropertiesUsed ||
 				used === UsageState.Unused
 			) {
-				mangleExportsInfo(deterministic, exportInfo.exportsInfo, false);
+				mangleExportsInfo(
+					deterministic,
+					/** @type {ExportsInfo} */ (exportInfo.exportsInfo),
+					false
+				);
 			}
 		}
 	}

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -56,7 +56,7 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 								"if(scripts.length) {",
 								Template.indent([
 									"var i = scripts.length - 1;",
-									"while (i > -1 && !scriptUrl) scriptUrl = scripts[i--].src;"
+									"while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;"
 								]),
 								"}"
 							]),

package/lib/util/chainedImports.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
@@ -17,7 +18,7 @@
  * because minifiers treat quoted accessors differently.  e.g. import { a } from "./module"; a["b"] vs a.b
  * @param {string[]} untrimmedIds chained ids
  * @param {Range} untrimmedRange range encompassing allIds
- * @param {Range[]} ranges cumulative range of ids for each of allIds
+ * @param {Range[] | undefined} ranges cumulative range of ids for each of allIds
  * @param {ModuleGraph} moduleGraph moduleGraph
  * @param {Dependency} dependency dependency
  * @returns {{trimmedIds: string[], trimmedRange: Range}} computed trimmed ids and cumulative range of those ids
@@ -44,7 +45,7 @@ exports.getTrimmedIdsAndRange = (
 			ranges === undefined
 				? -1 /* trigger failure case below */
 				: ranges.length + (trimmedIds.length - untrimmedIds.length);
-		if (idx < 0 || idx >= ranges.length) {
+		if (idx < 0 || idx >= /** @type {Range[]} */ (ranges).length) {
 			// cspell:ignore minifiers
 			// Should not happen but we can't throw an error here because of backward compatibility with
 			// external plugins in wp5.  Instead, we just disable trimming for now.  This may break some minifiers.
@@ -52,7 +53,7 @@ exports.getTrimmedIdsAndRange = (
 			// TODO webpack 6 remove the "trimmedIds = ids" above and uncomment the following line instead.
 			// throw new Error("Missing range starts data for id replacement trimming.");
 		} else {
-			trimmedRange = ranges[idx];
+			trimmedRange = /** @type {Range[]} */ (ranges)[idx];
 		}
 	}
 
@@ -68,11 +69,11 @@ exports.getTrimmedIdsAndRange = (
  * @returns {string[]} trimmed ids
  */
 function trimIdsToThoseImported(ids, moduleGraph, dependency) {
+	/** @type {string[]} */
 	let trimmedIds = [];
-	const exportsInfo = moduleGraph.getExportsInfo(
-		moduleGraph.getModule(dependency)
+	let currentExportsInfo = moduleGraph.getExportsInfo(
+		/** @type {Module} */ (moduleGraph.getModule(dependency))
 	);
-	let currentExportsInfo = /** @type {ExportsInfo=} */ exportsInfo;
 	for (let i = 0; i < ids.length; i++) {
 		if (i === 0 && ids[i] === "default") {
 			continue; // ExportInfo for the next level under default is still at the root ExportsInfo, so don't advance currentExportsInfo

package/lib/util/comparators.js

@@ -92,32 +92,68 @@ exports.compareNumbers = compareNumbers;
  * @returns {-1|0|1} compare result
  */
 const compareStringsNumeric = (a, b) => {
-	const partsA = a.split(/(\d+)/);
-	const partsB = b.split(/(\d+)/);
-	const len = Math.min(partsA.length, partsB.length);
-	for (let i = 0; i < len; i++) {
-		const pA = partsA[i];
-		const pB = partsB[i];
-		if (i % 2 === 0) {
-			if (pA.length > pB.length) {
-				if (pA.slice(0, pB.length) > pB) return 1;
-				return -1;
-			} else if (pB.length > pA.length) {
-				if (pB.slice(0, pA.length) > pA) return -1;
-				return 1;
-			} else {
-				if (pA < pB) return -1;
-				if (pA > pB) return 1;
-			}
+	const aLength = a.length;
+	const bLength = b.length;
+
+	let aChar = 0;
+	let bChar = 0;
+
+	let aIsDigit = false;
+	let bIsDigit = false;
+	let i = 0;
+	let j = 0;
+	while (i < aLength && j < bLength) {
+		aChar = a.charCodeAt(i);
+		bChar = b.charCodeAt(j);
+
+		aIsDigit = aChar >= 48 && aChar <= 57;
+		bIsDigit = bChar >= 48 && bChar <= 57;
+
+		if (!aIsDigit && !bIsDigit) {
+			if (aChar < bChar) return -1;
+			if (aChar > bChar) return 1;
+			i++;
+			j++;
+		} else if (aIsDigit && !bIsDigit) {
+			// This segment of a is shorter than in b
+			return 1;
+		} else if (!aIsDigit && bIsDigit) {
+			// This segment of b is shorter than in a
+			return -1;
 		} else {
-			const nA = +pA;
-			const nB = +pB;
-			if (nA < nB) return -1;
-			if (nA > nB) return 1;
+			let aNumber = aChar - 48;
+			let bNumber = bChar - 48;
+
+			while (++i < aLength) {
+				aChar = a.charCodeAt(i);
+				if (aChar < 48 || aChar > 57) break;
+				aNumber = aNumber * 10 + aChar - 48;
+			}
+
+			while (++j < bLength) {
+				bChar = b.charCodeAt(j);
+				if (bChar < 48 || bChar > 57) break;
+				bNumber = bNumber * 10 + bChar - 48;
+			}
+
+			if (aNumber < bNumber) return -1;
+			if (aNumber > bNumber) return 1;
 		}
 	}
-	if (partsB.length < partsA.length) return 1;
-	if (partsB.length > partsA.length) return -1;
+
+	if (j < bLength) {
+		// a is shorter than b
+		bChar = b.charCodeAt(j);
+		bIsDigit = bChar >= 48 && bChar <= 57;
+		return bIsDigit ? -1 : 1;
+	}
+	if (i < aLength) {
+		// b is shorter than a
+		aChar = a.charCodeAt(i);
+		aIsDigit = aChar >= 48 && aChar <= 57;
+		return aIsDigit ? 1 : -1;
+	}
+
 	return 0;
 };
 exports.compareStringsNumeric = compareStringsNumeric;

package/lib/util/numberHash.js

@@ -6,36 +6,69 @@
 "use strict";
 
 /**
- * The maximum safe integer value for 32-bit integers.
+ * Threshold for switching from 32-bit to 64-bit hashing. This is selected to ensure that the bias towards lower modulo results when using 32-bit hashing is <0.5%.
  * @type {number}
  */
-const SAFE_LIMIT = 0x80000000;
+const FNV_64_THRESHOLD = 1 << 24;
 
 /**
- * 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.
+ * The FNV-1a offset basis for 32-bit hash values.
  * @type {number}
  */
-const SAFE_PART = SAFE_LIMIT - 1;
-
+const FNV_OFFSET_32 = 2166136261;
 /**
- * The number of 32-bit integers used to store intermediate hash values.
+ * The FNV-1a prime for 32-bit hash values.
  * @type {number}
  */
-const COUNT = 4;
+const FNV_PRIME_32 = 16777619;
+/**
+ * The mask for a positive 32-bit signed integer.
+ * @type {number}
+ */
+const MASK_31 = 0x7fffffff;
+
+/**
+ * The FNV-1a offset basis for 64-bit hash values.
+ * @type {bigint}
+ */
+const FNV_OFFSET_64 = BigInt("0xCBF29CE484222325");
+/**
+ * The FNV-1a prime for 64-bit hash values.
+ * @type {bigint}
+ */
+const FNV_PRIME_64 = BigInt("0x100000001B3");
 
 /**
- * An array used to store intermediate hash values during the calculation.
- * @type {number[]}
+ * Computes a 32-bit FNV-1a hash value for the given string.
+ * See https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+ * @param {string} str The input string to hash
+ * @returns {number} - The computed hash value.
  */
-const arr = [0, 0, 0, 0, 0];
+function fnv1a32(str) {
+	let hash = FNV_OFFSET_32;
+	for (let i = 0, len = str.length; i < len; i++) {
+		hash ^= str.charCodeAt(i);
+		// Use Math.imul to do c-style 32-bit multiplication and keep only the 32 least significant bits
+		hash = Math.imul(hash, FNV_PRIME_32);
+	}
+	// Force the result to be positive
+	return hash & MASK_31;
+}
 
 /**
- * An array of prime numbers used in the hash calculation.
- * @type {number[]}
+ * Computes a 64-bit FNV-1a hash value for the given string.
+ * See https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+ * @param {string} str The input string to hash
+ * @returns {bigint} - The computed hash value.
  */
-const primes = [3, 7, 17, 19];
+function fnv1a64(str) {
+	let hash = FNV_OFFSET_64;
+	for (let i = 0, len = str.length; i < len; i++) {
+		hash ^= BigInt(str.charCodeAt(i));
+		hash = BigInt.asUintN(64, hash * FNV_PRIME_64);
+	}
+	return hash;
+}
 
 /**
  * Computes a hash value for the given string and range. This hashing algorithm is a modified
@@ -53,47 +86,15 @@ const primes = [3, 7, 17, 19];
  *
  * ```js
  * const numberHash = require("webpack/lib/util/numberHash");
- * numberHash("hello", 1000); // 57
- * numberHash("hello world"); // 990
+ * numberHash("hello", 1000); // 73
+ * numberHash("hello world"); // 72
  * ```
  *
  */
 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 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) {
-		return (arr[0] + arr[1] + arr[2] + arr[3]) % range;
+	if (range < FNV_64_THRESHOLD) {
+		return fnv1a32(str) % range;
 	} else {
-		// Calculate the range extension.
-		const rangeExt = Math.floor(range / SAFE_LIMIT);
-
-		const sum1 = (arr[0] + arr[2]) & SAFE_PART;
-		const sum2 = (arr[0] + arr[2]) % rangeExt;
-
-		return (sum2 * SAFE_LIMIT + sum1) % range;
+		return Number(fnv1a64(str) % BigInt(range));
 	}
 };

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -52,38 +52,63 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 				runtime: chunk.runtime
 			}
 		);
-		return `${fn} = ${runtimeTemplate.basicFunction(
-			"exports, wasmModuleId, wasmModuleHash, importsObj",
-			[
-				`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
-				this.supportsStreaming
-					? Template.asString([
-							"if (typeof WebAssembly.instantiateStreaming === 'function') {",
+
+		const loader = this.generateLoadBinaryCode(wasmModuleSrcPath);
+		const fallback = [
+			`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,
+			`.then(${runtimeTemplate.returningFunction(
+				"WebAssembly.instantiate(bytes, importsObj)",
+				"bytes"
+			)})`,
+			`.then(${runtimeTemplate.returningFunction(
+				"Object.assign(exports, res.instance.exports)",
+				"res"
+			)})`
+		];
+		const getStreaming = () => {
+			const concat = (/** @type {string[]} */ ...text) => text.join("");
+			return [
+				`var req = ${loader};`,
+				`var fallback = ${runtimeTemplate.returningFunction(Template.asString(["req", Template.indent(fallback)]))};`,
+				concat(
+					"return req.then(",
+					runtimeTemplate.basicFunction("res", [
+						`if (typeof WebAssembly.instantiateStreaming === "function") {`,
+						Template.indent([
+							"return WebAssembly.instantiateStreaming(res, importsObj)",
 							Template.indent([
-								"return WebAssembly.instantiateStreaming(req, importsObj)",
+								".then(",
 								Template.indent([
-									`.then(${runtimeTemplate.returningFunction(
+									runtimeTemplate.returningFunction(
 										"Object.assign(exports, res.instance.exports)",
 										"res"
-									)});`
-								])
-							]),
-							"}"
-						])
-					: "// no support for streaming compilation",
-				"return req",
-				Template.indent([
-					`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,
-					`.then(${runtimeTemplate.returningFunction(
-						"WebAssembly.instantiate(bytes, importsObj)",
-						"bytes"
-					)})`,
-					`.then(${runtimeTemplate.returningFunction(
-						"Object.assign(exports, res.instance.exports)",
-						"res"
-					)});`
-				])
-			]
+									) + ",",
+									runtimeTemplate.basicFunction("e", [
+										`if(res.headers.get("Content-Type") !== "application/wasm") {`,
+										Template.indent([
+											'console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n", e);',
+											"return fallback();"
+										]),
+										"}",
+										"throw e;"
+									])
+								]),
+								");"
+							])
+						]),
+						"}",
+						"return fallback();"
+					]),
+					");"
+				)
+			];
+		};
+
+		return `${fn} = ${runtimeTemplate.basicFunction(
+			"exports, wasmModuleId, wasmModuleHash, importsObj",
+			this.supportsStreaming
+				? getStreaming()
+				: [`return ${loader}`, Template.indent(fallback) + ";"]
 		)};`;
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.90.0",
+  "version": "5.90.2",
   "author": "Tobias Koppers @sokra",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
@@ -57,7 +57,7 @@
     "eslint": "^8.48.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jest": "^27.6.3",
-    "eslint-plugin-jsdoc": "^43.0.5",
+    "eslint-plugin-jsdoc": "^48.1.0",
     "eslint-plugin-n": "^16.6.2",
     "eslint-plugin-prettier": "^5.1.3",
     "file-loader": "^6.0.0",
@@ -84,6 +84,7 @@
     "mini-svg-data-uri": "^1.2.3",
     "nyc": "^15.1.0",
     "open-cli": "^7.2.0",
+    "prettier-2": "npm:prettier@^2",
     "prettier": "^3.2.1",
     "pretty-format": "^29.5.0",
     "pug": "^3.0.0",
@@ -158,7 +159,7 @@
     "special-lint-fix": "node node_modules/tooling/inherit-types --write && node node_modules/tooling/format-schemas --write && node tooling/generate-runtime-code.js --write && node tooling/generate-wasm-code.js --write && node node_modules/tooling/format-file-header --write && node node_modules/tooling/compile-to-definitions --write && node node_modules/tooling/precompile-schemas --write && node node_modules/tooling/generate-types --no-template-literals --write",
     "fix": "yarn code-lint --fix && yarn special-lint-fix && yarn pretty-lint-fix",
     "prepare": "husky install",
-    "pretty-lint-base": "prettier --cache .",
+    "pretty-lint-base": "node node_modules/prettier/bin/prettier.cjs --cache .",
     "pretty-lint-fix": "yarn pretty-lint-base --loglevel warn --write",
     "pretty-lint": "yarn pretty-lint-base --check",
     "yarn-lint": "yarn-deduplicate --fail --list -s highest yarn.lock",
@@ -186,61 +187,5 @@
     "*.md|{.github,benchmark,bin,examples,hot,lib,schemas,setup,tooling}/**/*.{md,yml,yaml,js,json}": [
       "cspell"
     ]
-  },
-  "jest": {
-    "forceExit": true,
-    "setupFilesAfterEnv": [
-      "<rootDir>/test/setupTestFramework.js"
-    ],
-    "testMatch": [
-      "<rootDir>/test/*.test.js",
-      "<rootDir>/test/*.basictest.js",
-      "<rootDir>/test/*.longtest.js",
-      "<rootDir>/test/*.unittest.js"
-    ],
-    "watchPathIgnorePatterns": [
-      "<rootDir>/.git",
-      "<rootDir>/node_modules",
-      "<rootDir>/test/js",
-      "<rootDir>/test/browsertest/js",
-      "<rootDir>/test/fixtures/temp-cache-fixture",
-      "<rootDir>/test/fixtures/temp-",
-      "<rootDir>/benchmark",
-      "<rootDir>/assembly",
-      "<rootDir>/tooling",
-      "<rootDir>/examples/*/dist",
-      "<rootDir>/coverage",
-      "<rootDir>/.eslintcache"
-    ],
-    "modulePathIgnorePatterns": [
-      "<rootDir>/.git",
-      "<rootDir>/node_modules/webpack/node_modules",
-      "<rootDir>/test/js",
-      "<rootDir>/test/browsertest/js",
-      "<rootDir>/test/fixtures/temp-cache-fixture",
-      "<rootDir>/test/fixtures/temp-",
-      "<rootDir>/benchmark",
-      "<rootDir>/examples/*/dist",
-      "<rootDir>/coverage",
-      "<rootDir>/.eslintcache"
-    ],
-    "transformIgnorePatterns": [
-      "<rootDir>"
-    ],
-    "coverageDirectory": "<rootDir>/coverage",
-    "coveragePathIgnorePatterns": [
-      "\\.runtime\\.js$",
-      "<rootDir>/test",
-      "<rootDir>/schemas",
-      "<rootDir>/node_modules"
-    ],
-    "testEnvironment": "./test/patch-node-env.js",
-    "coverageReporters": [
-      "json"
-    ],
-    "snapshotFormat": {
-      "escapeString": true,
-      "printBasicPrototype": true
-    }
   }
 }