webpack 5.84.1 → 5.85.0

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -51,7 +51,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		/** @type {Map<string | FilenameFunction, Set<Chunk>>} */
 		const chunkFilenames = new Map();
 		let maxChunks = 0;
-		/** @type {string} */
+		/** @type {string | undefined} */
 		let dynamicFilename;
 
 		/**
@@ -69,9 +69,20 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				if (typeof chunkFilename === "string") {
 					if (set.size < maxChunks) return;
 					if (set.size === maxChunks) {
-						if (chunkFilename.length < dynamicFilename.length) return;
-						if (chunkFilename.length === dynamicFilename.length) {
-							if (chunkFilename < dynamicFilename) return;
+						if (
+							chunkFilename.length <
+							/** @type {string} */ (dynamicFilename).length
+						) {
+							return;
+						}
+
+						if (
+							chunkFilename.length ===
+							/** @type {string} */ (dynamicFilename).length
+						) {
+							if (chunkFilename < /** @type {string} */ (dynamicFilename)) {
+								return;
+							}
 						}
 					}
 					maxChunks = set.size;
@@ -108,7 +119,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 			addChunk(entrypoint.chunks[entrypoint.chunks.length - 1]);
 		}
 
-		/** @type {Map<string, Set<string | number>>} */
+		/** @type {Map<string, Set<string | number | null>>} */
 		const staticUrls = new Map();
 		/** @type {Set<Chunk>} */
 		const dynamicUrlChunks = new Set();
