webpack 5.112.0 → 5.112.2

package/lib/util/cleverMerge.js

@@ -88,19 +88,27 @@ const cachedSetProperty = (obj, property, value) => {
 
 /**
  * Defines the by values type used by this module.
- * @typedef {Map<string, EXPECTED_ANY>} ByValues
+ * @template V
+ * @typedef {Map<string, V>} ByValues
  */
 
 /**
  * Defines the object parsed property entry type used by this module.
  * @template T
+ * @template [V=T[keyof T]]
  * @typedef {object} ObjectParsedPropertyEntry
- * @property {T[keyof T] | undefined} base base value
+ * @property {V | undefined} base base value
  * @property {`by${string}` | undefined} byProperty the name of the selector property
- * @property {ByValues | undefined} byValues value depending on selector property, merged with base
+ * @property {ByValues<V | undefined> | undefined} byValues value depending on selector property, merged with base
  */
 
-/** @typedef {((...x: EXPECTED_ANY) => object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */
+/**
+ * Result of merging a value of type `A` with a value of type `B`.
+ * @template A, B
+ * @typedef {A & B | (A | B)[] | A | A[] | B | B[]} MergedValue
+ */
+
+/** @typedef {((...values: never[]) => object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */
 
 /**
  * Defines the parsed object static type used by this module.
@@ -139,7 +147,11 @@ const cachedParseObject = (obj) => {
 	return result;
 };
 
-/** @typedef {{ [p: string]: { [p: string]: EXPECTED_ANY } } | DynamicFunction} ByObject */
+/**
+ * Defines the by object type used by this module.
+ * @template T
+ * @typedef {{ [p: string]: Partial<T> } | DynamicFunction} ByObject
+ */
 
 /**
  * Returns parsed object.
@@ -172,7 +184,7 @@ const parseObject = (obj) => {
 		const key = /** @type {keyof T} */ (key_);
 		if (typeof key === "string" && key.startsWith("by")) {
 			const byProperty = key;
-			const byObj = /** @type {ByObject} */ (obj[byProperty]);
+			const byObj = /** @type {ByObject<T>} */ (obj[byProperty]);
 			if (typeof byObj === "object") {
 				for (const byValue of Object.keys(byObj)) {
 					const obj = byObj[/** @type {keyof (keyof T)} */ (byValue)];
@@ -183,20 +195,20 @@ const parseObject = (obj) => {
 							entry.byValues = new Map();
 						} else if (entry.byProperty !== byProperty) {
 							throw new Error(
-								`${/** @type {string} */ (byProperty)} and ${entry.byProperty} for a single property is not supported`
+								`${byProperty} and ${entry.byProperty} for a single property is not supported`
 							);
 						}
-						/** @type {ByValues} */
-						(entry.byValues).set(byValue, obj[key]);
+						/** @type {ByValues<T[keyof T] | undefined>} */
+						(entry.byValues).set(byValue, obj[/** @type {keyof T} */ (key)]);
 						if (byValue === "default") {
 							for (const otherByValue of Object.keys(byObj)) {
 								if (
 									!(
-										/** @type {ByValues} */
+										/** @type {ByValues<T[keyof T] | undefined>} */
 										(entry.byValues).has(otherByValue)
 									)
 								) {
-									/** @type {ByValues} */
+									/** @type {ByValues<T[keyof T] | undefined>} */
 									(entry.byValues).set(otherByValue, undefined);
 								}
 							}
@@ -237,13 +249,19 @@ const parseObject = (obj) => {
  * @returns {T} the object
  */
 const serializeObject = (info, dynamicInfo) => {
-	const obj = /** @type {EXPECTED_ANY} */ ({});
+	const obj =
+		/** @type {Record<PropertyKey, T[keyof T] | Record<string, Record<PropertyKey, T[keyof T]>> | DynamicFunction>} */
+		({});
 	// Setup byProperty structure
 	for (const entry of info.values()) {
 		if (entry.byProperty !== undefined) {
 			const byProperty = entry.byProperty;
-			const byObj = (obj[byProperty] = obj[byProperty] || {});
-			for (const byValue of /** @type {ByValues} */ (entry.byValues).keys()) {
+			const byObj =
+				/** @type {Record<string, Record<PropertyKey, T[keyof T]>>} */
+				(obj[byProperty] = obj[byProperty] || {});
+			for (const byValue of /** @type {ByValues<T[keyof T] | undefined>} */ (
+				entry.byValues
+			).keys()) {
 				byObj[byValue] = byObj[byValue] || {};
 			}
 		}
@@ -255,10 +273,12 @@ const serializeObject = (info, dynamicInfo) => {
 		// Fill byProperty structure
 		if (entry.byProperty !== undefined) {
 			const byProperty = entry.byProperty;
-			const byObj = (obj[byProperty] = obj[byProperty] || {});
+			const byObj =
+				/** @type {Record<string, Record<PropertyKey, T[keyof T]>>} */
+				(obj[byProperty] = obj[byProperty] || {});
 			for (const byValue of Object.keys(byObj)) {
 				const value = getFromByValues(
-					/** @type {ByValues} */
+					/** @type {ByValues<T[keyof T] | undefined>} */
 					(entry.byValues),
 					byValue
 				);
@@ -269,7 +289,7 @@ const serializeObject = (info, dynamicInfo) => {
 	if (dynamicInfo !== undefined) {
 		obj[dynamicInfo.byProperty] = dynamicInfo.fn;
 	}
-	return obj;
+	return /** @type {T} */ (obj);
 };
 
 const VALUE_TYPE_UNDEFINED = 0;
@@ -395,7 +415,7 @@ const _cleverMerge = (first, second, internalCaching = false) => {
  * @param {ObjectParsedPropertyEntry<T>} firstEntry a
  * @param {ObjectParsedPropertyEntry<O>} secondEntry b
  * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {ObjectParsedPropertyEntry<T> | ObjectParsedPropertyEntry<O> | ObjectParsedPropertyEntry<T & O>} new entry
+ * @returns {ObjectParsedPropertyEntry<T> | ObjectParsedPropertyEntry<O> | ObjectParsedPropertyEntry<T & O, MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} new entry
  */
 const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 	switch (getValueType(secondEntry.base)) {
@@ -420,13 +440,16 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 			} else {
 				// = first.base + (first.byProperty + second.byProperty)
 				// need to merge first and second byValues
-				/** @type {Map<string, T & O>} */
+				/** @type {ByValues<MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} */
 				const newByValues = new Map(firstEntry.byValues);
-				for (const [key, value] of /** @type {ByValues} */ (
+				for (const [
+					key,
+					value
+				] of /** @type {ByValues<O[keyof O] | undefined>} */ (
 					secondEntry.byValues
 				)) {
 					const firstValue = getFromByValues(
-						/** @type {ByValues} */
+						/** @type {ByValues<T[keyof T] | undefined>} */
 						(firstEntry.byValues),
 						key
 					);
@@ -461,7 +484,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 			}
 			/** @type {O[keyof O] | T[keyof T] | (T[keyof T] & O[keyof O]) | (T[keyof T] | undefined)[] | (O[keyof O] | undefined)[] | (O[keyof O] | T[keyof T] | undefined)[] | undefined} */
 			let newBase;
-			/** @type {Map<string, (T & O) | O[keyof O] | (O[keyof O] | undefined)[] | ((T & O) | undefined)[] | (T & O & O[keyof O]) | ((T & O) | O[keyof O] | undefined)[] | undefined>} */
+			/** @type {ByValues<MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} */
 			const intermediateByValues = new Map(firstEntry.byValues);
 			for (const [key, value] of intermediateByValues) {
 				intermediateByValues.set(
@@ -470,12 +493,14 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				);
 			}
 			if (
-				[.../** @type {ByValues} */ (firstEntry.byValues).values()].every(
-					(value) => {
-						const type = getValueType(value);
-						return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
-					}
-				)
+				[
+					.../** @type {ByValues<T[keyof T] | undefined>} */ (
+						firstEntry.byValues
+					).values()
+				].every((value) => {
+					const type = getValueType(value);
+					return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
+				})
 			) {
 				// = (first.base + second.base) + ((first.byProperty + second.base) + second.byProperty)
 				newBase = mergeSingleValue(
@@ -502,9 +527,12 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 					`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`
 				);
 			}
-			/** @type {Map<string, (T & O) | O[keyof O] | (O[keyof O] | undefined)[] | (T & O & O[keyof O]) | ((T & O) | undefined)[] | ((T & O) | O[keyof O] | undefined)[] | undefined>} */
+			/** @type {ByValues<MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} */
 			const newByValues = new Map(intermediateByValues);
-			for (const [key, value] of /** @type {ByValues} */ (
+			for (const [
+				key,
+				value
+			] of /** @type {ByValues<O[keyof O] | undefined>} */ (
 				secondEntry.byValues
 			)) {
 				const firstValue = getFromByValues(intermediateByValues, key);
@@ -525,7 +553,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 /**
  * Gets from by values.
  * @template V
- * @param {ByValues} byValues all values
+ * @param {ByValues<V>} byValues all values
  * @param {string} key value of the selector
  * @returns {V | undefined} value
  */
@@ -543,7 +571,7 @@ const getFromByValues = (byValues, key) => {
  * @param {A | A[]} a value
  * @param {B | B[]} b value
  * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {A & B | (A | B)[] | A | A[] | B | B[]} value
+ * @returns {MergedValue<A, B>} value
  */
 const mergeSingleValue = (a, b, internalCaching) => {
 	const bType = getValueType(b);
@@ -635,7 +663,7 @@ const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 				newObj[key] =
 					/** @type {T[keyof T]} */
 					(
-						/** @type {EXPECTED_ANY[]} */
+						/** @type {T[keyof T] extends readonly (infer E)[] ? E[] : never} */
 						(value).filter((i) => i !== "...")
 					);
 				break;

package/lib/util/comparators.js

@@ -93,7 +93,9 @@ const compareIds = (a, b) => {
  */
 const compareIterables = (elementComparator) => {
 	const cacheEntry = compareIteratorsCache.get(elementComparator);
-	if (cacheEntry !== undefined) return cacheEntry;
+	if (cacheEntry !== undefined) {
+		return /** @type {Comparator<Iterable<T>>} */ (cacheEntry);
+	}
 	/**
 	 * Returns compare result.
 	 * @param {Iterable<T>} a first value
@@ -419,7 +421,7 @@ class TwoKeyWeakMap {
 	}
 }
 
-/** @type {TwoKeyWeakMap<Comparator<EXPECTED_ANY>, Comparator<EXPECTED_ANY>, Comparator<EXPECTED_ANY>>}} */
+/** @type {TwoKeyWeakMap<Comparator<never>, Comparator<never>, Comparator<never>>} */
 const concatComparatorsCache = new TwoKeyWeakMap();
 
 /**
@@ -460,7 +462,7 @@ const concatComparators = (c1, c2, ...cRest) => {
  * @typedef {(input: A) => B | undefined | null} Selector
  */
 
-/** @type {TwoKeyWeakMap<Selector<EXPECTED_ANY, EXPECTED_ANY>, Comparator<EXPECTED_ANY>, Comparator<EXPECTED_ANY>>}} */
+/** @type {TwoKeyWeakMap<(input: never) => void, Comparator<never>, Comparator<never>>} */
 const compareSelectCache = new TwoKeyWeakMap();
 
 /**
@@ -473,7 +475,9 @@ const compareSelectCache = new TwoKeyWeakMap();
  */
 const compareSelect = (getter, comparator) => {
 	const cacheEntry = compareSelectCache.get(getter, comparator);
-	if (cacheEntry !== undefined) return cacheEntry;
+	if (cacheEntry !== undefined) {
+		return /** @type {Comparator<T>} */ (cacheEntry);
+	}
 	/**
 	 * Returns compare result.
 	 * @param {T} a first value
@@ -530,7 +534,7 @@ const compareErrors = concatComparators(
 	)
 );
 
-/** @type {WeakMap<Comparator<EXPECTED_ANY>, Comparator<Iterable<EXPECTED_ANY>>>} */
+/** @type {WeakMap<Comparator<never>, Comparator<Iterable<never>>>} */
 const compareIteratorsCache = new WeakMap();
 
 // TODO this is no longer needed when minimum node.js version is >= 12

package/lib/util/dataURL.js

@@ -327,6 +327,8 @@ const askEmbeddedRenderer = async (render, hole, reported) => {
 
 module.exports = {
 	EMBEDDED_LANGUAGES,
+	JSON_TYPE,
+	SVG_TYPE,
 	URIRegEx,
 	askEmbeddedRenderer,
 	buildDataURI,

package/lib/util/deprecation.js

@@ -96,7 +96,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 			`${name} was changed from Array to Set (using Array method '${method}' is deprecated)`,
 			"ARRAY_TO_SET"
 		);
-		/** @type {EXPECTED_ANY} */
+		/** @type {Set<T> & Record<COPY_METHODS_NAMES, (this: Set<T>) => void>} */
 		(set)[method] =
 			// eslint-disable-next-line func-names
 			function () {
@@ -318,10 +318,11 @@ module.exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
 			set: util.deprecate(
 				/**
 				 * Handles the callback logic for this hook.
+				 * @template V
 				 * @param {object} target target
 				 * @param {string | symbol} property property
-				 * @param {EXPECTED_ANY} value value
-				 * @param {EXPECTED_ANY} receiver receiver
+				 * @param {V} value value
+				 * @param {T} receiver receiver
 				 * @returns {boolean} result
 				 */
 				(target, property, value, receiver) =>

package/lib/util/globUtils.js

@@ -15,10 +15,7 @@ const memoize = require("./memoize");
 
 // watchpack's glob-to-regexp core, loaded only when a glob is translated
 const getGlobToRegExpSource = memoize(
-	() =>
-		/** @type {{ util: { globToRegExp: (glob: string) => string } }} */ (
-			/** @type {unknown} */ (require("watchpack"))
-		).util.globToRegExp
+	() => require("watchpack").util.globToRegExp
 );
 
 /** @typedef {{ caseSensitive?: boolean, requireLiteralLeadingDot?: boolean }} GlobMatchOptions */

package/lib/util/internalSerializables.js

@@ -315,6 +315,8 @@ module.exports = {
 		require("../dependencies/esm/ESMImportSideEffectDependency"),
 	"dependencies/esm/ESMImportSpecifierDependency": () =>
 		require("../dependencies/esm/ESMImportSpecifierDependency"),
+	"dependencies/esm/ESMLiveExportDependency": () =>
+		require("../dependencies/esm/ESMLiveExportDependency"),
 	"dependencies/esm/TopLevelAwaitDependency": () =>
 		require("../dependencies/esm/TopLevelAwaitDependency"),
 	"dependencies/hmr/ImportMetaHotAcceptDependency": () =>

package/lib/util/makeSerializable.js

@@ -8,7 +8,6 @@ const { register, registerLegacyRequest } = require("./serialization");
 
 /**
  * @import {
- * 	Constructor,
  * 	ObjectDeserializerContext,
  * 	ObjectSerializerContext
  * } from "../serialization/ObjectMiddleware"
@@ -18,7 +17,7 @@ const { register, registerLegacyRequest } = require("./serialization");
 /**
  * Defines the serializable class constructor type used by this module.
  * @template {SerializableClass} T
- * @typedef {(new (...params: EXPECTED_ANY[]) => T) & { deserialize?: (context: ObjectDeserializerContext) => T }} SerializableClassConstructor
+ * @typedef {(new (...params: never[]) => T) & { deserialize?: (context: ObjectDeserializerContext) => T }} SerializableClassConstructor
  */
 
 /**
@@ -64,7 +63,7 @@ class ClassSerializer {
  * keep requests the class was written under before a move readable: the first
  * is the one it is written under now, the rest restore older cache packs; a
  * historical entry written under another name pairs its request with it.
- * @template {Constructor} T
+ * @template {new (...params: never[]) => EXPECTED_OBJECT} T
  * @param {T} Constructor the constructor
  * @param {string | (string | [string, string | null])[]} request the request which will be required when deserializing, current one first
  * @param {string | null=} name the name to make multiple serializer unique when sharing a request
@@ -75,7 +74,10 @@ module.exports = (Constructor, request, name = null) => {
 		Constructor,
 		/** @type {string} */ (requests[0]),
 		name,
-		new ClassSerializer(Constructor)
+		new ClassSerializer(
+			/** @type {SerializableClassConstructor<SerializableClass>} */
+			(Constructor)
+		)
 	);
 	// TODO in the next major release: remove, dropping every request but the
 	// first from each caller, which stops pre-move cache packs loading

package/lib/util/memoize.js

@@ -31,7 +31,7 @@ const memoize = (fn) => {
 		// and all dependent resources
 		/** @type {FunctionReturning<T> | undefined} */
 		(fn) = undefined;
-		return /** @type {T} */ (result);
+		return result;
 	};
 };
 

package/lib/util/parseJson.js

@@ -8,7 +8,7 @@ const memoize = require("./memoize");
 
 const getJSONParseError = memoize(() => require("../errors/JSONParseError"));
 
-/** @import { JsonValue } from "../fs/fs" */
+/** @import { JsonArray, JsonObject, JsonValue } from "../fs/fs" */
 
 // Inspired by https://github.com/npm/json-parse-even-better-errors
 
@@ -25,7 +25,7 @@ const stripBOM = (txt) => String(txt).replace(/^\uFEFF/, "");
  * @template [R=JsonValue]
  * @callback ParseJsonFn
  * @param {string} raw text
- * @param {(this: EXPECTED_ANY, key: string, value: EXPECTED_ANY) => EXPECTED_ANY=} reviver reviver
+ * @param {(this: JsonObject | JsonArray, key: string, value: JsonValue) => JsonValue=} reviver reviver
  * @returns {R} parsed JSON
  */
 

package/lib/util/serialization.js

@@ -54,6 +54,12 @@ const registerSerializers = memoize(() => {
  */
 /** @import { HashFunction } from "../util/Hash" */
 /** @import { IntermediateFileSystem } from "../fs/fs" */
+/**
+ * @import {
+ * 	BufferSerializableType,
+ * 	ComplexSerializableType
+ * } from "../serialization/types"
+ */
 
 /**
  * Defines the serializer type used by this module.
@@ -62,7 +68,7 @@ const registerSerializers = memoize(() => {
  */
 
 /**
- * @type {Serializer<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>}
+ * @type {Serializer<ComplexSerializableType, BufferSerializableType[], EXPECTED_OBJECT>}
  */
 let buffersSerializer;
 
@@ -97,7 +103,7 @@ module.exports = {
 		const Serializer = getSerializer();
 		const binaryMiddleware = getBinaryMiddlewareInstance();
 		const SingleItemMiddleware = getSingleItemMiddleware();
-		return /** @type {Serializer<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>} */ (
+		return /** @type {Serializer<ComplexSerializableType, BufferSerializableType[], EXPECTED_OBJECT>} */ (
 			buffersSerializer = new Serializer([
 				new SingleItemMiddleware(),
 				new ObjectMiddleware((context) => {
@@ -129,30 +135,28 @@ module.exports = {
 		const fileMiddleware = new FileMiddleware(fs, hashFunction);
 		const binaryMiddleware = getBinaryMiddlewareInstance();
 		const SingleItemMiddleware = getSingleItemMiddleware();
-		return /** @type {Serializer<D, S, C>} */ (
-			new Serializer([
-				new SingleItemMiddleware(),
-				new ObjectMiddleware((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 new Serializer([
+			new SingleItemMiddleware(),
+			new ObjectMiddleware((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/AsyncWasmModule.js

@@ -7,12 +7,22 @@
 const NormalModule = require("../module/NormalModule");
 const makeSerializable = require("../util/makeSerializable");
 
-/** @import Module from "../module/Module" */
-/** @import { NormalModuleCreateData } from "../module/NormalModule" */
+/** @import Module, { BuildMeta } from "../module/Module" */
+/**
+ * @import {
+ * 	NormalModuleBuildInfo,
+ * 	NormalModuleCreateData
+ * } from "../module/NormalModule"
+ */
 /** @import { ImportPhaseName } from "../dependencies/core/ImportPhase" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ImportPhaseName | undefined]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ImportPhaseName | undefined]>} ObjectSerializerContext */
 
+/**
+ * A built async wasm module, typed with its build info and build meta.
+ * @typedef {NormalModule & { buildInfo: NormalModuleBuildInfo, buildMeta: BuildMeta }} BuiltAsyncWasmModule
+ */
+
 /**
  * Module class for `webassembly/async` modules. Wasm-specific properties should live here instead of `NormalModule`.
  */

package/lib/wasm/AsyncWebAssemblyGenerator.js

@@ -20,6 +20,14 @@ const { WEBASSEMBLY_TYPES } = require("../module/ModuleSourceTypeConstants");
  * @property {boolean=} mangleImports mangle imports
  */
 
+/**
+ * The module type the JSDoc inherited from `Generator` names.
+ * @typedef {NormalModule} TModule
+ */
+
+/**
+ * @extends {Generator<TModule>}
+ */
 class AsyncWebAssemblyGenerator extends Generator {
 	/**
 	 * Creates an instance of AsyncWebAssemblyGenerator.
@@ -33,7 +41,7 @@ class AsyncWebAssemblyGenerator extends Generator {
 
 	/**
 	 * Returns the source types available for this module.
-	 * @param {NormalModule} module fresh module
+	 * @param {TModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
@@ -42,7 +50,7 @@ class AsyncWebAssemblyGenerator extends Generator {
 
 	/**
 	 * Returns the estimated size for the requested source type.
-	 * @param {NormalModule} module the module
+	 * @param {TModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
@@ -56,7 +64,7 @@ class AsyncWebAssemblyGenerator extends Generator {
 
 	/**
 	 * Generates generated code for this runtime module.
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */
@@ -67,7 +75,7 @@ class AsyncWebAssemblyGenerator extends Generator {
 	/**
 	 * Generates fallback output for the provided error condition.
 	 * @param {Error} error the error
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */

package/lib/wasm/AsyncWebAssemblyJavascriptGenerator.js

@@ -25,10 +25,18 @@ const Template = require("../template/Template");
  * @typedef {{ request: string, importVar: string, dependency: WebAssemblyImportDependency }} ImportObjRequestItem
  */
 
+/**
+ * The module type the JSDoc inherited from `Generator` names.
+ * @typedef {NormalModule} TModule
+ */
+
+/**
+ * @extends {Generator<TModule>}
+ */
 class AsyncWebAssemblyJavascriptGenerator extends Generator {
 	/**
 	 * Returns the source types available for this module.
-	 * @param {NormalModule} module fresh module
+	 * @param {TModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
@@ -37,7 +45,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 
 	/**
 	 * Returns the estimated size for the requested source type.
-	 * @param {NormalModule} module the module
+	 * @param {TModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
@@ -53,7 +61,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 
 	/**
 	 * Generates generated code for this runtime module.
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */
@@ -236,7 +244,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 
 	/**
 	 * Generate code for source phase import (returns WebAssembly.Module)
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source} generated code
 	 */
@@ -298,7 +306,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 	/**
 	 * Generates fallback output for the provided error condition.
 	 * @param {Error} error the error
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */

package/lib/wasm/AsyncWebAssemblyParser.js

@@ -16,8 +16,7 @@ const getEnvironmentNotSupportAsyncWarning = memoize(() =>
 	require("../errors/EnvironmentNotSupportAsyncWarning")
 );
 
-/** @import AsyncWasmModule from "./AsyncWasmModule" */
-/** @import { BuildInfo, BuildMeta } from "../module/Module" */
+/** @import AsyncWasmModule, { BuiltAsyncWasmModule } from "./AsyncWasmModule" */
 /** @import { ParserState, PreparsedAst } from "../module/Parser" */
 
 const WASM_HEADER = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
@@ -30,6 +29,9 @@ const decoderOpts = {
 	ignoreCustomNameSection: true
 };
 
+/**
+ * @extends {Parser<BuiltAsyncWasmModule>}
+ */
 class AsyncWebAssemblyParser extends Parser {
 	/**
 	 * Parses the provided source and updates the parser state.
@@ -42,7 +44,9 @@ class AsyncWebAssemblyParser extends Parser {
 			throw new Error("AsyncWebAssemblyParser input must be a Buffer");
 		}
 
-		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		const { buildInfo, buildMeta } = /** @type {BuiltAsyncWasmModule} */ (
+			state.module
+		);
 		buildMeta.exportsType = "namespace";
 		buildMeta.async = true;
 
@@ -53,8 +57,6 @@ class AsyncWebAssemblyParser extends Parser {
 		);
 
 		// flag it as async module
-		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
-
 		buildInfo.strict = true;
 
 		if (/** @type {AsyncWasmModule} */ (state.module).phase === "source") {