webpack 5.99.5 → 5.99.7

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/concatenate.js

@@ -198,11 +198,13 @@ const RESERVED_NAMES = new Set(
 		.split(",")
 );
 
+/** @typedef {{ usedNames: UsedNames, alreadyCheckedScopes: ScopeSet }} ScopeInfo */
+
 /**
- * @param {Map<string, { usedNames: UsedNames, alreadyCheckedScopes: ScopeSet }>} usedNamesInScopeInfo used names in scope info
+ * @param {Map<string, ScopeInfo>} usedNamesInScopeInfo used names in scope info
  * @param {string} module module identifier
  * @param {string} id export id
- * @returns {{ usedNames: UsedNames, alreadyCheckedScopes: ScopeSet }} info
+ * @returns {ScopeInfo} info
  */
 const getUsedNamesInScopeInfo = (usedNamesInScopeInfo, module, id) => {
 	const key = `${module}-${id}`;

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/WasmFinalizeExportsPlugin.js

@@ -13,6 +13,8 @@ const UnsupportedWebAssemblyFeatureError = require("./UnsupportedWebAssemblyFeat
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 
+const PLUGIN_NAME = "WasmFinalizeExportsPlugin";
+
 class WasmFinalizeExportsPlugin {
 	/**
 	 * Apply the plugin
@@ -20,72 +22,68 @@ class WasmFinalizeExportsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("WasmFinalizeExportsPlugin", compilation => {
-			compilation.hooks.finishModules.tap(
-				"WasmFinalizeExportsPlugin",
-				modules => {
-					for (const module of modules) {
-						// 1. if a WebAssembly module
-						if (module.type.startsWith("webassembly") === true) {
-							const jsIncompatibleExports =
-								/** @type {BuildMeta} */
-								(module.buildMeta).jsIncompatibleExports;
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+			compilation.hooks.finishModules.tap(PLUGIN_NAME, modules => {
+				for (const module of modules) {
+					// 1. if a WebAssembly module
+					if (module.type.startsWith("webassembly") === true) {
+						const jsIncompatibleExports =
+							/** @type {BuildMeta} */
+							(module.buildMeta).jsIncompatibleExports;
 
-							if (jsIncompatibleExports === undefined) {
-								continue;
-							}
+						if (jsIncompatibleExports === undefined) {
+							continue;
+						}
 
-							for (const connection of compilation.moduleGraph.getIncomingConnections(
-								module
-							)) {
-								// 2. is active and referenced by a non-WebAssembly module
-								if (
-									connection.isTargetActive(undefined) &&
-									/** @type {Module} */
-									(connection.originModule).type.startsWith("webassembly") ===
-										false
-								) {
-									const referencedExports =
-										compilation.getDependencyReferencedExports(
-											/** @type {Dependency} */ (connection.dependency),
-											undefined
-										);
+						for (const connection of compilation.moduleGraph.getIncomingConnections(
+							module
+						)) {
+							// 2. is active and referenced by a non-WebAssembly module
+							if (
+								connection.isTargetActive(undefined) &&
+								/** @type {Module} */
+								(connection.originModule).type.startsWith("webassembly") ===
+									false
+							) {
+								const referencedExports =
+									compilation.getDependencyReferencedExports(
+										/** @type {Dependency} */ (connection.dependency),
+										undefined
+									);
 
-									for (const info of referencedExports) {
-										const names = Array.isArray(info) ? info : info.name;
-										if (names.length === 0) continue;
-										const name = names[0];
-										if (typeof name === "object") continue;
-										// 3. and uses a func with an incompatible JS signature
-										if (
-											Object.prototype.hasOwnProperty.call(
-												jsIncompatibleExports,
-												name
-											)
-										) {
-											// 4. error
-											const error = new UnsupportedWebAssemblyFeatureError(
-												`Export "${name}" with ${jsIncompatibleExports[name]} can only be used for direct wasm to wasm dependencies\n` +
-													`It's used from ${
-														/** @type {Module} */
-														(connection.originModule).readableIdentifier(
-															compilation.requestShortener
-														)
-													} at ${formatLocation(
-														/** @type {Dependency} */ (connection.dependency)
-															.loc
-													)}.`
-											);
-											error.module = module;
-											compilation.errors.push(error);
-										}
+								for (const info of referencedExports) {
+									const names = Array.isArray(info) ? info : info.name;
+									if (names.length === 0) continue;
+									const name = names[0];
+									if (typeof name === "object") continue;
+									// 3. and uses a func with an incompatible JS signature
+									if (
+										Object.prototype.hasOwnProperty.call(
+											jsIncompatibleExports,
+											name
+										)
+									) {
+										// 4. error
+										const error = new UnsupportedWebAssemblyFeatureError(
+											`Export "${name}" with ${jsIncompatibleExports[name]} can only be used for direct wasm to wasm dependencies\n` +
+												`It's used from ${
+													/** @type {Module} */
+													(connection.originModule).readableIdentifier(
+														compilation.requestShortener
+													)
+												} at ${formatLocation(
+													/** @type {Dependency} */ (connection.dependency).loc
+												)}.`
+										);
+										error.module = module;
+										compilation.errors.push(error);
 									}
 								}
 							}
 						}
 					}
 				}
-			);
+			});
 		});
 	}
 }

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;