webpack 5.103.0 → 5.104.0

package/lib/util/hash/hash-digest.js

@@ -0,0 +1,216 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @typedef {import("../Hash")} Hash */
+/** @typedef {import("../../../declarations/WebpackOptions").HashDigest} Encoding */
+
+/** @typedef {"26" | "32" | "36" | "49" | "52" | "58" | "62"} Base */
+
+/* cSpell:disable */
+
+/** @type {Record<Base, string>} */
+const ENCODE_TABLE = Object.freeze({
+	26: "abcdefghijklmnopqrstuvwxyz",
+	32: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+	36: "0123456789abcdefghijklmnopqrstuvwxyz",
+	49: "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ",
+	52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+	58: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
+	62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+});
+
+/* cSpell:enable */
+
+const ZERO = BigInt("0");
+const EIGHT = BigInt("8");
+const FF = BigInt("0xff");
+
+/**
+ * It encodes octet arrays by doing long divisions on all significant digits in the array, creating a representation of that number in the new base.
+ * Then for every leading zero in the input (not significant as a number) it will encode as a single leader character.
+ * This is the first in the alphabet and will decode as 8 bits. The other characters depend upon the base.
+ * For example, a base58 alphabet packs roughly 5.858 bits per character.
+ * This means the encoded string 000f (using a base16, 0-f alphabet) will actually decode to 4 bytes unlike a canonical hex encoding which uniformly packs 4 bits into each character.
+ * While unusual, this does mean that no padding is required, and it works for bases like 43.
+ * @param {Buffer} buffer buffer
+ * @param {Base} base base
+ * @returns {string} encoded buffer
+ */
+const encode = (buffer, base) => {
+	if (buffer.length === 0) return "";
+	const bigIntBase = BigInt(ENCODE_TABLE[base].length);
+	// Convert buffer to BigInt efficiently using bitwise operations
+	let value = ZERO;
+	for (let i = 0; i < buffer.length; i++) {
+		value = (value << EIGHT) | BigInt(buffer[i]);
+	}
+	// Convert to baseX string efficiently using array
+	const digits = [];
+	if (value === ZERO) return ENCODE_TABLE[base][0];
+	while (value > ZERO) {
+		const remainder = Number(value % bigIntBase);
+		digits.push(ENCODE_TABLE[base][remainder]);
+		value /= bigIntBase;
+	}
+	return digits.reverse().join("");
+};
+
+/**
+ * @param {string} data string
+ * @param {Base} base base
+ * @returns {Buffer} buffer
+ */
+const decode = (data, base) => {
+	if (data.length === 0) return Buffer.from("");
+	const bigIntBase = BigInt(ENCODE_TABLE[base].length);
+	// Convert the baseX string to a BigInt value
+	let value = ZERO;
+	for (let i = 0; i < data.length; i++) {
+		const digit = ENCODE_TABLE[base].indexOf(data[i]);
+		if (digit === -1) {
+			throw new Error(`Invalid character at position ${i}: ${data[i]}`);
+		}
+		value = value * bigIntBase + BigInt(digit);
+	}
+	// If value is 0, return a single-byte buffer with value 0
+	if (value === ZERO) {
+		return Buffer.alloc(1);
+	}
+	// Determine buffer size efficiently by counting bytes
+	let temp = value;
+	let byteLength = 0;
+	while (temp > ZERO) {
+		temp >>= EIGHT;
+		byteLength++;
+	}
+	// Create buffer and fill it from right to left
+	const buffer = Buffer.alloc(byteLength);
+	for (let i = byteLength - 1; i >= 0; i--) {
+		buffer[i] = Number(value & FF);
+		value >>= EIGHT;
+	}
+	return buffer;
+};
+
+// Compatibility with the old hash libraries, they can return different structures, so let's stringify them firstly
+
+/**
+ * @param {string | { toString: (radix: number) => string }} value value
+ * @param {string} encoding encoding
+ * @returns {string} string
+ */
+const toString = (value, encoding) =>
+	typeof value === "string"
+		? value
+		: Buffer.from(value.toString(16), "hex").toString(
+				/** @type {NodeJS.BufferEncoding} */
+				(encoding)
+			);
+
+/**
+ * @param {Buffer | { toString: (radix: number) => string }} value value
+ * @returns {Buffer} buffer
+ */
+const toBuffer = (value) =>
+	Buffer.isBuffer(value) ? value : Buffer.from(value.toString(16), "hex");
+
+let isBase64URLSupported = false;
+
+try {
+	isBase64URLSupported = Boolean(Buffer.from("", "base64url"));
+} catch (_err) {
+	// Nothing
+}
+
+/**
+ * @param {Hash} hash hash
+ * @param {string | Buffer} data data
+ * @param {Encoding=} encoding encoding of the return value
+ * @returns {void}
+ */
+const update = (hash, data, encoding) => {
+	if (encoding === "base64url" && !isBase64URLSupported) {
+		const base64String = /** @type {string} */ (data)
+			.replace(/-/g, "+")
+			.replace(/_/g, "/");
+		const buf = Buffer.from(base64String, "base64");
+		hash.update(buf);
+		return;
+	} else if (
+		typeof data === "string" &&
+		encoding &&
+		typeof ENCODE_TABLE[/** @type {Base} */ (encoding.slice(4))] !== "undefined"
+	) {
+		const buf = decode(data, /** @type {Base} */ (encoding.slice(4)));
+		hash.update(buf);
+		return;
+	}
+
+	if (encoding) {
+		hash.update(/** @type {string} */ (data), encoding);
+	} else {
+		hash.update(data);
+	}
+};
+
+/**
+ * @overload
+ * @param {Hash} hash hash
+ * @returns {Buffer} digest
+ */
+/**
+ * @overload
+ * @param {Hash} hash hash
+ * @param {undefined} encoding encoding of the return value
+ * @param {boolean=} isSafe true when we await right types from digest(), otherwise false
+ * @returns {Buffer} digest
+ */
+/**
+ * @overload
+ * @param {Hash} hash hash
+ * @param {Encoding} encoding encoding of the return value
+ * @param {boolean=} isSafe true when we await right types from digest(), otherwise false
+ * @returns {string} digest
+ */
+/**
+ * @param {Hash} hash hash
+ * @param {Encoding=} encoding encoding of the return value
+ * @param {boolean=} isSafe true when we await right types from digest(), otherwise false
+ * @returns {string | Buffer} digest
+ */
+const digest = (hash, encoding, isSafe) => {
+	if (typeof encoding === "undefined") {
+		return isSafe ? hash.digest() : toBuffer(hash.digest());
+	}
+
+	if (encoding === "base64url" && !isBase64URLSupported) {
+		const digest = isSafe
+			? hash.digest("base64")
+			: toString(hash.digest("base64"), "base64");
+
+		return digest.replace(/\+/g, "-").replace(/\//g, "_").replace(/[=]+$/, "");
+	} else if (
+		typeof ENCODE_TABLE[/** @type {Base} */ (encoding.slice(4))] !== "undefined"
+	) {
+		const buf = isSafe ? hash.digest() : toBuffer(hash.digest());
+
+		return encode(
+			buf,
+			/** @type {Base} */
+			(encoding.slice(4))
+		);
+	}
+
+	return isSafe
+		? hash.digest(encoding)
+		: toString(hash.digest(encoding), encoding);
+};
+
+module.exports.decode = decode;
+module.exports.digest = digest;
+module.exports.encode = encode;
+module.exports.update = update;

package/lib/util/identifier.js

@@ -321,6 +321,7 @@ const absolutify = makeCacheableWithContext(_absolutify);
 const PATH_QUERY_FRAGMENT_REGEXP =
 	/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
 const PATH_QUERY_REGEXP = /^((?:\0.|[^?\0])*)(\?.*)?$/;
+const ZERO_ESCAPE_REGEXP = /\0(.)/g;
 
 /** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
 /** @typedef {{ resource: string, path: string, query: string }} ParsedResourceWithoutFragment */
@@ -330,15 +331,56 @@ const PATH_QUERY_REGEXP = /^((?:\0.|[^?\0])*)(\?.*)?$/;
  * @returns {ParsedResource} parsed parts
  */
 const _parseResource = (str) => {
-	const match =
-		/** @type {[string, string, string | undefined, string | undefined]} */
-		(/** @type {unknown} */ (PATH_QUERY_FRAGMENT_REGEXP.exec(str)));
-	return {
-		resource: str,
-		path: match[1].replace(/\0(.)/g, "$1"),
-		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
-		fragment: match[3] || ""
-	};
+	const firstEscape = str.indexOf("\0");
+
+	// Handle `\0`
+	if (firstEscape !== -1) {
+		const match =
+			/** @type {[string, string, string | undefined, string | undefined]} */
+			(/** @type {unknown} */ (PATH_QUERY_FRAGMENT_REGEXP.exec(str)));
+
+		return {
+			resource: str,
+			path: match[1].replace(ZERO_ESCAPE_REGEXP, "$1"),
+			query: match[2] ? match[2].replace(ZERO_ESCAPE_REGEXP, "$1") : "",
+			fragment: match[3] || ""
+		};
+	}
+
+	/** @type {ParsedResource} */
+	const result = { resource: str, path: "", query: "", fragment: "" };
+	const queryStart = str.indexOf("?");
+	const fragmentStart = str.indexOf("#");
+
+	if (fragmentStart < 0) {
+		if (queryStart < 0) {
+			result.path = result.resource;
+
+			// No fragment, no query
+			return result;
+		}
+
+		result.path = str.slice(0, queryStart);
+		result.query = str.slice(queryStart);
+
+		// Query, no fragment
+		return result;
+	}
+
+	if (queryStart < 0 || fragmentStart < queryStart) {
+		result.path = str.slice(0, fragmentStart);
+		result.fragment = str.slice(fragmentStart);
+
+		// Fragment, no query
+		return result;
+	}
+
+	result.path = str.slice(0, queryStart);
+	result.query = str.slice(queryStart, fragmentStart);
+	result.fragment = str.slice(fragmentStart);
+
+	// Query and fragment
+	return result;
 };
 
 /**
@@ -347,14 +389,37 @@ const _parseResource = (str) => {
  * @returns {ParsedResourceWithoutFragment} parsed parts
  */
 const _parseResourceWithoutFragment = (str) => {
-	const match =
-		/** @type {[string, string, string | undefined]} */
-		(/** @type {unknown} */ (PATH_QUERY_REGEXP.exec(str)));
-	return {
-		resource: str,
-		path: match[1].replace(/\0(.)/g, "$1"),
-		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : ""
-	};
+	const firstEscape = str.indexOf("\0");
+
+	// Handle `\0`
+	if (firstEscape !== -1) {
+		const match =
+			/** @type {[string, string, string | undefined]} */
+			(/** @type {unknown} */ (PATH_QUERY_REGEXP.exec(str)));
+
+		return {
+			resource: str,
+			path: match[1].replace(ZERO_ESCAPE_REGEXP, "$1"),
+			query: match[2] ? match[2].replace(ZERO_ESCAPE_REGEXP, "$1") : ""
+		};
+	}
+
+	/** @type {ParsedResourceWithoutFragment} */
+	const result = { resource: str, path: "", query: "" };
+	const queryStart = str.indexOf("?");
+
+	if (queryStart < 0) {
+		result.path = result.resource;
+
+		// No query
+		return result;
+	}
+
+	result.path = str.slice(0, queryStart);
+	result.query = str.slice(queryStart);
+
+	// Query
+	return result;
 };
 
 /**

package/lib/util/internalSerializables.js

@@ -73,16 +73,12 @@ module.exports = {
 		require("../dependencies/CriticalDependencyWarning"),
 	"dependencies/CssImportDependency": () =>
 		require("../dependencies/CssImportDependency"),
-	"dependencies/CssIcssLocalIdentifierDependency": () =>
-		require("../dependencies/CssIcssLocalIdentifierDependency"),
-	"dependencies/CssIcssSelfLocalIdentifierDependency": () =>
-		require("../dependencies/CssIcssSelfLocalIdentifierDependency"),
+	"dependencies/CssUrlDependency": () =>
+		require("../dependencies/CssUrlDependency"),
 	"dependencies/CssIcssImportDependency": () =>
 		require("../dependencies/CssIcssImportDependency"),
 	"dependencies/CssIcssExportDependency": () =>
 		require("../dependencies/CssIcssExportDependency"),
-	"dependencies/CssUrlDependency": () =>
-		require("../dependencies/CssUrlDependency"),
 	"dependencies/CssIcssSymbolDependency": () =>
 		require("../dependencies/CssIcssSymbolDependency"),
 	"dependencies/DelegatedSourceDependency": () =>

package/lib/util/runtime.js

@@ -71,7 +71,7 @@ const forEachRuntime = (runtime, fn, deterministicOrder = false) => {
 
 /**
  * @template T
- * @param {SortableSet<T>} set set
+ * @param {Exclude<RuntimeSpec, undefined | string>} set set
  * @returns {string} runtime key
  */
 const getRuntimesKey = (set) => {
@@ -102,7 +102,7 @@ const keyToRuntime = (key) => {
 
 /**
  * @template T
- * @param {SortableSet<T>} set set
+ * @param {Exclude<RuntimeSpec, undefined | string>} set set
  * @returns {string} runtime string
  */
 const getRuntimesString = (set) => {
@@ -163,7 +163,7 @@ const runtimeEqual = (a, b) => {
 /**
  * @param {RuntimeSpec} a first
  * @param {RuntimeSpec} b second
- * @returns {-1|0|1} compare
+ * @returns {-1 | 0 | 1} compare
  */
 const compareRuntime = (a, b) => {
 	if (a === b) {

package/lib/util/source.js

@@ -17,9 +17,9 @@ const equalityCache = new WeakMap();
  */
 const _isSourceEqual = (a, b) => {
 	// prefer .buffer(), it's called anyway during emit
-	/** @type {Buffer|string} */
+	/** @type {Buffer | string} */
 	let aSource = typeof a.buffer === "function" ? a.buffer() : a.source();
-	/** @type {Buffer|string} */
+	/** @type {Buffer | string} */
 	let bSource = typeof b.buffer === "function" ? b.buffer() : b.source();
 	if (aSource === bSource) return true;
 	if (typeof aSource === "string" && typeof bSource === "string") return false;

package/lib/wasm-async/AsyncWebAssemblyGenerator.js

@@ -7,10 +7,11 @@
 
 const { RawSource } = require("webpack-sources");
 const Generator = require("../Generator");
-const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypesConstants");
+const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
 
@@ -38,7 +39,7 @@ class AsyncWebAssemblyGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
+	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -8,7 +8,7 @@
 const { RawSource } = require("webpack-sources");
 const Generator = require("../Generator");
 const InitFragment = require("../InitFragment");
-const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypesConstants");
+const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
@@ -16,6 +16,7 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
 
@@ -34,7 +35,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
+	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -11,13 +11,14 @@ const { addWithAST, editWithAST } = require("@webassemblyjs/wasm-edit");
 const { decode } = require("@webassemblyjs/wasm-parser");
 const { RawSource } = require("webpack-sources");
 const Generator = require("../Generator");
-const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypesConstants");
+const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 const WebAssemblyUtils = require("./WebAssemblyUtils");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../NormalModule")} NormalModule */
@@ -270,11 +271,13 @@ const rewriteExportNames =
 			}
 		});
 
+/** @typedef {Map<string, UsedWasmDependency>} Mapping */
+
 /**
  * Mangle import names and modules
  * @param {object} state state
  * @param {AST} state.ast Module's ast
- * @param {Map<string, UsedWasmDependency>} state.usedDependencyMap mappings to mangle names
+ * @param {Mapping} state.usedDependencyMap mappings to mangle names
  * @returns {ArrayBufferTransform} transform
  */
 const rewriteImports =
@@ -383,11 +386,11 @@ const addInitFunction =
  * Extract mangle mappings from module
  * @param {ModuleGraph} moduleGraph module graph
  * @param {Module} module current module
- * @param {boolean | undefined} mangle mangle imports
- * @returns {Map<string, UsedWasmDependency>} mappings to mangled names
+ * @param {boolean=} mangle mangle imports
+ * @returns {Mapping} mappings to mangled names
  */
 const getUsedDependencyMap = (moduleGraph, module, mangle) => {
-	/** @type {Map<string, UsedWasmDependency>} */
+	/** @type {Mapping} */
 	const map = new Map();
 	for (const usedDep of WebAssemblyUtils.getUsedDependencies(
 		moduleGraph,
@@ -426,7 +429,7 @@ class WebAssemblyGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
+	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -9,7 +9,7 @@ const { RawSource } = require("webpack-sources");
 const { UsageState } = require("../ExportsInfo");
 const Generator = require("../Generator");
 const InitFragment = require("../InitFragment");
-const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypesConstants");
+const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const ModuleDependency = require("../dependencies/ModuleDependency");
@@ -19,6 +19,7 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
 
@@ -33,7 +34,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
+	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {

package/lib/wasm-sync/WebAssemblyModulesPlugin.js

@@ -6,6 +6,10 @@
 "use strict";
 
 const Generator = require("../Generator");
+const {
+	JAVASCRIPT_TYPE,
+	WEBASSEMBLY_TYPE
+} = require("../ModuleSourceTypeConstants");
 const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
@@ -74,8 +78,8 @@ class WebAssemblyModulesPlugin {
 						const WebAssemblyGenerator = getWebAssemblyGenerator();
 
 						return Generator.byType({
-							javascript: new WebAssemblyJavascriptGenerator(),
-							webassembly: new WebAssemblyGenerator(this.options)
+							[JAVASCRIPT_TYPE]: new WebAssemblyJavascriptGenerator(),
+							[WEBASSEMBLY_TYPE]: new WebAssemblyGenerator(this.options)
 						});
 					});
 

package/lib/webpack.js

@@ -154,7 +154,7 @@ const webpack = (options, callback) => {
 				"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
 			)();
 		}
-		/** @type {MultiCompiler|Compiler} */
+		/** @type {MultiCompiler | Compiler} */
 		let compiler;
 		/** @type {boolean | undefined} */
 		let watch = false;