webpack 5.76.1 → 5.88.2

package/lib/util/runtime.js

@@ -53,7 +53,7 @@ exports.getEntryRuntime = (compilation, name, options) => {
 
 /**
  * @param {RuntimeSpec} runtime runtime
- * @param {function(string): void} fn functor
+ * @param {function(string | undefined): void} fn functor
  * @param {boolean} deterministicOrder enforce a deterministic order
  * @returns {void}
  */
@@ -70,6 +70,11 @@ exports.forEachRuntime = (runtime, fn, deterministicOrder = false) => {
 	}
 };
 
+/**
+ * @template T
+ * @param {SortableSet<T>} set set
+ * @returns {string} runtime key
+ */
 const getRuntimesKey = set => {
 	set.sort();
 	return Array.from(set).join("\n");
@@ -98,6 +103,11 @@ const keyToRuntime = key => {
 };
 exports.keyToRuntime = keyToRuntime;
 
+/**
+ * @template T
+ * @param {SortableSet<T>} set set
+ * @returns {string} runtime string
+ */
 const getRuntimesString = set => {
 	set.sort();
 	return Array.from(set).join("+");
@@ -415,6 +425,11 @@ exports.filterRuntime = (runtime, filter) => {
 	return result;
 };
 
+/**
+ * @template T
+ * @typedef {Map<string, T>} RuntimeSpecMapInnerMap
+ * */
+
 /**
  * @template T
  */
@@ -426,15 +441,15 @@ class RuntimeSpecMap {
 		this._mode = clone ? clone._mode : 0; // 0 = empty, 1 = single entry, 2 = map
 		/** @type {RuntimeSpec} */
 		this._singleRuntime = clone ? clone._singleRuntime : undefined;
-		/** @type {T} */
+		/** @type {T | undefined} */
 		this._singleValue = clone ? clone._singleValue : undefined;
-		/** @type {Map<string, T> | undefined} */
+		/** @type {RuntimeSpecMapInnerMap<T> | undefined} */
 		this._map = clone && clone._map ? new Map(clone._map) : undefined;
 	}
 
 	/**
 	 * @param {RuntimeSpec} runtime the runtimes
-	 * @returns {T} value
+	 * @returns {T | undefined} value
 	 */
 	get(runtime) {
 		switch (this._mode) {
@@ -445,7 +460,9 @@ class RuntimeSpecMap {
 					? this._singleValue
 					: undefined;
 			default:
-				return this._map.get(getRuntimeKey(runtime));
+				return /** @type {RuntimeSpecMapInnerMap<T>} */ (this._map).get(
+					getRuntimeKey(runtime)
+				);
 		}
 	}
 
@@ -460,10 +477,16 @@ class RuntimeSpecMap {
 			case 1:
 				return runtimeEqual(this._singleRuntime, runtime);
 			default:
-				return this._map.has(getRuntimeKey(runtime));
+				return /** @type {RuntimeSpecMapInnerMap<T>} */ (this._map).has(
+					getRuntimeKey(runtime)
+				);
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @param {T} value the value
+	 */
 	set(runtime, value) {
 		switch (this._mode) {
 			case 0:
@@ -478,15 +501,24 @@ class RuntimeSpecMap {
 				}
 				this._mode = 2;
 				this._map = new Map();
-				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._map.set(
+					getRuntimeKey(this._singleRuntime),
+					/** @type {T} */ (this._singleValue)
+				);
 				this._singleRuntime = undefined;
 				this._singleValue = undefined;
 			/* falls through */
 			default:
-				this._map.set(getRuntimeKey(runtime), value);
+				/** @type {RuntimeSpecMapInnerMap<T>} */
+				(this._map).set(getRuntimeKey(runtime), value);
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @param {() => TODO} computer function to compute the value
+	 * @returns {TODO} true, when the runtime was deleted
+	 */
 	provide(runtime, computer) {
 		switch (this._mode) {
 			case 0:
@@ -495,11 +527,14 @@ class RuntimeSpecMap {
 				return (this._singleValue = computer());
 			case 1: {
 				if (runtimeEqual(this._singleRuntime, runtime)) {
-					return this._singleValue;
+					return /** @type {T} */ (this._singleValue);
 				}
 				this._mode = 2;
 				this._map = new Map();
-				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._map.set(
+					getRuntimeKey(this._singleRuntime),
+					/** @type {T} */ (this._singleValue)
+				);
 				this._singleRuntime = undefined;
 				this._singleValue = undefined;
 				const newValue = computer();
@@ -508,15 +543,19 @@ class RuntimeSpecMap {
 			}
 			default: {
 				const key = getRuntimeKey(runtime);
-				const value = this._map.get(key);
+				const value = /** @type {Map<string, T>} */ (this._map).get(key);
 				if (value !== undefined) return value;
 				const newValue = computer();
-				this._map.set(key, newValue);
+				/** @type {Map<string, T>} */
+				(this._map).set(key, newValue);
 				return newValue;
 			}
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 */
 	delete(runtime) {
 		switch (this._mode) {
 			case 0:
@@ -529,10 +568,15 @@ class RuntimeSpecMap {
 				}
 				return;
 			default:
-				this._map.delete(getRuntimeKey(runtime));
+				/** @type {RuntimeSpecMapInnerMap<T>} */
+				(this._map).delete(getRuntimeKey(runtime));
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @param {function(T | undefined): T} fn function to update the value
+	 */
 	update(runtime, fn) {
 		switch (this._mode) {
 			case 0:
@@ -546,7 +590,10 @@ class RuntimeSpecMap {
 				if (newValue !== undefined) {
 					this._mode = 2;
 					this._map = new Map();
-					this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+					this._map.set(
+						getRuntimeKey(this._singleRuntime),
+						/** @type {T} */ (this._singleValue)
+					);
 					this._singleRuntime = undefined;
 					this._singleValue = undefined;
 					this._map.set(getRuntimeKey(runtime), newValue);
@@ -555,9 +602,11 @@ class RuntimeSpecMap {
 			}
 			default: {
 				const key = getRuntimeKey(runtime);
-				const oldValue = this._map.get(key);
+				const oldValue = /** @type {Map<string, T>} */ (this._map).get(key);
 				const newValue = fn(oldValue);
-				if (newValue !== oldValue) this._map.set(key, newValue);
+				if (newValue !== oldValue)
+					/** @type {RuntimeSpecMapInnerMap<T>} */
+					(this._map).set(key, newValue);
 			}
 		}
 	}
@@ -569,7 +618,11 @@ class RuntimeSpecMap {
 			case 1:
 				return [this._singleRuntime];
 			default:
-				return Array.from(this._map.keys(), keyToRuntime);
+				return Array.from(
+					/** @type {RuntimeSpecMapInnerMap<T>} */
+					(this._map).keys(),
+					keyToRuntime
+				);
 		}
 	}
 
@@ -578,21 +631,24 @@ class RuntimeSpecMap {
 			case 0:
 				return [][Symbol.iterator]();
 			case 1:
-				return [this._singleValue][Symbol.iterator]();
+				return [/** @type {T} */ (this._singleValue)][Symbol.iterator]();
 			default:
-				return this._map.values();
+				return /** @type {Map<string, T>} */ (this._map).values();
 		}
 	}
 
 	get size() {
-		if (this._mode <= 1) return this._mode;
-		return this._map.size;
+		if (/** @type {number} */ (this._mode) <= 1) return this._mode;
+		return /** @type {Map<string, T>} */ (this._map).size;
 	}
 }
 
 exports.RuntimeSpecMap = RuntimeSpecMap;
 
 class RuntimeSpecSet {
+	/**
+	 * @param {Iterable<RuntimeSpec>=} iterable iterable
+	 */
 	constructor(iterable) {
 		/** @type {Map<string, RuntimeSpec>} */
 		this._map = new Map();
@@ -603,10 +659,17 @@ class RuntimeSpecSet {
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime runtime
+	 */
 	add(runtime) {
 		this._map.set(getRuntimeKey(runtime), runtime);
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime runtime
+	 * @returns {boolean} true, when the runtime exists
+	 */
 	has(runtime) {
 		return this._map.has(getRuntimeKey(runtime));
 	}

package/lib/util/semver.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {(string|number|undefined|[])[]} SemVerRange */
 
 /**
@@ -288,7 +289,7 @@ const satisfy = (range, version) => {
 	if (0 in range) {
 		// @ts-expect-error
 		version = parseVersion(version);
-		var fixCount = range[0];
+		var fixCount = /** @type {number} */ (range[0]);
 		// when negated is set it swill set for < instead of >=
 		var negated = fixCount < 0;
 		if (negated) fixCount = -fixCount - 1;

package/lib/util/serialization.js

@@ -11,6 +11,8 @@ const memoize = require("./memoize");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../serialization/Serializer")} Serializer */
+/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
 const getBinaryMiddleware = memoize(() =>
 	require("../serialization/BinaryMiddleware")
@@ -72,6 +74,9 @@ module.exports = {
 	get MEASURE_END_OPERATION() {
 		return getBinaryMiddleware().MEASURE_END_OPERATION;
 	},
+	/**
+	 * @returns {Serializer} buffer serializer
+	 */
 	get buffersSerializer() {
 		if (buffersSerializer !== undefined) return buffersSerializer;
 		registerSerializers();
@@ -93,6 +98,11 @@ module.exports = {
 			binaryMiddleware
 		]));
 	},
+	/**
+	 * @param {IntermediateFileSystem} fs filesystem
+	 * @param {string | Hash} hashFunction hash function to use
+	 * @returns {Serializer} file serializer
+	 */
 	createFileSerializer: (fs, hashFunction) => {
 		registerSerializers();
 		const Serializer = getSerializer();

package/lib/util/smartGrouping.js

@@ -110,7 +110,7 @@ const smartGrouping = (items, groupConfigs) => {
 		/** @type {(T | R)[]} */
 		const results = [];
 		for (;;) {
-			/** @type {Group<T, R>} */
+			/** @type {Group<T, R> | undefined} */
 			let bestGroup = undefined;
 			let bestGroupSize = -1;
 			let bestGroupItems = undefined;

package/lib/validateSchema.js

@@ -119,7 +119,9 @@ const validateSchema = (schema, options, validationConfiguration) => {
 						)
 					) {
 						return `${formattedError}\nDid you mean ${
-							DID_YOU_MEAN[params.additionalProperty]
+							DID_YOU_MEAN[
+								/** @type {keyof DID_YOU_MEAN} */ (params.additionalProperty)
+							]
 						}?`;
 					}
 
@@ -129,7 +131,9 @@ const validateSchema = (schema, options, validationConfiguration) => {
 							params.additionalProperty
 						)
 					) {
-						return `${formattedError}\n${REMOVED[params.additionalProperty]}?`;
+						return `${formattedError}\n${
+							REMOVED[/** @type {keyof REMOVED} */ (params.additionalProperty)]
+						}?`;
 					}
 
 					if (!error.dataPath) {

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

@@ -9,7 +9,19 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+
+/**
+ * @typedef {Object} AsyncWasmLoadingRuntimeModuleOptions
+ * @property {function(string): string} generateLoadBinaryCode
+ * @property {boolean} supportsStreaming
+ */
+
 class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {AsyncWasmLoadingRuntimeModuleOptions} options options
+	 */
 	constructor({ generateLoadBinaryCode, supportsStreaming }) {
 		super("wasm loading", RuntimeModule.STAGE_NORMAL);
 		this.generateLoadBinaryCode = generateLoadBinaryCode;
@@ -17,10 +29,11 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { compilation, chunk } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const { outputOptions, runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.instantiateWasm;
 		const wasmModuleSrcPath = compilation.getPath(

package/lib/wasm-async/AsyncWebAssemblyGenerator.js

@@ -13,7 +13,15 @@ const Generator = require("../Generator");
 
 const TYPES = new Set(["webassembly"]);
 
+/**
+ * @typedef {Object} AsyncWebAssemblyGeneratorOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 class AsyncWebAssemblyGenerator extends Generator {
+	/**
+	 * @param {AsyncWebAssemblyGeneratorOptions} options options
+	 */
 	constructor(options) {
 		super();
 		this.options = options;
@@ -46,7 +54,7 @@ class AsyncWebAssemblyGenerator extends Generator {
 	 * @returns {Source} generated code
 	 */
 	generate(module, generateContext) {
-		return module.originalSource();
+		return /** @type {Source} */ (module.originalSource());
 	}
 }
 

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -13,6 +13,7 @@ const Template = require("../Template");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
@@ -21,7 +22,14 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 
 const TYPES = new Set(["webassembly"]);
 
+/**
+ * @typedef {{ request: string, importVar: string }} ImportObjRequestItem
+ */
+
 class AsyncWebAssemblyJavascriptGenerator extends Generator {
+	/**
+	 * @param {OutputOptions["webassemblyModuleFilename"]} filenameTemplate template for the WebAssembly module filename
+	 */
 	constructor(filenameTemplate) {
 		super();
 		this.filenameTemplate = filenameTemplate;
@@ -61,9 +69,9 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 		runtimeRequirements.add(RuntimeGlobals.moduleId);
 		runtimeRequirements.add(RuntimeGlobals.exports);
 		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
-		/** @type {InitFragment[]} */
+		/** @type {InitFragment<InitFragment<string>>[]} */
 		const initFragments = [];
-		/** @type {Map<Module, { request: string, importVar: string }>} */
+		/** @type {Map<Module, ImportObjRequestItem>} */
 		const depModules = new Map();
 		/** @type {Map<string, WebAssemblyImportDependency[]>} */
 		const wasmDepsByRequest = new Map();
@@ -85,6 +93,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 			}
 		}
 
+		/** @type {Array<string>} */
 		const promises = [];
 
 		const importStatements = Array.from(
@@ -112,7 +121,9 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 			([request, deps]) => {
 				const exportItems = deps.map(dep => {
 					const importedModule = moduleGraph.getModule(dep);
-					const importVar = depModules.get(importedModule).importVar;
+					const importVar =
+						/** @type {ImportObjRequestItem} */
+						(depModules.get(importedModule)).importVar;
 					return `${JSON.stringify(
 						dep.name
 					)}: ${runtimeTemplate.exportFromImport({

package/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -9,11 +9,13 @@ const { SyncWaterfallHook } = require("tapable");
 const Compilation = require("../Compilation");
 const Generator = require("../Generator");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
+const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
@@ -24,6 +26,7 @@ const memoize = require("../util/memoize");
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../Template").RenderManifestEntry} RenderManifestEntry */
 /** @typedef {import("../Template").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
 
 const getAsyncWebAssemblyGenerator = memoize(() =>
 	require("./AsyncWebAssemblyGenerator")
@@ -50,9 +53,16 @@ const getAsyncWebAssemblyParser = memoize(() =>
  * @property {SyncWaterfallHook<[Source, Module, WebAssemblyRenderContext]>} renderModuleContent
  */
 
+/**
+ * @typedef {Object} AsyncWebAssemblyModulesPluginOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+const PLUGIN_NAME = "AsyncWebAssemblyModulesPlugin";
+
 class AsyncWebAssemblyModulesPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -78,6 +88,9 @@ class AsyncWebAssemblyModulesPlugin {
 		return hooks;
 	}
 
+	/**
+	 * @param {AsyncWebAssemblyModulesPluginOptions} options options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -89,7 +102,7 @@ class AsyncWebAssemblyModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"AsyncWebAssemblyModulesPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const hooks =
 					AsyncWebAssemblyModulesPlugin.getCompilationHooks(compilation);
@@ -99,15 +112,15 @@ class AsyncWebAssemblyModulesPlugin {
 				);
 
 				normalModuleFactory.hooks.createParser
-					.for("webassembly/async")
-					.tap("AsyncWebAssemblyModulesPlugin", () => {
+					.for(WEBASSEMBLY_MODULE_TYPE_ASYNC)
+					.tap(PLUGIN_NAME, () => {
 						const AsyncWebAssemblyParser = getAsyncWebAssemblyParser();
 
 						return new AsyncWebAssemblyParser();
 					});
 				normalModuleFactory.hooks.createGenerator
-					.for("webassembly/async")
-					.tap("AsyncWebAssemblyModulesPlugin", () => {
+					.for(WEBASSEMBLY_MODULE_TYPE_ASYNC)
+					.tap(PLUGIN_NAME, () => {
 						const AsyncWebAssemblyJavascriptGenerator =
 							getAsyncWebAssemblyJavascriptGenerator();
 						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
@@ -135,9 +148,10 @@ class AsyncWebAssemblyModulesPlugin {
 							chunk,
 							compareModulesByIdentifier
 						)) {
-							if (module.type === "webassembly/async") {
+							if (module.type === WEBASSEMBLY_MODULE_TYPE_ASYNC) {
 								const filenameTemplate =
-									outputOptions.webassemblyModuleFilename;
+									/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
+									(outputOptions.webassemblyModuleFilename);
 
 								result.push({
 									render: () =>
@@ -175,6 +189,12 @@ class AsyncWebAssemblyModulesPlugin {
 		);
 	}
 
+	/**
+	 * @param {Module} module the rendered module
+	 * @param {WebAssemblyRenderContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 * @returns {Source} the newly generated source from rendering
+	 */
 	renderModule(module, renderContext, hooks) {
 		const { codeGenerationResults, chunk } = renderContext;
 		try {
@@ -189,7 +209,7 @@ class AsyncWebAssemblyModulesPlugin {
 				"AsyncWebAssemblyModulesPlugin.getCompilationHooks().renderModuleContent"
 			);
 		} catch (e) {
-			e.module = module;
+			/** @type {WebpackError} */ (e).module = module;
 			throw e;
 		}
 	}

package/lib/wasm-async/AsyncWebAssemblyParser.js

@@ -11,6 +11,8 @@ const Parser = require("../Parser");
 const StaticExportsDependency = require("../dependencies/StaticExportsDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
@@ -23,6 +25,9 @@ const decoderOpts = {
 };
 
 class WebAssemblyParser extends Parser {
+	/**
+	 * @param {{}=} options parser options
+	 */
 	constructor(options) {
 		super();
 		this.hooks = Object.freeze({});
@@ -40,14 +45,16 @@ class WebAssemblyParser extends Parser {
 		}
 
 		// flag it as async module
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "namespace";
-		state.module.buildMeta.async = true;
+		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
+		buildInfo.strict = true;
+		const BuildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		BuildMeta.exportsType = "namespace";
+		BuildMeta.async = true;
 
 		// parse it
 		const program = decode(source, decoderOpts);
 		const module = program.body[0];
-
+		/** @type {Array<string>} */
 		const exports = [];
 		t.traverse(module, {
 			ModuleExport({ node }) {