webpack 5.99.4 → 5.99.6

package/lib/util/WeakTupleMap.js

@@ -6,15 +6,15 @@
 "use strict";
 
 /**
- * @template T
+ * @template {EXPECTED_ANY[]} T
  * @template V
- * @typedef {Map<EXPECTED_ANY, WeakTupleMap<T[], V>>} M
+ * @typedef {Map<EXPECTED_ANY, WeakTupleMap<T, V>>} M
  */
 
 /**
- * @template T
+ * @template {EXPECTED_ANY[]} T
  * @template V
- * @typedef {WeakMap<EXPECTED_OBJECT, WeakTupleMap<T[], V>>} W
+ * @typedef {WeakMap<EXPECTED_OBJECT, WeakTupleMap<T, V>>} W
  */
 
 /**
@@ -24,7 +24,12 @@
 const isWeakKey = thing => typeof thing === "object" && thing !== null;
 
 /**
- * @template {any[]} T
+ * @template {unknown[]} T
+ * @typedef {T extends readonly (infer ElementType)[] ? ElementType : never} ArrayElement
+ */
+
+/**
+ * @template {EXPECTED_ANY[]} K
  * @template V
  */
 class WeakTupleMap {
@@ -38,83 +43,83 @@ class WeakTupleMap {
 		this.v = undefined;
 		/**
 		 * @private
-		 * @type {M<T, V> | undefined}
+		 * @type {M<K, V> | undefined}
 		 */
 		this.m = undefined;
 		/**
 		 * @private
-		 * @type {W<T, V> | undefined}
+		 * @type {W<K, V> | undefined}
 		 */
 		this.w = undefined;
 	}
 
 	/**
-	 * @param {[...T, V]} args tuple
+	 * @param {[...K, V]} args tuple
 	 * @returns {void}
 	 */
 	set(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<K, V>} */
 		let node = this;
 		for (let i = 0; i < args.length - 1; i++) {
-			node = node._get(args[i]);
+			node = node._get(/** @type {ArrayElement<K>} */ (args[i]));
 		}
-		node._setValue(args[args.length - 1]);
+		node._setValue(/** @type {V} */ (args[args.length - 1]));
 	}
 
 	/**
-	 * @param {T} args tuple
+	 * @param {K} args tuple
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
 	has(...args) {
-		/** @type {WeakTupleMap<T, V> | undefined} */
+		/** @type {WeakTupleMap<K, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
+			node = node._peek(/** @type {ArrayElement<K>} */ (args[i]));
 			if (node === undefined) return false;
 		}
 		return node._hasValue();
 	}
 
 	/**
-	 * @param {T} args tuple
+	 * @param {K} args tuple
 	 * @returns {V | undefined} the value
 	 */
 	get(...args) {
-		/** @type {WeakTupleMap<T, V> | undefined} */
+		/** @type {WeakTupleMap<K, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
+			node = node._peek(/** @type {ArrayElement<K>} */ (args[i]));
 			if (node === undefined) return;
 		}
 		return node._getValue();
 	}
 
 	/**
-	 * @param {[...T, () => V]} args tuple
+	 * @param {[...K, (...args: K) => V]} args tuple
 	 * @returns {V} the value
 	 */
 	provide(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<K, V>} */
 		let node = this;
 		for (let i = 0; i < args.length - 1; i++) {
-			node = node._get(args[i]);
+			node = node._get(/** @type {ArrayElement<K>} */ (args[i]));
 		}
 		if (node._hasValue()) return /** @type {V} */ (node._getValue());
-		const fn = args[args.length - 1];
-		const newValue = fn(...args.slice(0, -1));
+		const fn = /** @type {(...args: K) => V} */ (args[args.length - 1]);
+		const newValue = fn(.../** @type {K} */ (args.slice(0, -1)));
 		node._setValue(newValue);
 		return newValue;
 	}
 
 	/**
-	 * @param {T} args tuple
+	 * @param {K} args tuple
 	 * @returns {void}
 	 */
 	delete(...args) {
-		/** @type {WeakTupleMap<T, V> | undefined} */
+		/** @type {WeakTupleMap<K, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
+			node = node._peek(/** @type {ArrayElement<K>} */ (args[i]));
 			if (node === undefined) return;
 		}
 		node._deleteValue();
