webpack 5.95.0 → 5.96.0

package/lib/util/makeSerializable.js

@@ -7,16 +7,38 @@
 const { register } = require("./serialization");
 
 /** @typedef {import("../serialization/ObjectMiddleware").Constructor} Constructor */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
+/** @typedef {{ serialize: (context: ObjectSerializerContext) => void, deserialize: (context: ObjectDeserializerContext) => void }} SerializableClass */
+/**
+ * @template {SerializableClass} T
+ * @typedef {(new (...params: any[]) => T) & { deserialize?: (context: ObjectDeserializerContext) => T }} SerializableClassConstructor
+ */
+
+/**
+ * @template {SerializableClass} T
+ */
 class ClassSerializer {
+	/**
+	 * @param {SerializableClassConstructor<T>} Constructor constructor
+	 */
 	constructor(Constructor) {
 		this.Constructor = Constructor;
 	}
 
+	/**
+	 * @param {T} obj obj
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(obj, context) {
 		obj.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {T} obj
+	 */
 	deserialize(context) {
 		if (typeof this.Constructor.deserialize === "function") {
 			return this.Constructor.deserialize(context);
@@ -28,7 +50,8 @@ class ClassSerializer {
 }
 
 /**
- * @param {Constructor} Constructor the constructor
+ * @template {Constructor} T
+ * @param {T} Constructor the constructor
  * @param {string} request the request which will be required when deserializing
  * @param {string | null} [name] the name to make multiple serializer unique when sharing a request
  */

package/lib/util/memoize.js

@@ -24,7 +24,8 @@ const memoize = fn => {
 		cache = true;
 		// Allow to clean up memory for fn
 		// and all dependent resources
-		fn = undefined;
+		/** @type {FunctionReturning<T> | undefined} */
+		(fn) = undefined;
 		return /** @type {T} */ (result);
 	};
 };

package/lib/util/runtime.js

@@ -633,7 +633,10 @@ class RuntimeSpecMap {
 	}
 
 	get size() {
-		if (/** @type {number} */ (this._mode) <= 1) return this._mode;
+		if (/** @type {number} */ (this._mode) <= 1) {
+			return /** @type {number} */ (this._mode);
+		}
+
 		return /** @type {Map<string, T>} */ (this._map).size;
 	}
 }

package/lib/util/semver.js

@@ -6,30 +6,42 @@
 "use strict";
 
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {(string|number|undefined|[])[]} SemVerRange */
+/** @typedef {string | number | undefined} SemVerRangeItem */
+/** @typedef {(SemVerRangeItem | SemVerRangeItem[])[]} SemVerRange */
 
 /**
  * @param {string} str version string
- * @returns {(string|number|undefined|[])[]} parsed version
+ * @returns {SemVerRange} parsed version
  */
 const parseVersion = str => {
+	/**
+	 * @param {str} str str
+	 * @returns {(string | number)[]} result
+	 */
 	var splitAndConvert = function (str) {
 		return str.split(".").map(function (item) {
 			// eslint-disable-next-line eqeqeq
-			return +item == item ? +item : item;
+			return +item == /** @type {EXPECTED_ANY} */ (item) ? +item : item;
 		});
 	};
-	var match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
-	/** @type {(string|number|undefined|[])[]} */
+
+	var match =
+		/** @type {RegExpExecArray} */
+		(/^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str));
+
+	/** @type {(string | number | undefined | [])[]} */
 	var ver = match[1] ? splitAndConvert(match[1]) : [];
+
 	if (match[2]) {
 		ver.length++;
 		ver.push.apply(ver, splitAndConvert(match[2]));
 	}
+
 	if (match[3]) {
 		ver.push([]);
 		ver.push.apply(ver, splitAndConvert(match[3]));
 	}
+
 	return ver;
 };
 module.exports.parseVersion = parseVersion;
