webpack 5.101.3 → 5.102.1

package/lib/util/hash/BatchedHash.js

@@ -8,6 +8,8 @@
 const Hash = require("../Hash");
 const MAX_SHORT_STRING = require("./wasm-hash").MAX_SHORT_STRING;
 
+/** @typedef {import("../../../declarations/WebpackOptions").HashDigest} Encoding */
+
 class BatchedHash extends Hash {
 	/**
 	 * @param {Hash} hash hash
@@ -21,9 +23,22 @@ class BatchedHash extends Hash {
 
 	/**
 	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
+	 * @overload
+	 * @param {string | Buffer} data data
+	 * @returns {Hash} updated hash
+	 */
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @overload
+	 * @param {string} data data
+	 * @param {Encoding} inputEncoding data encoding
+	 * @returns {Hash} updated hash
+	 */
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string | Buffer} data data
+	 * @param {Encoding=} inputEncoding data encoding
+	 * @returns {Hash} updated hash
 	 */
 	update(data, inputEncoding) {
 		if (this.string !== undefined) {
@@ -35,7 +50,11 @@ class BatchedHash extends Hash {
 				this.string += data;
 				return this;
 			}
-			this.hash.update(this.string, this.encoding);
+			if (this.encoding) {
+				this.hash.update(this.string, this.encoding);
+			} else {
+				this.hash.update(this.string);
+			}
 			this.string = undefined;
 		}
 		if (typeof data === "string") {
@@ -46,8 +65,10 @@ class BatchedHash extends Hash {
 			) {
 				this.string = data;
 				this.encoding = inputEncoding;
-			} else {
+			} else if (inputEncoding) {
 				this.hash.update(data, inputEncoding);
+			} else {
+				this.hash.update(data);
 			}
 		} else {
 			this.hash.update(data);
@@ -57,12 +78,30 @@ class BatchedHash extends Hash {
 
 	/**
 	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
+	 * @overload
+	 * @returns {Buffer} digest
+	 */
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @overload
+	 * @param {Encoding} encoding encoding of the return value
+	 * @returns {string} digest
+	 */
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {Encoding=} encoding encoding of the return value
+	 * @returns {string | Buffer} digest
 	 */
 	digest(encoding) {
 		if (this.string !== undefined) {
-			this.hash.update(this.string, this.encoding);
+			if (this.encoding) {
+				this.hash.update(this.string, this.encoding);
+			} else {
+				this.hash.update(this.string);
+			}
+		}
+		if (!encoding) {
+			return this.hash.digest();
 		}
 		return this.hash.digest(encoding);
 	}

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

@@ -5,13 +5,15 @@
 
 "use strict";
 
+const Hash = require("../Hash");
+
 // 65536 is the size of a wasm memory page
 // 64 is the maximum chunk size for every possible wasm hash implementation
 // 4 is the maximum number of bytes per char for string encoding (max is utf-8)
 // ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
 const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
 
-class WasmHash {
+class WasmHash extends Hash {
 	/**
 	 * @param {WebAssembly.Instance} instance wasm instance
 	 * @param {WebAssembly.Instance[]} instancesPool pool of instances
@@ -19,6 +21,8 @@ class WasmHash {
 	 * @param {number} digestSize size of digest returned by wasm
 	 */
 	constructor(instance, instancesPool, chunkSize, digestSize) {
+		super();
+
 		const exports = /** @type {EXPECTED_ANY} */ (instance.exports);
 		exports.init();
 		this.exports = exports;
@@ -35,17 +39,39 @@ class WasmHash {
 	}
 
 	/**
-	 * @param {Buffer | string} data data
-	 * @param {BufferEncoding=} encoding encoding
-	 * @returns {this} itself
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @overload
+	 * @param {string | Buffer} data data
+	 * @returns {Hash} updated hash
+	 */
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @overload
+	 * @param {string} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
 	 */
-	update(data, encoding) {
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string | Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
+	update(data, inputEncoding) {
 		if (typeof data === "string") {
 			while (data.length > MAX_SHORT_STRING) {
-				this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
+				this._updateWithShortString(
+					data.slice(0, MAX_SHORT_STRING),
+					/** @type {NodeJS.BufferEncoding} */
+					(inputEncoding)
+				);
 				data = data.slice(MAX_SHORT_STRING);
 			}
-			this._updateWithShortString(data, encoding);
+			this._updateWithShortString(
+				data,
+				/** @type {NodeJS.BufferEncoding} */
+				(inputEncoding)
+			);
 			return this;
 		}
 		this._updateWithBuffer(data);
@@ -136,17 +162,31 @@ class WasmHash {
 	}
 
 	/**
-	 * @param {BufferEncoding} type type
-	 * @returns {Buffer | string} digest
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @overload
+	 * @returns {Buffer} digest
+	 */
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @overload
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string} digest
+	 */
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string | Buffer} digest
 	 */
-	digest(type) {
+	digest(encoding) {
 		const { exports, buffered, mem, digestSize } = this;
 		exports.final(buffered);
 		this.instancesPool.push(this);
 		const hex = mem.toString("latin1", 0, digestSize);
-		if (type === "hex") return hex;
-		if (type === "binary" || !type) return Buffer.from(hex, "hex");
-		return Buffer.from(hex, "hex").toString(type);
+		if (encoding === "hex") return hex;
+		if (encoding === "binary" || !encoding) return Buffer.from(hex, "hex");
+		return Buffer.from(hex, "hex").toString(
+			/** @type {NodeJS.BufferEncoding} */ (encoding)
+		);
 	}
 }
 

package/lib/util/semver.js

@@ -6,7 +6,8 @@
 "use strict";
 
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {string | number | undefined} SemVerRangeItem */
+/** @typedef {string | number} VersionValue */
+/** @typedef {VersionValue | undefined} SemVerRangeItem */
 /** @typedef {(SemVerRangeItem | SemVerRangeItem[])[]} SemVerRange */
 
 /**
@@ -16,12 +17,12 @@
 const parseVersion = (str) => {
 	/**
 	 * @param {str} str str
-	 * @returns {(string | number)[]} result
+	 * @returns {VersionValue[]} result
 	 */
 	var splitAndConvert = function (str) {
 		return str.split(".").map(function (item) {
 			// eslint-disable-next-line eqeqeq
-			return +item == /** @type {EXPECTED_ANY} */ (item) ? +item : item;
+			return +item == /** @type {string | number} */ (item) ? +item : item;
 		});
 	};
 
@@ -29,7 +30,7 @@ const parseVersion = (str) => {
 		/** @type {RegExpExecArray} */
 		(/^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str));
 
-	/** @type {(string | number | undefined | [])[]} */
+	/** @type {(VersionValue | undefined | [])[]} */
 	var ver = match[1] ? splitAndConvert(match[1]) : [];
 
 	if (match[2]) {
@@ -103,7 +104,7 @@ module.exports.versionLt = versionLt;
 module.exports.parseRange = (str) => {
 	/**
 	 * @param {string} str str
-	 * @returns {(string | number)[]} result
+	 * @returns {VersionValue[]} result
 	 */
 	const splitAndConvert = (str) => {
 		return str
@@ -429,7 +430,7 @@ const satisfy = (range, version) => {
 				/** @type {"s" | "n" | "u" | ""} */
 				(j < range.length ? (typeof range[j])[0] : "");
 
-			/** @type {number | string | undefined} */
+			/** @type {VersionValue | undefined} */
 			var versionValue;
 			/** @type {"n" | "s" | "u" | "o" | undefined} */
 			var versionType;
@@ -470,8 +471,8 @@ const satisfy = (range, version) => {
 						// Handles "cmp" cases
 						if (
 							negated
-								? versionValue > /** @type {(number | string)[]} */ (range)[j]
-								: versionValue < /** @type {(number | string)[]} */ (range)[j]
+								? versionValue > /** @type {VersionValue[]} */ (range)[j]
+								: versionValue < /** @type {VersionValue[]} */ (range)[j]
 						) {
 							return false;
 						}

package/lib/util/smartGrouping.js

@@ -13,42 +13,53 @@
  */
 
 /**
- * @template T
- * @template R
+ * @template I
+ * @template G
  * @typedef {object} GroupConfig
- * @property {(item: T) => string[] | undefined} getKeys
- * @property {(key: string, children: (R | T)[], items: T[]) => R} createGroup
- * @property {(name: string, items: T[]) => GroupOptions=} getOptions
+ * @property {(item: I) => string[] | undefined} getKeys
+ * @property {(name: string, items: I[]) => GroupOptions=} getOptions
+ * @property {(key: string, children: I[], items: I[]) => G} createGroup
  */
 
 /**
- * @template T
- * @template R
+ * @template I
+ * @template G
+ * @typedef {{ config: GroupConfig<I, G>, name: string, alreadyGrouped: boolean, items: Items<I, G> | undefined }} Group
+ */
+
+/**
+ * @template I, G
+ * @typedef {Set<Group<I, G>>} Groups
+ */
+
+/**
+ * @template I
+ * @template G
  * @typedef {object} ItemWithGroups
- * @property {T} item
- * @property {Set<Group<T, R>>} groups
+ * @property {I} item
+ * @property {Groups<I, G>} groups
  */
 
 /**
- * @template T
- * @template R
- * @typedef {{ config: GroupConfig<T, R>, name: string, alreadyGrouped: boolean, items: Set<ItemWithGroups<T, R>> | undefined }} Group
+ * @template T, G
+ * @typedef {Set<ItemWithGroups<T, G>>} Items
  */
 
 /**
- * @template T
+ * @template I
+ * @template G
  * @template R
- * @param {T[]} items the list of items
- * @param {GroupConfig<T, R>[]} groupConfigs configuration
- * @returns {(R | T)[]} grouped items
+ * @param {I[]} items the list of items
+ * @param {GroupConfig<I, G>[]} groupConfigs configuration
+ * @returns {(I | G)[]} grouped items
  */
 const smartGrouping = (items, groupConfigs) => {
-	/** @type {Set<ItemWithGroups<T, R>>} */
+	/** @type {Items<I, G>} */
 	const itemsWithGroups = new Set();
-	/** @type {Map<string, Group<T, R>>} */
+	/** @type {Map<string, Group<I, G>>} */
 	const allGroups = new Map();
 	for (const item of items) {
-		/** @type {Set<Group<T, R>>} */
+		/** @type {Groups<I, G>} */
 		const groups = new Set();
 		for (let i = 0; i < groupConfigs.length; i++) {
 			const groupConfig = groupConfigs[i];
@@ -77,9 +88,10 @@ const smartGrouping = (items, groupConfigs) => {
 			groups
 		});
 	}
+
 	/**
-	 * @param {Set<ItemWithGroups<T, R>>} itemsWithGroups input items with groups
-	 * @returns {(T | R)[]} groups items
+	 * @param {Items<I, G>} itemsWithGroups input items with groups
+	 * @returns {(I | G)[]} groups items
 	 */
 	const runGrouping = (itemsWithGroups) => {
 		const totalSize = itemsWithGroups.size;
@@ -94,7 +106,7 @@ const smartGrouping = (items, groupConfigs) => {
 				}
 			}
 		}
-		/** @type {Map<Group<T, R>, { items: Set<ItemWithGroups<T, R>>, options: GroupOptions | false | undefined, used: boolean }>} */
+		/** @type {Map<Group<I, G>, { items: Items<I, G>, options: GroupOptions | false | undefined, used: boolean }>} */
 		const groupMap = new Map();
 		for (const group of allGroups.values()) {
 			if (group.items) {
@@ -107,13 +119,15 @@ const smartGrouping = (items, groupConfigs) => {
 				});
 			}
 		}
-		/** @type {(T | R)[]} */
+		/** @type {(I | G)[]} */
 		const results = [];
 		for (;;) {
-			/** @type {Group<T, R> | undefined} */
+			/** @type {Group<I, G> | undefined} */
 			let bestGroup;
 			let bestGroupSize = -1;
+			/** @type {Items<I, G> | undefined} */
 			let bestGroupItems;
+			/** @type {GroupOptions | false | undefined} */
 			let bestGroupOptions;
 			for (const [group, state] of groupMap) {
 				const { items, used } = state;
@@ -192,8 +206,9 @@ const smartGrouping = (items, groupConfigs) => {
 			bestGroup.alreadyGrouped = true;
 			const children = groupChildren ? runGrouping(items) : allItems;
 			bestGroup.alreadyGrouped = false;
-
-			results.push(groupConfig.createGroup(key, children, allItems));
+			results.push(
+				groupConfig.createGroup(key, /** @type {I[]} */ (children), allItems)
+			);
 		}
 		for (const { item } of itemsWithGroups) {
 			results.push(item);

package/lib/util/traverseDestructuringAssignmentProperties.js

@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+
+/**
+ * Deep first traverse the properties of a destructuring assignment.
+ * @param {DestructuringAssignmentProperties} properties destructuring assignment properties
+ * @param {((stack: DestructuringAssignmentProperty[]) => void) | undefined=} onLeftNode on left node callback
+ * @param {((stack: DestructuringAssignmentProperty[]) => void) | undefined=} enterNode enter node callback
+ * @param {((stack: DestructuringAssignmentProperty[]) => void) | undefined=} exitNode exit node callback
+ * @param {DestructuringAssignmentProperty[] | undefined=} stack stack of the walking nodes
+ */
+function traverseDestructuringAssignmentProperties(
+	properties,
+	onLeftNode,
+	enterNode,
+	exitNode,
+	stack = []
+) {
+	for (const property of properties) {
+		stack.push(property);
+		if (enterNode) enterNode(stack);
+		if (property.pattern) {
+			traverseDestructuringAssignmentProperties(
+				property.pattern,
+				onLeftNode,
+				enterNode,
+				exitNode,
+				stack
+			);
+		} else if (onLeftNode) {
+			onLeftNode(stack);
+		}
+		if (exitNode) exitNode(stack);
+		stack.pop();
+	}
+}
+
+module.exports = traverseDestructuringAssignmentProperties;

package/lib/wasm/EnableWasmLoadingPlugin.js

@@ -5,16 +5,17 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WasmLoadingType} WasmLoadingType */
 /** @typedef {import("../Compiler")} Compiler */
 
+/** @typedef {Set<WasmLoadingType>} WasmLoadingTypes */
+
 /** @type {WeakMap<Compiler, Set<WasmLoadingType>>} */
 const enabledTypes = new WeakMap();
 
 /**
  * @param {Compiler} compiler compiler instance
- * @returns {Set<WasmLoadingType>} enabled types
+ * @returns {WasmLoadingTypes} enabled types
  */
 const getEnabledTypes = (compiler) => {
 	let set = enabledTypes.get(compiler);

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -76,7 +76,11 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 			)})`
 		];
 		const getStreaming = () => {
-			const concat = (/** @type {string[]} */ ...text) => text.join("");
+			/**
+			 * @param {string[]} text text
+			 * @returns {string} merged text
+			 */
+			const concat = (...text) => text.join("");
 			return [
 				this.generateBeforeLoadBinaryCode
 					? this.generateBeforeLoadBinaryCode(wasmModuleSrcPath)

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -14,27 +14,16 @@ 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 */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 /**
  * @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;
-	}
-
 	/**
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
@@ -69,7 +58,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 		runtimeRequirements.add(RuntimeGlobals.moduleId);
 		runtimeRequirements.add(RuntimeGlobals.exports);
 		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
-		/** @type {InitFragment<InitFragment<string>>[]} */
+		/** @type {InitFragment<GenerateContext>[]} */
 		const initFragments = [];
 		/** @type {Map<Module, ImportObjRequestItem>} */
 		const depModules = new Map();
@@ -93,7 +82,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 			}
 		}
 
-		/** @type {Array<string>} */
+		/** @type {string[]} */
 		const promises = [];
 
 		const importStatements = Array.from(

package/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -15,7 +15,6 @@ const { compareModulesByIdOrIdentifier } = 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,8 +23,6 @@ const memoize = require("../util/memoize");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../Template").RenderManifestEntry} RenderManifestEntry */
-/** @typedef {import("../Template").RenderManifestOptions} RenderManifestOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
 
 const getAsyncWebAssemblyGenerator = memoize(() =>
@@ -126,9 +123,7 @@ class AsyncWebAssemblyModulesPlugin {
 						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
 
 						return Generator.byType({
-							javascript: new AsyncWebAssemblyJavascriptGenerator(
-								compilation.outputOptions.webassemblyModuleFilename
-							),
+							javascript: new AsyncWebAssemblyJavascriptGenerator(),
 							webassembly: new AsyncWebAssemblyGenerator(this.options)
 						});
 					});
@@ -147,9 +142,7 @@ class AsyncWebAssemblyModulesPlugin {
 						compareModulesByIdOrIdentifier(chunkGraph)
 					)) {
 						if (module.type === WEBASSEMBLY_MODULE_TYPE_ASYNC) {
-							const filenameTemplate =
-								/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
-								(outputOptions.webassemblyModuleFilename);
+							const filenameTemplate = outputOptions.webassemblyModuleFilename;
 
 							result.push({
 								render: () =>

package/lib/wasm-async/AsyncWebAssemblyParser.js

@@ -26,15 +26,6 @@ const decoderOpts = {
 };
 
 class WebAssemblyParser extends Parser {
-	/**
-	 * @param {{}=} options parser options
-	 */
-	constructor(options) {
-		super();
-		this.hooks = Object.freeze({});
-		this.options = options;
-	}
-
 	/**
 	 * @param {string | Buffer | PreparsedAst} source the source to parse
 	 * @param {ParserState} state the parser state
@@ -60,8 +51,9 @@ class WebAssemblyParser extends Parser {
 		// parse it
 		const program = decode(source, decoderOpts);
 		const module = program.body[0];
-		/** @type {Array<string>} */
+		/** @type {string[]} */
 		const exports = [];
+
 		t.traverse(module, {
 			ModuleExport({ node }) {
 				exports.push(node.name);

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -46,12 +46,14 @@ const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
 	return array;
 };
 
+/** @typedef {string[]} Declarations */
+
 /**
  * generates the import object function for a module
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Module} module the module
  * @param {boolean | undefined} mangle mangle imports
- * @param {string[]} declarations array where declarations are pushed to
+ * @param {Declarations} declarations array where declarations are pushed to
  * @param {RuntimeSpec} runtime the runtime
  * @returns {string} source code
  */
@@ -63,7 +65,7 @@ const generateImportObject = (
 	runtime
 ) => {
 	const moduleGraph = chunkGraph.moduleGraph;
-	/** @type {Map<string, string | number>} */
+	/** @type {Map<string, ModuleId>} */
 	const waitForInstances = new Map();
 	const properties = [];
 	const usedWasmDependencies = WebAssemblyUtils.getUsedDependencies(
@@ -146,7 +148,7 @@ const generateImportObject = (
 			"};"
 		];
 	} else {
-		/** @type {Map<string, Array<{ name: string, value: string }>>} */
+		/** @type {Map<string, { name: string, value: string }[]>} */
 		const propertiesByModule = new Map();
 		for (const p of properties) {
 			let list = propertiesByModule.get(p.module);
@@ -253,7 +255,7 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
 		const { mangleImports } = this;
-		/** @type {string[]} */
+		/** @type {Declarations} */
 		const declarations = [];
 		const importObjects = wasmModules.map((module) =>
 			generateImportObject(

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -16,13 +16,11 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 const WebAssemblyUtils = require("./WebAssemblyUtils");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
 /** @typedef {import("@webassemblyjs/ast").Instruction} Instruction */
@@ -175,7 +173,7 @@ const createDefaultInitForGlobal = (globalType) => {
  */
 const rewriteImportedGlobals = (state) => (bin) => {
 	const additionalInitCode = state.additionalInitCode;
-	/** @type {Array<t.Global>} */
+	/** @type {t.Global[]} */
 	const newGlobals = [];
 
 	bin = editWithAST(state.ast, bin, {

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -17,13 +17,10 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class WebAssemblyJavascriptGenerator extends Generator {
 	/**
@@ -56,7 +53,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 			runtimeRequirements,
 			runtime
 		} = generateContext;
-		/** @type {InitFragment<InitFragment<string>>[]} */
+		/** @type {InitFragment<GenerateContext>[]} */
 		const initFragments = [];
 
 		const exportsInfo = moduleGraph.getExportsInfo(module);