@@ -152,10 +163,14 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				hashWithLength: length =>
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				chunk: {
-					id: unquotedStringify(c.id),
-					hash: unquotedStringify(c.renderedHash),
-					hashWithLength: unquotedStringifyWithLength(c.renderedHash),
-					name: unquotedStringify(c.name || c.id),
+					id: unquotedStringify(/** @type {number | string} */ (c.id)),
+					hash: unquotedStringify(/** @type {string} */ (c.renderedHash)),
+					hashWithLength: unquotedStringifyWithLength(
+						/** @type {string} */ (c.renderedHash)
+					),
+					name: unquotedStringify(
+						c.name || /** @type {number | string} */ (c.id)
+					),
 					contentHash: {
 						[contentType]: unquotedStringify(c.contentHash[contentType])
 					},
@@ -187,8 +202,10 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		 * @returns {string} code with static mapping of results of fn
 		 */
 		const createMap = fn => {
+			/** @type {Record<number | string, number | string>} */
 			const obj = {};
 			let useId = false;
+			/** @type {number | string | undefined} */
 			let lastKey;
 			let entries = 0;
 			for (const c of dynamicUrlChunks) {
@@ -196,8 +213,8 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				if (value === c.id) {
 					useId = true;
 				} else {
-					obj[c.id] = value;
-					lastKey = c.id;
+					obj[/** @type {number | string} */ (c.id)] = value;
+					lastKey = /** @type {number | string} */ (c.id);
 					entries++;
 				}
 			}
@@ -205,9 +222,9 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 			if (entries === 1) {
 				return useId
 					? `(chunkId === ${JSON.stringify(lastKey)} ? ${JSON.stringify(
-							obj[lastKey]
+							obj[/** @type {number | string} */ (lastKey)]
 					  )} : chunkId)`
-					: JSON.stringify(obj[lastKey]);
+					: JSON.stringify(obj[/** @type {number | string} */ (lastKey)]);
 			}
 			return useId
 				? `(${JSON.stringify(obj)}[chunkId] || chunkId)`
@@ -238,9 +255,11 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				chunk: {
 					id: `" + chunkId + "`,
-					hash: mapExpr(c => c.renderedHash),
-					hashWithLength: mapExprWithLength(c => c.renderedHash),
-					name: mapExpr(c => c.name || c.id),
+					hash: mapExpr(c => /** @type {string} */ (c.renderedHash)),
+					hashWithLength: mapExprWithLength(
+						c => /** @type {string} */ (c.renderedHash)
+					),
+					name: mapExpr(c => c.name || /** @type {number | string} */ (c.id)),
 					contentHash: {
 						[contentType]: mapExpr(c => c.contentHash[contentType])
 					},

package/lib/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -10,7 +10,7 @@ const HelperRuntimeModule = require("./HelperRuntimeModule");
 
 class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
 	/**
-	 * @param {Set<string>} runtimeRequirements runtime requirements
+	 * @param {ReadonlySet<string>} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
 		super("trusted types policy");

package/lib/runtime/LoadScriptRuntimeModule.js

@@ -72,7 +72,7 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 			"script = document.createElement('script');",
 			scriptType ? `script.type = ${JSON.stringify(scriptType)};` : "",
 			charset ? "script.charset = 'utf-8';" : "",
-			`script.timeout = ${loadTimeout / 1000};`,
+			`script.timeout = ${/** @type {number} */ (loadTimeout) / 1000};`,
 			`if (${RuntimeGlobals.scriptNonce}) {`,
 			Template.indent(
 				`script.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`

package/lib/runtime/PublicPathRuntimeModule.js

@@ -7,7 +7,12 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+
 class PublicPathRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {OutputOptions["publicPath"]} publicPath public path
+	 */
 	constructor(publicPath) {
 		super("publicPath", RuntimeModule.STAGE_BASIC);
 		this.publicPath = publicPath;

package/lib/runtime/StartupChunkDependenciesPlugin.js

@@ -8,9 +8,20 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const StartupChunkDependenciesRuntimeModule = require("./StartupChunkDependenciesRuntimeModule");
 const StartupEntrypointRuntimeModule = require("./StartupEntrypointRuntimeModule");
 
+/** @typedef {import("../../declarations/WebpackOptions").ChunkLoadingType} ChunkLoadingType */
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * @typedef {Object} Options
+ * @property {ChunkLoadingType} chunkLoading
+ * @property {boolean=} asyncChunkLoading
+ */
+
 class StartupChunkDependenciesPlugin {
+	/**
+	 * @param {Options} options options
+	 */
 	constructor(options) {
 		this.chunkLoading = options.chunkLoading;
 		this.asyncChunkLoading =
@@ -29,6 +40,10 @@ class StartupChunkDependenciesPlugin {
 			"StartupChunkDependenciesPlugin",
 			compilation => {
 				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				/**
+				 * @param {Chunk} chunk chunk to check
+				 * @returns {boolean} true, when the plugin is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -10,6 +10,9 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {boolean} asyncChunkLoading use async chunk loading
+	 */
 	constructor(asyncChunkLoading) {
 		super("startup chunk dependencies", RuntimeModule.STAGE_TRIGGER);
 		this.asyncChunkLoading = asyncChunkLoading;

package/lib/runtime/StartupEntrypointRuntimeModule.js

@@ -10,6 +10,9 @@ const RuntimeModule = require("../RuntimeModule");
 /** @typedef {import("../MainTemplate")} MainTemplate */
 
 class StartupEntrypointRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {boolean} asyncChunkLoading use async chunk loading
+	 */
 	constructor(asyncChunkLoading) {
 		super("startup entrypoint");
 		this.asyncChunkLoading = asyncChunkLoading;

package/lib/sharing/ProvideSharedModuleFactory.js

@@ -15,7 +15,7 @@ const ProvideSharedModule = require("./ProvideSharedModule");
 class ProvideSharedModuleFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {

package/lib/util/createHash.js

@@ -132,7 +132,7 @@ let BatchedHash = undefined;
 
 /**
  * Creates a hash by name or function
- * @param {string | typeof Hash} algorithm the algorithm name or a constructor creating a hash
+ * @param {string | typeof Hash | undefined} algorithm the algorithm name or a constructor creating a hash
  * @returns {Hash} the hash
  */
 module.exports = algorithm => {

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -9,7 +9,16 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/**
+ * @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;

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();
@@ -113,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

@@ -15,6 +15,7 @@ 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 */
@@ -25,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")
@@ -51,6 +53,11 @@ 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();
 
@@ -81,6 +88,9 @@ class AsyncWebAssemblyModulesPlugin {
 		return hooks;
 	}
 
+	/**
+	 * @param {AsyncWebAssemblyModulesPluginOptions} options options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -140,7 +150,8 @@ class AsyncWebAssemblyModulesPlugin {
 						)) {
 							if (module.type === WEBASSEMBLY_MODULE_TYPE_ASYNC) {
 								const filenameTemplate =
-									outputOptions.webassemblyModuleFilename;
+									/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
+									(outputOptions.webassemblyModuleFilename);
 
 								result.push({
 									render: () =>
@@ -178,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 {
@@ -192,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

@@ -23,6 +23,9 @@ const decoderOpts = {
 };
 
 class WebAssemblyParser extends Parser {
+	/**
+	 * @param {{}=} options parser options
+	 */
 	constructor(options) {
 		super();
 		this.hooks = Object.freeze({});

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -10,14 +10,22 @@ const Template = require("../Template");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const WebAssemblyUtils = require("./WebAssemblyUtils");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 // TODO webpack 6 remove the whole folder
 
 // Get all wasm modules
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Chunk} chunk the chunk
+ * @returns {Module[]} all wasm modules
+ */
 const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
 	const wasmModules = chunk.getAllAsyncChunks();
 	const array = [];
@@ -39,7 +47,7 @@ const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
  * generates the import object function for a module
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Module} module the module
- * @param {boolean} mangle mangle imports
+ * @param {boolean | undefined} mangle mangle imports
  * @param {string[]} declarations array where declarations are pushed to
  * @param {RuntimeSpec} runtime the runtime
  * @returns {string} source code
@@ -188,7 +196,18 @@ const generateImportObject = (
 	}
 };
 
+/**
+ * @typedef {Object} WasmChunkLoadingRuntimeModuleOptions
+ * @property {(path: string) => string} generateLoadBinaryCode
+ * @property {boolean} [supportsStreaming]
+ * @property {boolean} [mangleImports]
+ * @property {Set<string>} runtimeRequirements
+ */
+
 class WasmChunkLoadingRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {WasmChunkLoadingRuntimeModuleOptions} options options
+	 */
 	constructor({
 		generateLoadBinaryCode,
 		supportsStreaming,
@@ -213,6 +232,7 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 			RuntimeGlobals.hmrDownloadUpdateHandlers
 		);
 		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
+		/** @type {string[]} */
 		const declarations = [];
 		const importObjects = wasmModules.map(module => {
 			return generateImportObject(
@@ -226,6 +246,10 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 		const chunkModuleIdMap = chunkGraph.getChunkModuleIdMap(chunk, m =>
 			m.type.startsWith("webassembly")
 		);
+		/**
+		 * @param {string} content content
+		 * @returns {string} created import object
+		 */
 		const createImportObject = content =>
 			mangleImports
 				? `{ ${JSON.stringify(WebAssemblyUtils.MANGLED_MODULE)}: ${content} }`

package/lib/wasm-sync/WasmFinalizeExportsPlugin.js

@@ -9,6 +9,8 @@ const formatLocation = require("../formatLocation");
 const UnsupportedWebAssemblyFeatureError = require("./UnsupportedWebAssemblyFeatureError");
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
 
 class WasmFinalizeExportsPlugin {
 	/**
@@ -37,12 +39,13 @@ class WasmFinalizeExportsPlugin {
 								// 2. is active and referenced by a non-WebAssembly module
 								if (
 									connection.isTargetActive(undefined) &&
-									connection.originModule.type.startsWith("webassembly") ===
+									/** @type {Module} */
+									(connection.originModule).type.startsWith("webassembly") ===
 										false
 								) {
 									const referencedExports =
 										compilation.getDependencyReferencedExports(
-											connection.dependency,
+											/** @type {Dependency} */ (connection.dependency),
 											undefined
 										);
 
@@ -61,9 +64,15 @@ class WasmFinalizeExportsPlugin {
 											// 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 ${connection.originModule.readableIdentifier(
-														compilation.requestShortener
-													)} at ${formatLocation(connection.dependency.loc)}.`
+													`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

@@ -27,7 +27,7 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 /** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
 
 /**
- * @typedef {(ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
+ * @typedef {(buf: ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
  */
 
 /**
@@ -62,9 +62,10 @@ const removeStartFunc = state => bin => {
  * Get imported globals
  *
  * @param {Object} ast Module's AST
- * @returns {Array<t.ModuleImport>} - nodes
+ * @returns {t.ModuleImport[]} - nodes
  */
 const getImportedGlobals = ast => {
+	/** @type {t.ModuleImport[]} */
 	const importedGlobals = [];
 
 	t.traverse(ast, {
@@ -318,7 +319,10 @@ const addInitFunction =
 				`${importedGlobal.module}.${importedGlobal.name}`
 			);
 
-			return t.funcParam(importedGlobal.descr.valtype, id);
+			return t.funcParam(
+				/** @type {string} */ (importedGlobal.descr.valtype),
+				id
+			);
 		});
 
 		const funcBody = [];
@@ -344,6 +348,7 @@ const addInitFunction =
 
 		funcBody.push(t.instruction("end"));
 
+		/** @type {string[]} */
 		const funcResults = [];
 
 		// Code section
@@ -369,7 +374,7 @@ const addInitFunction =
  * Extract mangle mappings from module
  * @param {ModuleGraph} moduleGraph module graph
  * @param {Module} module current module
- * @param {boolean} mangle mangle imports
+ * @param {boolean | undefined} mangle mangle imports
  * @returns {Map<string, UsedWasmDependency>} mappings to mangled names
  */
 const getUsedDependencyMap = (moduleGraph, module, mangle) => {
@@ -390,7 +395,15 @@ const getUsedDependencyMap = (moduleGraph, module, mangle) => {
 
 const TYPES = new Set(["webassembly"]);
 
+/**
+ * @typedef {Object} WebAssemblyGeneratorOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 class WebAssemblyGenerator extends Generator {
+	/**
+	 * @param {WebAssemblyGeneratorOptions} options options
+	 */
 	constructor(options) {
 		super();
 		this.options = options;
@@ -423,7 +436,7 @@ class WebAssemblyGenerator extends Generator {
 	 * @returns {Source} generated code
 	 */
 	generate(module, { moduleGraph, runtime }) {
-		const bin = module.originalSource().source();
+		const bin = /** @type {Source} */ (module.originalSource()).source();
 
 		const initFuncId = t.identifier("");
 

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -55,7 +55,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 			runtimeRequirements,
 			runtime
 		} = generateContext;
-		/** @type {InitFragment[]} */
+		/** @type {InitFragment<InitFragment<string>>[]} */
 		const initFragments = [];
 
 		const exportsInfo = moduleGraph.getExportsInfo(module);

package/lib/wasm-sync/WebAssemblyModulesPlugin.js

@@ -14,6 +14,7 @@ const memoize = require("../util/memoize");
 const WebAssemblyInInitialChunkError = require("./WebAssemblyInInitialChunkError");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleTemplate")} ModuleTemplate */
@@ -29,7 +30,15 @@ const getWebAssemblyParser = memoize(() => require("./WebAssemblyParser"));
 
 const PLUGIN_NAME = "WebAssemblyModulesPlugin";
 
+/**
+ * @typedef {Object} WebAssemblyModulesPluginOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 class WebAssemblyModulesPlugin {
+	/**
+	 * @param {WebAssemblyModulesPluginOptions} options options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -83,7 +92,9 @@ class WebAssemblyModulesPlugin {
 						compareModulesByIdentifier
 					)) {
 						if (module.type === WEBASSEMBLY_MODULE_TYPE_SYNC) {
-							const filenameTemplate = outputOptions.webassemblyModuleFilename;
+							const filenameTemplate =
+								/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
+								(outputOptions.webassemblyModuleFilename);
 
 							result.push({
 								render: () =>

package/lib/wasm-sync/WebAssemblyParser.js

@@ -61,6 +61,9 @@ const decoderOpts = {
 };
 
 class WebAssemblyParser extends Parser {
+	/**
+	 * @param {{}=} options parser options
+	 */
 	constructor(options) {
 		super();
 		this.hooks = Object.freeze({});
@@ -88,10 +91,12 @@ class WebAssemblyParser extends Parser {
 		const moduleContext = moduleContextFromModuleAST(module);
 
 		// extract imports and exports
+		/** @type {string[]} */
 		const exports = [];
 		let jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports =
 			undefined);
 
+		/** @type {TODO[]} */
 		const importedGlobals = [];
 		t.traverse(module, {
 			ModuleExport({ node }) {
@@ -157,12 +162,14 @@ class WebAssemblyParser extends Parser {
 				} else if (t.isTable(node.descr) === true) {
 					onlyDirectImport = "Table";
 				} else if (t.isFuncImportDescr(node.descr) === true) {
-					const incompatibleType = getJsIncompatibleType(node.descr.signature);
+					const incompatibleType = getJsIncompatibleType(
+						/** @type {t.Signature} */ (node.descr.signature)
+					);
 					if (incompatibleType) {
 						onlyDirectImport = `Non-JS-compatible Func Signature (${incompatibleType})`;
 					}
 				} else if (t.isGlobalType(node.descr) === true) {
-					const type = node.descr.valtype;
+					const type = /** @type {string} */ (node.descr.valtype);
 					if (!JS_COMPAT_TYPES.has(type)) {
 						onlyDirectImport = `Non-JS-compatible Global Type (${type})`;
 					}

package/lib/wasm-sync/WebAssemblyUtils.js

@@ -22,7 +22,7 @@ const MANGLED_MODULE = "a";
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {Module} module the module
- * @param {boolean} mangle mangle module and export names
+ * @param {boolean | undefined} mangle mangle module and export names
  * @returns {UsedWasmDependency[]} used dependencies and (mangled) name
  */
 const getUsedDependencies = (moduleGraph, module, mangle) => {