webpack 5.76.1 → 5.88.2

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -10,14 +10,23 @@ const Template = require("../Template");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const WebAssemblyUtils = require("./WebAssemblyUtils");
 
+/** @typedef {import("@webassemblyjs/ast").Signature} Signature */
+/** @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 +48,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
@@ -83,9 +92,11 @@ const generateImportObject = (
 				value: `${instanceVar}[${JSON.stringify(usedName)}]`
 			});
 		} else {
-			const params = description.signature.params.map(
-				(param, k) => "p" + k + param.valtype
-			);
+			const params =
+				/** @type {Signature} */
+				(description.signature).params.map(
+					(param, k) => "p" + k + param.valtype
+				);
 
 			const mod = `${RuntimeGlobals.moduleCache}[${JSON.stringify(
 				chunkGraph.getModuleId(importedModule)
@@ -122,6 +133,7 @@ const generateImportObject = (
 			"};"
 		];
 	} else {
+		/** @type {Map<string, Array<{ name: string, value: string }>>} */
 		const propertiesByModule = new Map();
 		for (const p of properties) {
 			let list = propertiesByModule.get(p.module);
@@ -188,7 +200,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,
@@ -203,22 +226,26 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunkGraph, compilation, chunk, mangleImports } = this;
-		const { moduleGraph, outputOptions } = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withHmr = this._runtimeRequirements.has(
 			RuntimeGlobals.hmrDownloadUpdateHandlers
 		);
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { moduleGraph, outputOptions } = compilation;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
+		const { mangleImports } = this;
+		/** @type {string[]} */
 		const declarations = [];
 		const importObjects = wasmModules.map(module => {
 			return generateImportObject(
 				chunkGraph,
 				module,
-				this.mangleImports,
+				mangleImports,
 				declarations,
 				chunk.runtime
 			);
@@ -226,6 +253,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,9 @@ const formatLocation = require("../formatLocation");
 const UnsupportedWebAssemblyFeatureError = require("./UnsupportedWebAssemblyFeatureError");
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 
 class WasmFinalizeExportsPlugin {
 	/**
@@ -25,7 +28,8 @@ class WasmFinalizeExportsPlugin {
 						// 1. if a WebAssembly module
 						if (module.type.startsWith("webassembly") === true) {
 							const jsIncompatibleExports =
-								module.buildMeta.jsIncompatibleExports;
+								/** @type {BuildMeta} */
+								(module.buildMeta).jsIncompatibleExports;
 
 							if (jsIncompatibleExports === undefined) {
 								continue;
@@ -37,12 +41,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 +66,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, {
@@ -173,6 +174,7 @@ const createDefaultInitForGlobal = globalType => {
  */
 const rewriteImportedGlobals = state => bin => {
 	const additionalInitCode = state.additionalInitCode;
+	/** @type {Array<t.Global>} */
 	const newGlobals = [];
 
 	bin = editWithAST(state.ast, bin, {
@@ -318,7 +320,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 +349,7 @@ const addInitFunction =
 
 		funcBody.push(t.instruction("end"));
 
+		/** @type {string[]} */
 		const funcResults = [];
 
 		// Code section
@@ -369,7 +375,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 +396,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 +437,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

@@ -6,6 +6,7 @@
 "use strict";
 
 const Generator = require("../Generator");
+const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 const { compareModulesByIdentifier } = require("../util/comparators");
@@ -13,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 */
@@ -26,7 +28,17 @@ const getWebAssemblyJavascriptGenerator = memoize(() =>
 );
 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;
 	}
@@ -38,7 +50,7 @@ class WebAssemblyModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"WebAssemblyModulesPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					WebAssemblyImportDependency,
@@ -51,16 +63,16 @@ class WebAssemblyModulesPlugin {
 				);
 
 				normalModuleFactory.hooks.createParser
-					.for("webassembly/sync")
-					.tap("WebAssemblyModulesPlugin", () => {
+					.for(WEBASSEMBLY_MODULE_TYPE_SYNC)
+					.tap(PLUGIN_NAME, () => {
 						const WebAssemblyParser = getWebAssemblyParser();
 
 						return new WebAssemblyParser();
 					});
 
 				normalModuleFactory.hooks.createGenerator
-					.for("webassembly/sync")
-					.tap("WebAssemblyModulesPlugin", () => {
+					.for(WEBASSEMBLY_MODULE_TYPE_SYNC)
+					.tap(PLUGIN_NAME, () => {
 						const WebAssemblyJavascriptGenerator =
 							getWebAssemblyJavascriptGenerator();
 						const WebAssemblyGenerator = getWebAssemblyGenerator();
@@ -71,53 +83,51 @@ class WebAssemblyModulesPlugin {
 						});
 					});
 
-				compilation.hooks.renderManifest.tap(
-					"WebAssemblyModulesPlugin",
-					(result, options) => {
-						const { chunkGraph } = compilation;
-						const { chunk, outputOptions, codeGenerationResults } = options;
-
-						for (const module of chunkGraph.getOrderedChunkModulesIterable(
-							chunk,
-							compareModulesByIdentifier
-						)) {
-							if (module.type === "webassembly/sync") {
-								const filenameTemplate =
-									outputOptions.webassemblyModuleFilename;
-
-								result.push({
-									render: () =>
-										codeGenerationResults.getSource(
-											module,
-											chunk.runtime,
-											"webassembly"
-										),
-									filenameTemplate,
-									pathOptions: {
+				compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => {
+					const { chunkGraph } = compilation;
+					const { chunk, outputOptions, codeGenerationResults } = options;
+
+					for (const module of chunkGraph.getOrderedChunkModulesIterable(
+						chunk,
+						compareModulesByIdentifier
+					)) {
+						if (module.type === WEBASSEMBLY_MODULE_TYPE_SYNC) {
+							const filenameTemplate =
+								/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
+								(outputOptions.webassemblyModuleFilename);
+
+							result.push({
+								render: () =>
+									codeGenerationResults.getSource(
 										module,
-										runtime: chunk.runtime,
-										chunkGraph
-									},
-									auxiliary: true,
-									identifier: `webassemblyModule${chunkGraph.getModuleId(
-										module
-									)}`,
-									hash: chunkGraph.getModuleHash(module, chunk.runtime)
-								});
-							}
+										chunk.runtime,
+										"webassembly"
+									),
+								filenameTemplate,
+								pathOptions: {
+									module,
+									runtime: chunk.runtime,
+									chunkGraph
+								},
+								auxiliary: true,
+								identifier: `webassemblyModule${chunkGraph.getModuleId(
+									module
+								)}`,
+								hash: chunkGraph.getModuleHash(module, chunk.runtime)
+							});
 						}
-
-						return result;
 					}
-				);
 
-				compilation.hooks.afterChunks.tap("WebAssemblyModulesPlugin", () => {
+					return result;
+				});
+
+				compilation.hooks.afterChunks.tap(PLUGIN_NAME, () => {
 					const chunkGraph = compilation.chunkGraph;
 					const initialWasmModules = new Set();
 					for (const chunk of compilation.chunks) {
 						if (chunk.canBeInitial()) {
 							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-								if (module.type === "webassembly/sync") {
+								if (module.type === WEBASSEMBLY_MODULE_TYPE_SYNC) {
 									initialWasmModules.add(module);
 								}
 							}

package/lib/wasm-sync/WebAssemblyParser.js

@@ -14,6 +14,8 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
@@ -61,6 +63,9 @@ const decoderOpts = {
 };
 
 class WebAssemblyParser extends Parser {
+	/**
+	 * @param {{}=} options parser options
+	 */
 	constructor(options) {
 		super();
 		this.hooks = Object.freeze({});
@@ -78,8 +83,10 @@ class WebAssemblyParser extends Parser {
 		}
 
 		// flag it as ESM
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "namespace";
+		/** @type {BuildInfo} */
+		(state.module.buildInfo).strict = true;
+		/** @type {BuildMeta} */
+		(state.module.buildMeta).exportsType = "namespace";
 
 		// parse it
 		const program = decode(source, decoderOpts);
@@ -88,10 +95,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 +166,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) => {

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -5,9 +5,11 @@
 
 "use strict";
 
+const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 class FetchCompileAsyncWasmPlugin {
@@ -21,6 +23,10 @@ class FetchCompileAsyncWasmPlugin {
 			"FetchCompileAsyncWasmPlugin",
 			compilation => {
 				const globalWasmLoading = compilation.outputOptions.wasmLoading;
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @returns {boolean} true, if wasm loading is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const wasmLoading =
@@ -29,6 +35,10 @@ class FetchCompileAsyncWasmPlugin {
 							: globalWasmLoading;
 					return wasmLoading === "fetch";
 				};
+				/**
+				 * @param {string} path path to the wasm file
+				 * @returns {string} code to load the wasm file
+				 */
 				const generateLoadBinaryCode = path =>
 					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
 
@@ -40,7 +50,7 @@ class FetchCompileAsyncWasmPlugin {
 						if (
 							!chunkGraph.hasModuleInGraph(
 								chunk,
-								m => m.type === "webassembly/async"
+								m => m.type === WEBASSEMBLY_MODULE_TYPE_ASYNC
 							)
 						) {
 							return;

package/lib/web/FetchCompileWasmPlugin.js

@@ -5,16 +5,28 @@
 
 "use strict";
 
+const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 // TODO webpack 6 remove
 
+const PLUGIN_NAME = "FetchCompileWasmPlugin";
+
+/**
+ * @typedef {Object} FetchCompileWasmPluginOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 class FetchCompileWasmPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * @param {FetchCompileWasmPluginOptions} [options] options
+	 */
+	constructor(options = {}) {
+		this.options = options;
 	}
 
 	/**
@@ -23,48 +35,53 @@ class FetchCompileWasmPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"FetchCompileWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === "fetch";
-				};
-				const generateLoadBinaryCode = path =>
-					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+			const globalWasmLoading = compilation.outputOptions.wasmLoading;
+			/**
+			 * @param {Chunk} chunk chunk
+			 * @returns {boolean} true, if wasm loading is enabled for the chunk
+			 */
+			const isEnabledForChunk = chunk => {
+				const options = chunk.getEntryOptions();
+				const wasmLoading =
+					options && options.wasmLoading !== undefined
+						? options.wasmLoading
+						: globalWasmLoading;
+				return wasmLoading === "fetch";
+			};
+			/**
+			 * @param {string} path path to the wasm file
+			 * @returns {string} code to load the wasm file
+			 */
+			const generateLoadBinaryCode = path =>
+				`fetch(${RuntimeGlobals.publicPath} + ${path})`;
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("FetchCompileWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === "webassembly/sync"
-							)
-						) {
-							return;
-						}
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.publicPath);
-						compilation.addRuntimeModule(
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkHandlers)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					const chunkGraph = compilation.chunkGraph;
+					if (
+						!chunkGraph.hasModuleInGraph(
 							chunk,
-							new WasmChunkLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: true,
-								mangleImports: this.options.mangleImports,
-								runtimeRequirements: set
-							})
-						);
-					});
-			}
-		);
+							m => m.type === WEBASSEMBLY_MODULE_TYPE_SYNC
+						)
+					) {
+						return;
+					}
+					set.add(RuntimeGlobals.moduleCache);
+					set.add(RuntimeGlobals.publicPath);
+					compilation.addRuntimeModule(
+						chunk,
+						new WasmChunkLoadingRuntimeModule({
+							generateLoadBinaryCode,
+							supportsStreaming: true,
+							mangleImports: this.options.mangleImports,
+							runtimeRequirements: set
+						})
+					);
+				});
+		});
 	}
 }
 

package/lib/web/JsonpChunkLoadingPlugin.js

@@ -8,6 +8,7 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const JsonpChunkLoadingRuntimeModule = require("./JsonpChunkLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 class JsonpChunkLoadingPlugin {
@@ -21,6 +22,10 @@ class JsonpChunkLoadingPlugin {
 			"JsonpChunkLoadingPlugin",
 			compilation => {
 				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @returns {boolean} true, if wasm loading is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =
@@ -30,6 +35,10 @@ class JsonpChunkLoadingPlugin {
 					return chunkLoading === "jsonp";
 				};
 				const onceForChunkSet = new WeakSet();
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @param {Set<string>} set runtime requirements
+				 */
 				const handler = (chunk, set) => {
 					if (onceForChunkSet.has(chunk)) return;
 					onceForChunkSet.add(chunk);