webpack 5.59.0 → 5.94.0

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -25,46 +25,50 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
+/** @typedef {import("@webassemblyjs/ast").Instruction} Instruction */
+/** @typedef {import("@webassemblyjs/ast").ModuleImport} ModuleImport */
+/** @typedef {import("@webassemblyjs/ast").ModuleExport} ModuleExport */
+/** @typedef {import("@webassemblyjs/ast").Global} Global */
+/**
+ * @template T
+ * @typedef {import("@webassemblyjs/ast").NodePath<T>} NodePath
+ */
 
 /**
- * @typedef {(ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
+ * @typedef {(buf: ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
  */
 
 /**
  * @template T
- * @param {Function[]} fns transforms
+ * @param {((prev: ArrayBuffer) => ArrayBuffer)[]} fns transforms
  * @returns {Function} composed transform
  */
-const compose = (...fns) => {
-	return fns.reduce(
-		(prevFn, nextFn) => {
-			return value => nextFn(prevFn(value));
-		},
+const compose = (...fns) =>
+	fns.reduce(
+		(prevFn, nextFn) => value => nextFn(prevFn(value)),
 		value => value
 	);
-};
 
 /**
  * Removes the start instruction
- *
- * @param {Object} state unused state
+ * @param {object} state state
+ * @param {object} state.ast Module's ast
  * @returns {ArrayBufferTransform} transform
  */
-const removeStartFunc = state => bin => {
-	return editWithAST(state.ast, bin, {
+const removeStartFunc = state => bin =>
+	editWithAST(state.ast, bin, {
 		Start(path) {
 			path.remove();
 		}
 	});
-};
 
 /**
  * Get imported globals
- *
- * @param {Object} ast Module's AST
- * @returns {Array<t.ModuleImport>} - nodes
+ * @param {object} ast Module's AST
+ * @returns {t.ModuleImport[]} - nodes
  */
 const getImportedGlobals = ast => {
+	/** @type {t.ModuleImport[]} */
 	const importedGlobals = [];
 
 	t.traverse(ast, {
@@ -80,9 +84,8 @@ const getImportedGlobals = ast => {
 
 /**
  * Get the count for imported func
- *
- * @param {Object} ast Module's AST
- * @returns {Number} - count
+ * @param {object} ast Module's AST
+ * @returns {number} - count
  */
 const getCountImportedFunc = ast => {
 	let count = 0;
@@ -100,8 +103,7 @@ const getCountImportedFunc = ast => {
 
 /**
  * Get next type index
- *
- * @param {Object} ast Module's AST
+ * @param {object} ast Module's AST
  * @returns {t.Index} - index
  */
 const getNextTypeIndex = ast => {
@@ -116,13 +118,11 @@ const getNextTypeIndex = ast => {
 
 /**
  * Get next func index
- *
- * The Func section metadata provide informations for implemented funcs
+ * The Func section metadata provide information for implemented funcs
  * in order to have the correct index we shift the index by number of external
  * functions.
- *
- * @param {Object} ast Module's AST
- * @param {Number} countImportedFunc number of imported funcs
+ * @param {object} ast Module's AST
+ * @param {number} countImportedFunc number of imported funcs
  * @returns {t.Index} - index
  */
 const getNextFuncIndex = (ast, countImportedFunc) => {
@@ -153,9 +153,8 @@ const createDefaultInitForGlobal = globalType => {
 		return t.objectInstruction("const", globalType.valtype, [
 			t.floatLiteral(66, false, false, "66")
 		]);
-	} else {
-		throw new Error("unknown type: " + globalType.valtype);
 	}
+	throw new Error(`unknown type: ${globalType.valtype}`);
 };
 
 /**
@@ -167,18 +166,20 @@ const createDefaultInitForGlobal = globalType => {
  * indices will be preserved.
  *
  * Note that globals will become mutable.
- *
- * @param {Object} state unused state
+ * @param {object} state transformation state
+ * @param {object} state.ast Module's ast
+ * @param {t.Instruction[]} state.additionalInitCode list of addition instructions for the init function
  * @returns {ArrayBufferTransform} transform
  */
 const rewriteImportedGlobals = state => bin => {
 	const additionalInitCode = state.additionalInitCode;
+	/** @type {Array<t.Global>} */
 	const newGlobals = [];
 
 	bin = editWithAST(state.ast, bin, {
 		ModuleImport(path) {
 			if (t.isGlobalType(path.node.descr)) {
-				const globalType = path.node.descr;
+				const globalType = /** @type {TODO} */ (path.node.descr);
 
 				globalType.mutability = "var";
 
@@ -195,6 +196,9 @@ const rewriteImportedGlobals = state => bin => {
 
 		// in order to preserve non-imported global's order we need to re-inject
 		// those as well
+		/**
+		 * @param {NodePath<Global>} path path
+		 */
 		Global(path) {
 			const { node } = path;
 			const [init] = node.init;
@@ -232,8 +236,8 @@ const rewriteImportedGlobals = state => bin => {
 
 /**
  * Rewrite the export names
- * @param {Object} state state
- * @param {Object} state.ast Module's ast
+ * @param {object} state state
+ * @param {object} state.ast Module's ast
  * @param {Module} state.module Module
  * @param {ModuleGraph} state.moduleGraph module graph
  * @param {Set<string>} state.externalExports Module
@@ -242,8 +246,11 @@ const rewriteImportedGlobals = state => bin => {
  */
 const rewriteExportNames =
 	({ ast, moduleGraph, module, externalExports, runtime }) =>
-	bin => {
-		return editWithAST(ast, bin, {
+	bin =>
+		editWithAST(ast, bin, {
+			/**
+			 * @param {NodePath<ModuleExport>} path path
+			 */
 			ModuleExport(path) {
 				const isExternal = externalExports.has(path.node.name);
 				if (isExternal) {
@@ -257,25 +264,27 @@ const rewriteExportNames =
 					path.remove();
 					return;
 				}
-				path.node.name = usedName;
+				path.node.name = /** @type {string} */ (usedName);
 			}
 		});
-	};
 
 /**
  * Mangle import names and modules
- * @param {Object} state state
- * @param {Object} state.ast Module's ast
+ * @param {object} state state
+ * @param {object} state.ast Module's ast
  * @param {Map<string, UsedWasmDependency>} state.usedDependencyMap mappings to mangle names
  * @returns {ArrayBufferTransform} transform
  */
 const rewriteImports =
 	({ ast, usedDependencyMap }) =>
-	bin => {
-		return editWithAST(ast, bin, {
+	bin =>
+		editWithAST(ast, bin, {
+			/**
+			 * @param {NodePath<ModuleImport>} path path
+			 */
 			ModuleImport(path) {
 				const result = usedDependencyMap.get(
-					path.node.module + ":" + path.node.name
+					`${path.node.module}:${path.node.name}`
 				);
 
 				if (result !== undefined) {
@@ -284,15 +293,13 @@ const rewriteImports =
 				}
 			}
 		});
-	};
 
 /**
  * Add an init function.
  *
  * The init function fills the globals given input arguments.
- *
- * @param {Object} state transformation state
- * @param {Object} state.ast Module's ast
+ * @param {object} state transformation state
+ * @param {object} state.ast Module's ast
  * @param {t.Identifier} state.initFuncId identifier of the init function
  * @param {t.Index} state.startAtFuncOffset index of the start function
  * @param {t.ModuleImport[]} state.importedGlobals list of imported globals
@@ -318,11 +325,15 @@ const addInitFunction =
 				`${importedGlobal.module}.${importedGlobal.name}`
 			);
 
-			return t.funcParam(importedGlobal.descr.valtype, id);
+			return t.funcParam(
+				/** @type {string} */ (importedGlobal.descr.valtype),
+				id
+			);
 		});
 
+		/** @type {Instruction[]} */
 		const funcBody = [];
-		importedGlobals.forEach((importedGlobal, index) => {
+		for (const [index, _importedGlobal] of importedGlobals.entries()) {
 			const args = [t.indexLiteral(index)];
 			const body = [
 				t.instruction("get_local", args),
@@ -330,7 +341,7 @@ const addInitFunction =
 			];
 
 			funcBody.push(...body);
-		});
+		}
 
 		if (typeof startAtFuncOffset === "number") {
 			funcBody.push(
@@ -344,6 +355,7 @@ const addInitFunction =
 
 		funcBody.push(t.instruction("end"));
 
+		/** @type {string[]} */
 		const funcResults = [];
 
 		// Code section
@@ -369,7 +381,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) => {
@@ -383,14 +395,22 @@ const getUsedDependencyMap = (moduleGraph, module, mangle) => {
 		const dep = usedDep.dependency;
 		const request = dep.request;
 		const exportName = dep.name;
-		map.set(request + ":" + exportName, usedDep);
+		map.set(`${request}:${exportName}`, usedDep);
 	}
 	return map;
 };
 
 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 +443,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

@@ -19,6 +19,7 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
@@ -55,7 +56,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 			runtimeRequirements,
 			runtime
 		} = generateContext;
-		/** @type {InitFragment[]} */
+		/** @type {InitFragment<InitFragment<string>>[]} */
 		const initFragments = [];
 
 		const exportsInfo = moduleGraph.getExportsInfo(module);
@@ -127,7 +128,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 						const defineStatement = Template.asString([
 							`${exportProp} = ${runtimeTemplate.exportFromImport({
 								moduleGraph,
-								module: moduleGraph.getModule(dep),
+								module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 								request: dep.request,
 								importVar: importData.importVar,
 								originModule: module,
@@ -200,8 +201,8 @@ class WebAssemblyJavascriptGenerator extends Generator {
 				copyAllExports
 					? `${module.moduleArgument}.exports = wasmExports;`
 					: "for(var name in wasmExports) " +
-					  `if(name) ` +
-					  `${module.exportsArgument}[name] = wasmExports[name];`,
+						"if(name) " +
+						`${module.exportsArgument}[name] = wasmExports[name];`,
 				"// exec imports from WebAssembly module (for esm order)",
 				importsCode,
 				"",

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,10 +14,12 @@ 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 */
 
-const JS_COMPAT_TYPES = new Set(["i32", "f32", "f64"]);
+const JS_COMPAT_TYPES = new Set(["i32", "i64", "f32", "f64"]);
 
 /**
  * @param {t.Signature} signature the func signature
@@ -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,13 @@ class WebAssemblyParser extends Parser {
 		const moduleContext = moduleContextFromModuleAST(module);
 
 		// extract imports and exports
+		/** @type {string[]} */
 		const exports = [];
-		let jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports =
-			undefined);
+		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		/** @type {Record<string, string> | undefined} */
+		let jsIncompatibleExports = (buildMeta.jsIncompatibleExports = undefined);
 
+		/** @type {TODO[]} */
 		const importedGlobals = [];
 		t.traverse(module, {
 			ModuleExport({ node }) {
@@ -109,7 +119,8 @@ class WebAssemblyParser extends Parser {
 					if (incompatibleType) {
 						if (jsIncompatibleExports === undefined) {
 							jsIncompatibleExports =
-								state.module.buildMeta.jsIncompatibleExports = {};
+								/** @type {BuildMeta} */
+								(state.module.buildMeta).jsIncompatibleExports = {};
 						}
 						jsIncompatibleExports[node.name] = incompatibleType;
 					}
@@ -118,7 +129,8 @@ class WebAssemblyParser extends Parser {
 				exports.push(node.name);
 
 				if (node.descr && node.descr.exportType === "Global") {
-					const refNode = importedGlobals[node.descr.id.value];
+					const refNode =
+						importedGlobals[/** @type {TODO} */ (node.descr.id.value)];
 					if (refNode) {
 						const dep = new WebAssemblyExportImportedDependency(
 							node.name,
@@ -157,12 +169,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

@@ -11,7 +11,8 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 
-/** @typedef {Object} UsedWasmDependency
+/**
+ * @typedef {object} UsedWasmDependency
  * @property {WebAssemblyImportDependency} dependency the dependency
  * @property {string} name the export name
  * @property {string} module the module name
@@ -22,7 +23,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) => {
@@ -61,5 +62,5 @@ const getUsedDependencies = (moduleGraph, module, mangle) => {
 	return array;
 };
 
-exports.getUsedDependencies = getUsedDependencies;
-exports.MANGLED_MODULE = MANGLED_MODULE;
+module.exports.getUsedDependencies = getUsedDependencies;
+module.exports.MANGLED_MODULE = MANGLED_MODULE;

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;