@@ -89,16 +101,28 @@ module.exports.versionLt = versionLt;
  * @returns {SemVerRange} parsed range
  */
 module.exports.parseRange = str => {
+	/**
+	 * @param {string} str str
+	 * @returns {(string | number)[]} result
+	 */
 	const splitAndConvert = str => {
 		return str
 			.split(".")
 			.map(item => (item !== "NaN" && `${+item}` === item ? +item : item));
 	};
+
 	// see https://docs.npmjs.com/misc/semver#range-grammar for grammar
+	/**
+	 * @param {string} str str
+	 * @returns {SemVerRangeItem[]}
+	 */
 	const parsePartial = str => {
-		const match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
-		/** @type {(string|number|undefined|[])[]} */
+		const match =
+			/** @type {RegExpExecArray} */
+			(/^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str));
+		/** @type {SemVerRangeItem[]} */
 		const ver = match[1] ? [0, ...splitAndConvert(match[1])] : [0];
+
 		if (match[2]) {
 			ver.length++;
 			ver.push.apply(ver, splitAndConvert(match[2]));
@@ -116,6 +140,12 @@ module.exports.parseRange = str => {
 
 		return ver;
 	};
+
+	/**
+	 *
+	 * @param {SemVerRangeItem[]} range range
+	 * @returns {SemVerRangeItem[]}
+	 */
 	const toFixed = range => {
 		if (range.length === 1) {
 			// Special case for "*" is "x.x.x" instead of "="
@@ -130,9 +160,20 @@ module.exports.parseRange = str => {
 
 		return [range.length, ...range.slice(1)];
 	};
+
+	/**
+	 *
+	 * @param {SemVerRangeItem[]} range
+	 * @returns {SemVerRangeItem[]} result
+	 */
 	const negate = range => {
-		return [-range[0] - 1, ...range.slice(1)];
+		return [-(/** @type { [number]} */ (range)[0]) - 1, ...range.slice(1)];
 	};
+
+	/**
+	 * @param {string} str str
+	 * @returns {SemVerRange}
+	 */
 	const parseSimple = str => {
 		// simple       ::= primitive | partial | tilde | caret
 		// primitive    ::= ( '<' | '>' | '>=' | '<=' | '=' | '!' ) ( ' ' ) * partial
@@ -143,6 +184,7 @@ module.exports.parseRange = str => {
 		const remainder = parsePartial(
 			start.length ? str.slice(start.length).trim() : str.trim()
 		);
+
 		switch (start) {
 			case "^":
 				if (remainder.length > 1 && remainder[1] === 0) {
@@ -185,6 +227,13 @@ module.exports.parseRange = str => {
 				throw new Error("Unexpected start value");
 		}
 	};
+
+	/**
+	 *
+	 * @param {SemVerRangeItem[][]} items items
+	 * @param {number} fn fn
+	 * @returns {SemVerRange} result
+	 */
 	const combine = (items, fn) => {
 		if (items.length === 1) return items[0];
 		const arr = [];
@@ -195,38 +244,64 @@ module.exports.parseRange = str => {
 				arr.push(...item.slice(1));
 			}
 		}
+
 		// eslint-disable-next-line no-sparse-arrays
 		return [, ...arr, ...items.slice(1).map(() => fn)];
 	};
+
+	/**
+	 * @param {string} str str
+	 * @returns {SemVerRange}
+	 */
 	const parseRange = str => {
 		// range      ::= hyphen | simple ( ' ' ( ' ' ) * simple ) * | ''
 		// hyphen     ::= partial ( ' ' ) * ' - ' ( ' ' ) * partial
 		const items = str.split(/\s+-\s+/);
+
 		if (items.length === 1) {
-			const items = str
-				.trim()
-				.split(/(?<=[-0-9A-Za-z])\s+/g)
-				.map(parseSimple);
+			const items =
+				/** @type {SemVerRangeItem[][]} */
+				(
+					str
+						.trim()
+						.split(/(?<=[-0-9A-Za-z])\s+/g)
+						.map(parseSimple)
+				);
+
 			return combine(items, 2);
 		}
+
 		const a = parsePartial(items[0]);
 		const b = parsePartial(items[1]);
 		// >=a <=b => and( >=a, or( <b, =b ) ) => >=a, <b, =b, or, and
 		// eslint-disable-next-line no-sparse-arrays
 		return [, toFixed(b), negate(b), 1, a, 2];
 	};
+
+	/**
+	 * @param {string} str str
+	 * @returns {SemVerRange}
+	 */
 	const parseLogicalOr = str => {
 		// range-set  ::= range ( logical-or range ) *
 		// logical-or ::= ( ' ' ) * '||' ( ' ' ) *
-		const items = str.split(/\s*\|\|\s*/).map(parseRange);
+		const items =
+			/** @type {SemVerRangeItem[][]} */
+			(str.split(/\s*\|\|\s*/).map(parseRange));
+
 		return combine(items, 1);
 	};
+
 	return parseLogicalOr(str);
 };
 
 /* eslint-disable eqeqeq */
+/**
+ * @param {SemVerRange} range
+ * @returns {string}
+ */
 const rangeToString = range => {
-	var fixCount = range[0];
+	var fixCount = /** @type {number} */ (range[0]);
 	var str = "";
 	if (range.length === 1) {
 		return "*";
@@ -270,7 +345,7 @@ const rangeToString = range => {
 					? "(" + pop() + " || " + pop() + ")"
 					: item === 2
 						? stack.pop() + " " + stack.pop()
-						: rangeToString(item)
+						: rangeToString(/** @type {SemVerRange} */ (item))
 		);
 	}
 	return pop();
@@ -279,10 +354,9 @@ const rangeToString = range => {
 		return /** @type {string} */ (stack.pop()).replace(/^\((.+)\)$/, "$1");
 	}
 };
-/* eslint-enable eqeqeq */
+
 module.exports.rangeToString = rangeToString;
 
-/* eslint-disable eqeqeq */
 /**
  * @param {SemVerRange} range version range
  * @param {string} version the version
@@ -341,16 +415,22 @@ const satisfy = (range, version) => {
 			// big-cmp: when negated => return false, else => next-nequ
 			// small-cmp: when negated => next-nequ, else => return false
 
-			var rangeType = j < range.length ? (typeof range[j])[0] : "";
+			var rangeType =
+				/** @type {"s" | "n" | "u" | ""} */
+				(j < range.length ? (typeof range[j])[0] : "");
 
+			/** @type {number | string | undefined} */
 			var versionValue;
+			/** @type {"n" | "s" | "u" | "o" | undefined} */
 			var versionType;
 
 			// Handles first column in both tables (end of version or object)
 			if (
 				i >= version.length ||
 				((versionValue = version[i]),
-				(versionType = (typeof versionValue)[0]) == "o")
+				(versionType = /** @type {"n" | "s" | "u" | "o"} */ (
+					(typeof versionValue)[0]
+				)) == "o")
 			) {
 				// Handles nequal
 				if (!isEqual) return true;
@@ -378,7 +458,11 @@ const satisfy = (range, version) => {
 						}
 					} else {
 						// Handles "cmp" cases
-						if (negated ? versionValue > range[j] : versionValue < range[j]) {
+						if (
+							negated
+								? versionValue > /** @type {(number | string)[]} */ (range)[j]
+								: versionValue < /** @type {(number | string)[]} */ (range)[j]
+						) {
 							return false;
 						}
 						if (versionValue != range[j]) isEqual = false;
@@ -410,17 +494,20 @@ const satisfy = (range, version) => {
 			}
 		}
 	}
+
 	/** @type {(boolean | number)[]} */
 	var stack = [];
 	var p = stack.pop.bind(stack);
 	// eslint-disable-next-line no-redeclare
 	for (var i = 1; i < range.length; i++) {
-		var item = /** @type {SemVerRange | 0 | 1 | 2} */ (range[i]);
+		var item = /** @type {SemVerRangeItem[] | 0 | 1 | 2} */ (range[i]);
+
 		stack.push(
 			item == 1
-				? p() | p()
+				? /** @type {() => number} */ (p)() | /** @type {() => number} */ (p)()
 				: item == 2
-					? p() & p()
+					? /** @type {() => number} */ (p)() &
+						/** @type {() => number} */ (p)()
 					: item
 						? satisfy(item, version)
 						: !p()
@@ -431,6 +518,10 @@ const satisfy = (range, version) => {
 /* eslint-enable eqeqeq */
 module.exports.satisfy = satisfy;
 
+/**
+ * @param {SemVerRange | string | number | false | undefined} json
+ * @returns {string}
+ */
 module.exports.stringifyHoley = json => {
 	switch (typeof json) {
 		case "undefined":
@@ -453,6 +544,10 @@ module.exports.stringifyHoley = json => {
 };
 
 //#region runtime code: parseVersion
+/**
+ * @param {RuntimeTemplate} runtimeTemplate
+ * @returns {string}
+ */
 exports.parseVersionRuntimeCode = runtimeTemplate =>
 	`var parseVersion = ${runtimeTemplate.basicFunction("str", [
 		"// see webpack/lib/util/semver.js for original code",
@@ -461,6 +556,10 @@ exports.parseVersionRuntimeCode = runtimeTemplate =>
 //#endregion
 
 //#region runtime code: versionLt
+/**
+ * @param {RuntimeTemplate} runtimeTemplate
+ * @returns {string}
+ */
 exports.versionLtRuntimeCode = runtimeTemplate =>
 	`var versionLt = ${runtimeTemplate.basicFunction("a, b", [
 		"// see webpack/lib/util/semver.js for original code",
@@ -469,6 +568,10 @@ exports.versionLtRuntimeCode = runtimeTemplate =>
 //#endregion
 
 //#region runtime code: rangeToString
+/**
+ * @param {RuntimeTemplate} runtimeTemplate
+ * @returns {string}
+ */
 exports.rangeToStringRuntimeCode = runtimeTemplate =>
 	`var rangeToString = ${runtimeTemplate.basicFunction("range", [
 		"// see webpack/lib/util/semver.js for original code",
@@ -477,6 +580,10 @@ exports.rangeToStringRuntimeCode = runtimeTemplate =>
 //#endregion
 
 //#region runtime code: satisfy
+/**
+ * @param {RuntimeTemplate} runtimeTemplate
+ * @returns {string}
+ */
 exports.satisfyRuntimeCode = runtimeTemplate =>
 	`var satisfy = ${runtimeTemplate.basicFunction("range, version", [
 		"// see webpack/lib/util/semver.js for original code",

package/lib/wasm/EnableWasmLoadingPlugin.js

@@ -52,8 +52,8 @@ class EnableWasmLoadingPlugin {
 			throw new Error(
 				`Library type "${type}" is not enabled. ` +
 					"EnableWasmLoadingPlugin need to be used to enable this type of wasm loading. " +
-					`This usually happens through the "output.enabledWasmLoadingTypes" option. ` +
-					`If you are using a function as entry which sets "wasmLoading", you need to add all potential library types to "output.enabledWasmLoadingTypes". ` +
+					'This usually happens through the "output.enabledWasmLoadingTypes" option. ' +
+					'If you are using a function as entry which sets "wasmLoading", you need to add all potential library types to "output.enabledWasmLoadingTypes". ' +
 					`These types are enabled: ${Array.from(
 						getEnabledTypes(compiler)
 					).join(", ")}`

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -44,7 +44,7 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
 				module: {
 					id: '" + wasmModuleId + "',
-					hash: `" + wasmModuleHash + "`,
+					hash: '" + wasmModuleHash + "',
 					hashWithLength(length) {
 						return `" + wasmModuleHash.slice(0, ${length}) + "`;
 					}
@@ -75,7 +75,7 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 				concat(
 					"return req.then(",
 					runtimeTemplate.basicFunction("res", [
-						`if (typeof WebAssembly.instantiateStreaming === "function") {`,
+						'if (typeof WebAssembly.instantiateStreaming === "function") {',
 						Template.indent([
 							"return WebAssembly.instantiateStreaming(res, importsObj)",
 							Template.indent([
@@ -86,7 +86,7 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 										"res"
 									)},`,
 									runtimeTemplate.basicFunction("e", [
-										`if(res.headers.get("Content-Type") !== "application/wasm") {`,
+										'if(res.headers.get("Content-Type") !== "application/wasm") {',
 										Template.indent([
 											'console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n", e);',
 											"return fallback();"

package/lib/wasm-async/AsyncWebAssemblyGenerator.js

@@ -6,13 +6,13 @@
 "use strict";
 
 const Generator = require("../Generator");
+const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypesConstants");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
 
-const TYPES = new Set(["webassembly"]);
-
 /**
  * @typedef {object} AsyncWebAssemblyGeneratorOptions
  * @property {boolean} [mangleImports] mangle imports
@@ -29,10 +29,10 @@ class AsyncWebAssemblyGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		return TYPES;
+		return WEBASSEMBLY_TYPES;
 	}
 
 	/**
@@ -51,7 +51,7 @@ class AsyncWebAssemblyGenerator extends Generator {
 	/**
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @returns {Source | null} generated code
 	 */
 	generate(module, generateContext) {
 		return /** @type {Source} */ (module.originalSource());

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -8,6 +8,7 @@
 const { RawSource } = require("webpack-sources");
 const Generator = require("../Generator");
 const InitFragment = require("../InitFragment");
+const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypesConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
@@ -17,11 +18,10 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @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 */
 
-const TYPES = new Set(["webassembly"]);
-
 /**
  * @typedef {{ request: string, importVar: string }} ImportObjRequestItem
  */
@@ -37,10 +37,10 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		return TYPES;
+		return WEBASSEMBLY_TYPES;
 	}
 
 	/**
@@ -55,7 +55,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 	/**
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @returns {Source | null} generated code
 	 */
 	generate(module, generateContext) {
 		const {

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -5,14 +5,14 @@
 
 "use strict";
 
-const { RawSource } = require("webpack-sources");
-const Generator = require("../Generator");
-const WebAssemblyUtils = require("./WebAssemblyUtils");
-
 const t = require("@webassemblyjs/ast");
 const { moduleContextFromModuleAST } = require("@webassemblyjs/ast");
 const { editWithAST, addWithAST } = require("@webassemblyjs/wasm-edit");
 const { decode } = require("@webassemblyjs/wasm-parser");
+const { RawSource } = require("webpack-sources");
+const Generator = require("../Generator");
+const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypesConstants");
+const WebAssemblyUtils = require("./WebAssemblyUtils");
 
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 
@@ -20,6 +20,7 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 /** @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 */
@@ -400,8 +401,6 @@ const getUsedDependencyMap = (moduleGraph, module, mangle) => {
 	return map;
 };
 
-const TYPES = new Set(["webassembly"]);
-
 /**
  * @typedef {object} WebAssemblyGeneratorOptions
  * @property {boolean} [mangleImports] mangle imports
@@ -418,10 +417,10 @@ class WebAssemblyGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		return TYPES;
+		return WEBASSEMBLY_TYPES;
 	}
 
 	/**
@@ -440,7 +439,7 @@ class WebAssemblyGenerator extends Generator {
 	/**
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @returns {Source | null} generated code
 	 */
 	generate(module, { moduleGraph, runtime }) {
 		const bin = /** @type {Source} */ (module.originalSource()).source();

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -9,6 +9,7 @@ const { RawSource } = require("webpack-sources");
 const { UsageState } = require("../ExportsInfo");
 const Generator = require("../Generator");
 const InitFragment = require("../InitFragment");
+const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypesConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const ModuleDependency = require("../dependencies/ModuleDependency");
@@ -20,18 +21,17 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @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 */
 
-const TYPES = new Set(["webassembly"]);
-
 class WebAssemblyJavascriptGenerator extends Generator {
 	/**
 	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		return TYPES;
+		return WEBASSEMBLY_TYPES;
 	}
 
 	/**
@@ -46,7 +46,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 	/**
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @returns {Source | null} generated code
 	 */
 	generate(module, generateContext) {
 		const {

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -44,9 +44,8 @@ class FetchCompileAsyncWasmPlugin {
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.instantiateWasm)
-					.tap("FetchCompileAsyncWasmPlugin", (chunk, set) => {
+					.tap("FetchCompileAsyncWasmPlugin", (chunk, set, { chunkGraph }) => {
 						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
 						if (
 							!chunkGraph.hasModuleInGraph(
 								chunk,

package/lib/web/FetchCompileWasmPlugin.js

@@ -58,9 +58,8 @@ class FetchCompileWasmPlugin {
 
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.ensureChunkHandlers)
-				.tap(PLUGIN_NAME, (chunk, set) => {
+				.tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {
 					if (!isEnabledForChunk(chunk)) return;
-					const chunkGraph = compilation.chunkGraph;
 					if (
 						!chunkGraph.hasModuleInGraph(
 							chunk,

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -103,12 +103,6 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 		const withHmrManifest = this._runtimeRequirements.has(
 			RuntimeGlobals.hmrDownloadManifest
 		);
-		const withPrefetch = this._runtimeRequirements.has(
-			RuntimeGlobals.prefetchChunkHandlers
-		);
-		const withPreload = this._runtimeRequirements.has(
-			RuntimeGlobals.preloadChunkHandlers
-		);
 		const withFetchPriority = this._runtimeRequirements.has(
 			RuntimeGlobals.hasFetchPriority
 		);
@@ -117,6 +111,12 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 		)}]`;
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const chunk = /** @type {Chunk} */ (this.chunk);
+		const withPrefetch =
+			this._runtimeRequirements.has(RuntimeGlobals.prefetchChunkHandlers) &&
+			chunk.hasChildByOrder(chunkGraph, "prefetch", true, chunkHasJs);
+		const withPreload =
+			this._runtimeRequirements.has(RuntimeGlobals.preloadChunkHandlers) &&
+			chunk.hasChildByOrder(chunkGraph, "preload", true, chunkHasJs);
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);