@@ -153,59 +158,67 @@ class WeakTupleMap {
 	}
 
 	/**
-	 * @param {EXPECTED_ANY} thing thing
-	 * @returns {WeakTupleMap<T, V> | undefined} thing
+	 * @param {ArrayElement<K>} thing thing
+	 * @returns {WeakTupleMap<K, V> | undefined} thing
 	 * @private
 	 */
 	_peek(thing) {
 		if (isWeakKey(thing)) {
 			if ((this.f & 4) !== 4) return;
-			return /** @type {W<T, V>} */ (this.w).get(thing);
+			return /** @type {WeakMap<ArrayElement<K>, WeakTupleMap<K, V>>} */ (
+				this.w
+			).get(thing);
 		}
 		if ((this.f & 2) !== 2) return;
-		return /** @type {M<T, V>} */ (this.m).get(thing);
+		return /** @type {Map<ArrayElement<K>, WeakTupleMap<K, V>>} */ (this.m).get(
+			thing
+		);
 	}
 
 	/**
 	 * @private
-	 * @param {EXPECTED_ANY} thing thing
-	 * @returns {WeakTupleMap<T, V>} value
+	 * @param {ArrayElement<K>} thing thing
+	 * @returns {WeakTupleMap<K, V>} value
 	 */
 	_get(thing) {
 		if (isWeakKey(thing)) {
 			if ((this.f & 4) !== 4) {
+				/** @type {W<K, V>} */
 				const newMap = new WeakMap();
 				this.f |= 4;
+				/** @type {WeakTupleMap<K, V>} */
 				const newNode = new WeakTupleMap();
 				(this.w = newMap).set(thing, newNode);
 				return newNode;
 			}
-			const entry =
-				/** @type {W<T, V>} */
-				(this.w).get(thing);
+			const entry = /** @type {W<K, V>} */ (this.w).get(thing);
 			if (entry !== undefined) {
 				return entry;
 			}
+			/** @type {WeakTupleMap<K, V>} */
 			const newNode = new WeakTupleMap();
-			/** @type {W<T, V>} */
+			/** @type {W<K, V>} */
 			(this.w).set(thing, newNode);
 			return newNode;
 		}
 		if ((this.f & 2) !== 2) {
+			/** @type {M<K, V>} */
 			const newMap = new Map();
 			this.f |= 2;
+			/** @type {WeakTupleMap<K, V>} */
 			const newNode = new WeakTupleMap();
 			(this.m = newMap).set(thing, newNode);
 			return newNode;
 		}
 		const entry =
-			/** @type {M<T, V>} */
+			/** @type {M<K, V>} */
 			(this.m).get(thing);
 		if (entry !== undefined) {
 			return entry;
 		}
+		/** @type {WeakTupleMap<K, V>} */
 		const newNode = new WeakTupleMap();
-		/** @type {M<T, V>} */
+		/** @type {M<K, V>} */
 		(this.m).set(thing, newNode);
 		return newNode;
 	}

package/lib/util/cleverMerge.js

@@ -89,9 +89,9 @@ const cachedSetProperty = (obj, property, value) => {
 
 /**
  * @typedef {object} ObjectParsedPropertyEntry
- * @property {any | undefined} base base value
+ * @property {TODO | undefined} base base value
  * @property {string | undefined} byProperty the name of the selector property
- * @property {ByValues<any>} byValues value depending on selector property, merged with base
+ * @property {ByValues<TODO>} byValues value depending on selector property, merged with base
  */
 
 /** @typedef {(function(...EXPECTED_ANY): object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */

package/lib/util/comparators.js

@@ -361,7 +361,7 @@ module.exports.concatComparators = concatComparators;
  * @typedef {(input: A) => B | undefined | null} Selector
  */
 
-/** @type {TwoKeyWeakMap<Selector<any, any>, Comparator<any>, Comparator<any>>}} */
+/** @type {TwoKeyWeakMap<Selector<EXPECTED_ANY, EXPECTED_ANY>, Comparator<EXPECTED_ANY>, Comparator<EXPECTED_ANY>>}} */
 const compareSelectCache = new TwoKeyWeakMap();
 
 /**

package/lib/util/createHash.js

@@ -19,7 +19,7 @@ const digestCaches = {};
 class BulkUpdateDecorator extends Hash {
 	/**
 	 * @param {Hash | HashFactory} hashOrFactory function to create a hash
-	 * @param {string} [hashKey] key for caching
+	 * @param {string=} hashKey key for caching
 	 */
 	constructor(hashOrFactory, hashKey) {
 		super();

package/lib/util/fs.js

@@ -129,7 +129,7 @@ const path = require("path");
 
 /**
  * @typedef {object} ObjectEncodingOptions
- * @property {BufferEncoding | null | undefined} [encoding]
+ * @property {BufferEncoding | null | undefined=} encoding
  */
 
 /**

package/lib/util/makeSerializable.js

@@ -53,7 +53,7 @@ class ClassSerializer {
  * @template {Constructor} T
  * @param {T} Constructor the constructor
  * @param {string} request the request which will be required when deserializing
- * @param {string | null} [name] the name to make multiple serializer unique when sharing a request
+ * @param {string | null=} name the name to make multiple serializer unique when sharing a request
  */
 module.exports = (Constructor, request, name = null) => {
 	register(Constructor, request, name, new ClassSerializer(Constructor));

package/lib/util/runtime.js

@@ -431,6 +431,7 @@ class RuntimeSpecMap {
 	 * @param {RuntimeSpecMap<T, R>=} clone copy form this
 	 */
 	constructor(clone) {
+		/** @type {0 | 1 | 2} */
 		this._mode = clone ? clone._mode : 0; // 0 = empty, 1 = single entry, 2 = map
 		/** @type {RuntimeSpec} */
 		this._singleRuntime = clone ? clone._singleRuntime : undefined;

package/lib/util/serialization.js

@@ -9,10 +9,14 @@ const memoize = require("./memoize");
 
 /** @typedef {import("../serialization/BinaryMiddleware").MEASURE_END_OPERATION_TYPE} MEASURE_END_OPERATION */
 /** @typedef {import("../serialization/BinaryMiddleware").MEASURE_START_OPERATION_TYPE} MEASURE_START_OPERATION */
-/** @typedef {import("../serialization/Serializer")} Serializer */
 /** @typedef {typeof import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
+/**
+ * @template D, S, C
+ * @typedef {import("../serialization/Serializer")<D, S, C>} Serializer
+ */
+
 const getBinaryMiddleware = memoize(() =>
 	require("../serialization/BinaryMiddleware")
 );
@@ -53,7 +57,9 @@ const registerSerializers = memoize(() => {
 	});
 });
 
-/** @type {Serializer} */
+/**
+ * @type {Serializer<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>}
+ */
 let buffersSerializer;
 
 // Expose serialization API
@@ -78,9 +84,6 @@ module.exports = {
 	get MEASURE_END_OPERATION() {
 		return getBinaryMiddleware().MEASURE_END_OPERATION;
 	},
-	/**
-	 * @returns {Serializer} buffer serializer
-	 */
 	get buffersSerializer() {
 		if (buffersSerializer !== undefined) return buffersSerializer;
 		registerSerializers();
@@ -88,24 +91,27 @@ module.exports = {
 		const binaryMiddleware = getBinaryMiddlewareInstance();
 		const SerializerMiddleware = getSerializerMiddleware();
 		const SingleItemMiddleware = getSingleItemMiddleware();
-		return (buffersSerializer = new Serializer([
-			new SingleItemMiddleware(),
-			new (getObjectMiddleware())(context => {
-				if ("write" in context) {
-					context.writeLazy = value => {
-						context.write(
-							SerializerMiddleware.createLazy(value, binaryMiddleware)
-						);
-					};
-				}
-			}, DEFAULTS.HASH_FUNCTION),
-			binaryMiddleware
-		]));
+		return /** @type {Serializer<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>} */ (
+			buffersSerializer = new Serializer([
+				new SingleItemMiddleware(),
+				new (getObjectMiddleware())(context => {
+					if ("write" in context) {
+						context.writeLazy = value => {
+							context.write(
+								SerializerMiddleware.createLazy(value, binaryMiddleware)
+							);
+						};
+					}
+				}, DEFAULTS.HASH_FUNCTION),
+				binaryMiddleware
+			])
+		);
 	},
 	/**
+	 * @template D, S, C
 	 * @param {IntermediateFileSystem} fs filesystem
 	 * @param {string | Hash} hashFunction hash function to use
-	 * @returns {Serializer} file serializer
+	 * @returns {Serializer<D, S, C>} file serializer
 	 */
 	createFileSerializer: (fs, hashFunction) => {
 		registerSerializers();
@@ -115,28 +121,30 @@ module.exports = {
 		const binaryMiddleware = getBinaryMiddlewareInstance();
 		const SerializerMiddleware = getSerializerMiddleware();
 		const SingleItemMiddleware = getSingleItemMiddleware();
-		return new Serializer([
-			new SingleItemMiddleware(),
-			new (getObjectMiddleware())(context => {
-				if ("write" in context) {
-					context.writeLazy = value => {
-						context.write(
-							SerializerMiddleware.createLazy(value, binaryMiddleware)
-						);
-					};
-					context.writeSeparate = (value, options) => {
-						const lazy = SerializerMiddleware.createLazy(
-							value,
-							fileMiddleware,
-							options
-						);
-						context.write(lazy);
-						return lazy;
-					};
-				}
-			}, hashFunction),
-			binaryMiddleware,
-			fileMiddleware
-		]);
+		return /** @type {Serializer<D, S, C>} */ (
+			new Serializer([
+				new SingleItemMiddleware(),
+				new (getObjectMiddleware())(context => {
+					if ("write" in context) {
+						context.writeLazy = value => {
+							context.write(
+								SerializerMiddleware.createLazy(value, binaryMiddleware)
+							);
+						};
+						context.writeSeparate = (value, options) => {
+							const lazy = SerializerMiddleware.createLazy(
+								value,
+								fileMiddleware,
+								options
+							);
+							context.write(lazy);
+							return lazy;
+						};
+					}
+				}, hashFunction),
+				binaryMiddleware,
+				fileMiddleware
+			])
+		);
 	}
 };

package/lib/wasm-async/AsyncWebAssemblyGenerator.js

@@ -16,7 +16,7 @@ const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypesConstants");
 
 /**
  * @typedef {object} AsyncWebAssemblyGeneratorOptions
- * @property {boolean} [mangleImports] mangle imports
+ * @property {boolean=} mangleImports mangle imports
  */
 
 class AsyncWebAssemblyGenerator extends Generator {

package/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -55,7 +55,7 @@ const getAsyncWebAssemblyParser = memoize(() =>
 
 /**
  * @typedef {object} AsyncWebAssemblyModulesPluginOptions
- * @property {boolean} [mangleImports] mangle imports
+ * @property {boolean=} mangleImports mangle imports
  */
 
 /** @type {WeakMap<Compilation, CompilationHooks>} */

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -213,8 +213,8 @@ const generateImportObject = (
 /**
  * @typedef {object} WasmChunkLoadingRuntimeModuleOptions
  * @property {(path: string) => string} generateLoadBinaryCode
- * @property {boolean} [supportsStreaming]
- * @property {boolean} [mangleImports]
+ * @property {boolean=} supportsStreaming
+ * @property {boolean=} mangleImports
  * @property {ReadOnlyRuntimeRequirements} runtimeRequirements
  */
 

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -407,7 +407,7 @@ const getUsedDependencyMap = (moduleGraph, module, mangle) => {
 
 /**
  * @typedef {object} WebAssemblyGeneratorOptions
- * @property {boolean} [mangleImports] mangle imports
+ * @property {boolean=} mangleImports mangle imports
  */
 
 class WebAssemblyGenerator extends Generator {

package/lib/wasm-sync/WebAssemblyModulesPlugin.js

@@ -32,7 +32,7 @@ const PLUGIN_NAME = "WebAssemblyModulesPlugin";
 
 /**
  * @typedef {object} WebAssemblyModulesPluginOptions
- * @property {boolean} [mangleImports] mangle imports
+ * @property {boolean=} mangleImports mangle imports
  */
 
 class WebAssemblyModulesPlugin {

package/lib/web/FetchCompileWasmPlugin.js

@@ -14,7 +14,7 @@ const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRunt
 
 /**
  * @typedef {object} FetchCompileWasmPluginOptions
- * @property {boolean} [mangleImports] mangle imports
+ * @property {boolean=} mangleImports mangle imports
  */
 
 // TODO webpack 6 remove
@@ -23,7 +23,7 @@ const PLUGIN_NAME = "FetchCompileWasmPlugin";
 
 class FetchCompileWasmPlugin {
 	/**
-	 * @param {FetchCompileWasmPluginOptions} [options] options
+	 * @param {FetchCompileWasmPluginOptions=} options options
 	 */
 	constructor(options = {}) {
 		this.options = options;

package/lib/webpack.js

@@ -59,7 +59,7 @@ const createMultiCompiler = (childOptions, options) => {
 
 /**
  * @param {WebpackOptions} rawOptions options object
- * @param {number} [compilerIndex] index of compiler
+ * @param {number=} compilerIndex index of compiler
  * @returns {Compiler} a compiler
  */
 const createCompiler = (rawOptions, compilerIndex) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.99.4",
+  "version": "5.99.6",
   "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",