webpack 5.97.1 → 5.104.1

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -7,29 +7,29 @@
 
 const t = require("@webassemblyjs/ast");
 const { moduleContextFromModuleAST } = require("@webassemblyjs/ast");
-const { editWithAST, addWithAST } = require("@webassemblyjs/wasm-edit");
+const { addWithAST, editWithAST } = 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 { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
+const WebAssemblyUtils = require("./WebAssemblyUtils");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
 /** @typedef {import("@webassemblyjs/ast").Instruction} Instruction */
 /** @typedef {import("@webassemblyjs/ast").ModuleImport} ModuleImport */
 /** @typedef {import("@webassemblyjs/ast").ModuleExport} ModuleExport */
 /** @typedef {import("@webassemblyjs/ast").Global} Global */
+/** @typedef {import("@webassemblyjs/ast").AST} AST */
+/** @typedef {import("@webassemblyjs/ast").GlobalType} GlobalType */
 /**
  * @template T
  * @typedef {import("@webassemblyjs/ast").NodePath<T>} NodePath
@@ -42,21 +42,21 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 /**
  * @template T
  * @param {((prev: ArrayBuffer) => ArrayBuffer)[]} fns transforms
- * @returns {Function} composed transform
+ * @returns {(buf: ArrayBuffer) => ArrayBuffer} composed transform
  */
 const compose = (...fns) =>
 	fns.reduce(
-		(prevFn, nextFn) => value => nextFn(prevFn(value)),
-		value => value
+		(prevFn, nextFn) => (value) => nextFn(prevFn(value)),
+		(value) => value
 	);
 
 /**
  * Removes the start instruction
  * @param {object} state state
- * @param {object} state.ast Module's ast
+ * @param {AST} state.ast Module's ast
  * @returns {ArrayBufferTransform} transform
  */
-const removeStartFunc = state => bin =>
+const removeStartFunc = (state) => (bin) =>
 	editWithAST(state.ast, bin, {
 		Start(path) {
 			path.remove();
@@ -65,10 +65,10 @@ const removeStartFunc = state => bin =>
 
 /**
  * Get imported globals
- * @param {object} ast Module's AST
+ * @param {AST} ast Module's AST
  * @returns {t.ModuleImport[]} - nodes
  */
-const getImportedGlobals = ast => {
+const getImportedGlobals = (ast) => {
 	/** @type {t.ModuleImport[]} */
 	const importedGlobals = [];
 
@@ -85,10 +85,10 @@ const getImportedGlobals = ast => {
 
 /**
  * Get the count for imported func
- * @param {object} ast Module's AST
+ * @param {AST} ast Module's AST
  * @returns {number} - count
  */
-const getCountImportedFunc = ast => {
+const getCountImportedFunc = (ast) => {
 	let count = 0;
 
 	t.traverse(ast, {
@@ -104,10 +104,10 @@ const getCountImportedFunc = ast => {
 
 /**
  * Get next type index
- * @param {object} ast Module's AST
+ * @param {AST} ast Module's AST
  * @returns {t.Index} - index
  */
-const getNextTypeIndex = ast => {
+const getNextTypeIndex = (ast) => {
 	const typeSectionMetadata = t.getSectionMetadata(ast, "type");
 
 	if (typeSectionMetadata === undefined) {
@@ -122,7 +122,7 @@ const getNextTypeIndex = ast => {
  * 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 {AST} ast Module's AST
  * @param {number} countImportedFunc number of imported funcs
  * @returns {t.Index} - index
  */
@@ -143,7 +143,7 @@ const getNextFuncIndex = (ast, countImportedFunc) => {
  * @param {t.GlobalType} globalType the global type
  * @returns {t.Instruction} init expression
  */
-const createDefaultInitForGlobal = globalType => {
+const createDefaultInitForGlobal = (globalType) => {
 	if (globalType.valtype[0] === "i") {
 		// create NumberLiteral global initializer
 		return t.objectInstruction("const", globalType.valtype, [
@@ -168,19 +168,21 @@ const createDefaultInitForGlobal = globalType => {
  *
  * Note that globals will become mutable.
  * @param {object} state transformation state
- * @param {object} state.ast Module's ast
+ * @param {AST} 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 rewriteImportedGlobals = (state) => (bin) => {
 	const additionalInitCode = state.additionalInitCode;
-	/** @type {Array<t.Global>} */
+	/** @type {t.Global[]} */
 	const newGlobals = [];
 
 	bin = editWithAST(state.ast, bin, {
 		ModuleImport(path) {
 			if (t.isGlobalType(path.node.descr)) {
-				const globalType = /** @type {TODO} */ (path.node.descr);
+				const globalType =
+					/** @type {GlobalType} */
+					(path.node.descr);
 
 				globalType.mutability = "var";
 
@@ -238,7 +240,7 @@ const rewriteImportedGlobals = state => bin => {
 /**
  * Rewrite the export names
  * @param {object} state state
- * @param {object} state.ast Module's ast
+ * @param {AST} state.ast Module's ast
  * @param {Module} state.module Module
  * @param {ModuleGraph} state.moduleGraph module graph
  * @param {Set<string>} state.externalExports Module
@@ -247,7 +249,7 @@ const rewriteImportedGlobals = state => bin => {
  */
 const rewriteExportNames =
 	({ ast, moduleGraph, module, externalExports, runtime }) =>
-	bin =>
+	(bin) =>
 		editWithAST(ast, bin, {
 			/**
 			 * @param {NodePath<ModuleExport>} path path
@@ -269,16 +271,18 @@ const rewriteExportNames =
 			}
 		});
 
+/** @typedef {Map<string, UsedWasmDependency>} Mapping */
+
 /**
  * Mangle import names and modules
  * @param {object} state state
- * @param {object} state.ast Module's ast
- * @param {Map<string, UsedWasmDependency>} state.usedDependencyMap mappings to mangle names
+ * @param {AST} state.ast Module's ast
+ * @param {Mapping} state.usedDependencyMap mappings to mangle names
  * @returns {ArrayBufferTransform} transform
  */
 const rewriteImports =
 	({ ast, usedDependencyMap }) =>
-	bin =>
+	(bin) =>
 		editWithAST(ast, bin, {
 			/**
 			 * @param {NodePath<ModuleImport>} path path
@@ -300,7 +304,7 @@ const rewriteImports =
  *
  * The init function fills the globals given input arguments.
  * @param {object} state transformation state
- * @param {object} state.ast Module's ast
+ * @param {AST} 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
@@ -319,8 +323,8 @@ const addInitFunction =
 		nextFuncIndex,
 		nextTypeIndex
 	}) =>
-	bin => {
-		const funcParams = importedGlobals.map(importedGlobal => {
+	(bin) => {
+		const funcParams = importedGlobals.map((importedGlobal) => {
 			// used for debugging
 			const id = t.identifier(
 				`${importedGlobal.module}.${importedGlobal.name}`
@@ -382,11 +386,11 @@ const addInitFunction =
  * Extract mangle mappings from module
  * @param {ModuleGraph} moduleGraph module graph
  * @param {Module} module current module
- * @param {boolean | undefined} mangle mangle imports
- * @returns {Map<string, UsedWasmDependency>} mappings to mangled names
+ * @param {boolean=} mangle mangle imports
+ * @returns {Mapping} mappings to mangled names
  */
 const getUsedDependencyMap = (moduleGraph, module, mangle) => {
-	/** @type {Map<string, UsedWasmDependency>} */
+	/** @type {Mapping} */
 	const map = new Map();
 	for (const usedDep of WebAssemblyUtils.getUsedDependencies(
 		moduleGraph,
@@ -403,7 +407,7 @@ const getUsedDependencyMap = (moduleGraph, module, mangle) => {
 
 /**
  * @typedef {object} WebAssemblyGeneratorOptions
- * @property {boolean} [mangleImports] mangle imports
+ * @property {boolean=} mangleImports mangle imports
  */
 
 class WebAssemblyGenerator extends Generator {
@@ -425,7 +429,7 @@ class WebAssemblyGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
+	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
@@ -442,7 +446,9 @@ class WebAssemblyGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generate(module, { moduleGraph, runtime }) {
-		const bin = /** @type {Source} */ (module.originalSource()).source();
+		const bin =
+			/** @type {Buffer} */
+			(/** @type {Source} */ (module.originalSource()).source());
 
 		const initFuncId = t.identifier("");
 
@@ -468,8 +474,8 @@ class WebAssemblyGenerator extends Generator {
 		);
 		const externalExports = new Set(
 			module.dependencies
-				.filter(d => d instanceof WebAssemblyExportImportedDependency)
-				.map(d => {
+				.filter((d) => d instanceof WebAssemblyExportImportedDependency)
+				.map((d) => {
 					const wasmDep = /** @type {WebAssemblyExportImportedDependency} */ (
 						d
 					);
@@ -509,12 +515,21 @@ class WebAssemblyGenerator extends Generator {
 			})
 		);
 
-		const newBin = transform(bin);
-
+		const newBin = transform(/** @type {ArrayBuffer} */ (bin.buffer));
 		const newBuf = Buffer.from(newBin);
 
 		return new RawSource(newBuf);
 	}
+
+	/**
+	 * @param {Error} error the error
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generateError(error, module, generateContext) {
+		return new RawSource(error.message);
+	}
 }
 
 module.exports = WebAssemblyGenerator;

package/lib/wasm-sync/WebAssemblyInInitialChunkError.js

@@ -42,8 +42,11 @@ const getInitialModuleChains = (
 		for (const connection of moduleGraph.getIncomingConnections(head)) {
 			const newHead = connection.originModule;
 			if (newHead) {
-				if (!chunkGraph.getModuleChunks(newHead).some(c => c.canBeInitial()))
+				if (
+					!chunkGraph.getModuleChunks(newHead).some((c) => c.canBeInitial())
+				) {
 					continue;
+				}
 				final = false;
 				if (alreadyReferencedModules.has(newHead)) continue;
 				alreadyReferencedModules.add(newHead);
@@ -76,7 +79,7 @@ const getInitialModuleChains = (
 	for (const result of incompleteResults) {
 		results.add(result);
 	}
-	return Array.from(results);
+	return [...results];
 };
 
 module.exports = class WebAssemblyInInitialChunkError extends WebpackError {
@@ -96,7 +99,7 @@ module.exports = class WebAssemblyInInitialChunkError extends WebpackError {
 		const message = `WebAssembly module is included in initial chunk.
 This is not allowed, because WebAssembly download and compilation must happen asynchronous.
 Add an async split point (i. e. import()) somewhere between your entrypoint and the WebAssembly module:
-${moduleChains.map(s => `* ${s}`).join("\n")}`;
+${moduleChains.map((s) => `* ${s}`).join("\n")}`;
 
 		super(message);
 		this.name = "WebAssemblyInInitialChunkError";

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -9,7 +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 { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const ModuleDependency = require("../dependencies/ModuleDependency");
@@ -17,13 +17,11 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class WebAssemblyJavascriptGenerator extends Generator {
 	/**
@@ -36,7 +34,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
+	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
@@ -56,7 +54,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 			runtimeRequirements,
 			runtime
 		} = generateContext;
-		/** @type {InitFragment<InitFragment<string>>[]} */
+		/** @type {InitFragment<GenerateContext>[]} */
 		const initFragments = [];
 
 		const exportsInfo = moduleGraph.getExportsInfo(module);
@@ -74,6 +72,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 					importedModules.set(
 						moduleGraph.getModule(dep),
 						(importData = {
+							dependency: moduleDep,
 							importVar: `m${index}`,
 							index,
 							request: (moduleDep && moduleDep.userRequest) || undefined,
@@ -97,6 +96,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 								initParams.push(
 									runtimeTemplate.exportFromImport({
 										moduleGraph,
+										chunkGraph,
 										module: importedModule,
 										request: dep.request,
 										importVar: importData.importVar,
@@ -108,7 +108,8 @@ class WebAssemblyJavascriptGenerator extends Generator {
 										defaultInterop: true,
 										initFragments,
 										runtime,
-										runtimeRequirements
+										runtimeRequirements,
+										dependency: dep
 									})
 								);
 							}
@@ -129,6 +130,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 							`${exportProp} = ${runtimeTemplate.exportFromImport({
 								moduleGraph,
 								module: /** @type {Module} */ (moduleGraph.getModule(dep)),
+								chunkGraph,
 								request: dep.request,
 								importVar: importData.importVar,
 								originModule: module,
@@ -139,7 +141,8 @@ class WebAssemblyJavascriptGenerator extends Generator {
 								defaultInterop: true,
 								initFragments,
 								runtime,
-								runtimeRequirements
+								runtimeRequirements,
+								dependency: dep
 							})};`,
 							`if(WebAssembly.Global) ${exportProp} = ` +
 								`new WebAssembly.Global({ value: ${JSON.stringify(
@@ -155,14 +158,16 @@ class WebAssemblyJavascriptGenerator extends Generator {
 		const importsCode = Template.asString(
 			Array.from(
 				importedModules,
-				([module, { importVar, request, reexports }]) => {
+				([module, { importVar, request, reexports, dependency }]) => {
 					const importStatement = runtimeTemplate.importStatement({
 						module,
+						moduleGraph,
 						chunkGraph,
 						request,
 						importVar,
 						originModule: module,
-						runtimeRequirements
+						runtimeRequirements,
+						dependency
 					});
 					return importStatement[0] + importStatement[1] + reexports.join("\n");
 				}
@@ -212,6 +217,16 @@ class WebAssemblyJavascriptGenerator extends Generator {
 		);
 		return InitFragment.addToSource(source, initFragments, generateContext);
 	}
+
+	/**
+	 * @param {Error} error the error
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generateError(error, module, generateContext) {
+		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+	}
 }
 
 module.exports = WebAssemblyJavascriptGenerator;

package/lib/wasm-sync/WebAssemblyModulesPlugin.js

@@ -6,19 +6,19 @@
 "use strict";
 
 const Generator = require("../Generator");
+const {
+	JAVASCRIPT_TYPE,
+	WEBASSEMBLY_TYPE
+} = require("../ModuleSourceTypeConstants");
 const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
-const { compareModulesByIdentifier } = require("../util/comparators");
+const { compareModulesByIdOrIdentifier } = require("../util/comparators");
 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 */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 
 const getWebAssemblyGenerator = memoize(() =>
 	require("./WebAssemblyGenerator")
@@ -32,7 +32,7 @@ const PLUGIN_NAME = "WebAssemblyModulesPlugin";
 
 /**
  * @typedef {object} WebAssemblyModulesPluginOptions
- * @property {boolean} [mangleImports] mangle imports
+ * @property {boolean=} mangleImports mangle imports
  */
 
 class WebAssemblyModulesPlugin {
@@ -78,8 +78,8 @@ class WebAssemblyModulesPlugin {
 						const WebAssemblyGenerator = getWebAssemblyGenerator();
 
 						return Generator.byType({
-							javascript: new WebAssemblyJavascriptGenerator(),
-							webassembly: new WebAssemblyGenerator(this.options)
+							[JAVASCRIPT_TYPE]: new WebAssemblyJavascriptGenerator(),
+							[WEBASSEMBLY_TYPE]: new WebAssemblyGenerator(this.options)
 						});
 					});
 
@@ -89,12 +89,10 @@ class WebAssemblyModulesPlugin {
 
 					for (const module of chunkGraph.getOrderedChunkModulesIterable(
 						chunk,
-						compareModulesByIdentifier
+						compareModulesByIdOrIdentifier(chunkGraph)
 					)) {
 						if (module.type === WEBASSEMBLY_MODULE_TYPE_SYNC) {
-							const filenameTemplate =
-								/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
-								(outputOptions.webassemblyModuleFilename);
+							const filenameTemplate = outputOptions.webassemblyModuleFilename;
 
 							result.push({
 								render: () =>
@@ -123,6 +121,7 @@ class WebAssemblyModulesPlugin {
 
 				compilation.hooks.afterChunks.tap(PLUGIN_NAME, () => {
 					const chunkGraph = compilation.chunkGraph;
+					/** @type {Set<Module>} */
 					const initialWasmModules = new Set();
 					for (const chunk of compilation.chunks) {
 						if (chunk.canBeInitial()) {

package/lib/wasm-sync/WebAssemblyParser.js

@@ -13,7 +13,7 @@ const StaticExportsDependency = require("../dependencies/StaticExportsDependency
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
-/** @typedef {import("../Module")} Module */
+/** @typedef {import("@webassemblyjs/ast").ModuleImport} ModuleImport */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
@@ -25,7 +25,7 @@ const JS_COMPAT_TYPES = new Set(["i32", "i64", "f32", "f64", "externref"]);
  * @param {t.Signature} signature the func signature
  * @returns {null | string} the type incompatible with js types
  */
-const getJsIncompatibleType = signature => {
+const getJsIncompatibleType = (signature) => {
 	for (const param of signature.params) {
 		if (!JS_COMPAT_TYPES.has(param.valtype)) {
 			return `${param.valtype} as parameter`;
@@ -42,7 +42,7 @@ const getJsIncompatibleType = signature => {
  * @param {t.FuncSignature} signature the func signature
  * @returns {null | string} the type incompatible with js types
  */
-const getJsIncompatibleTypeOfFuncSignature = signature => {
+const getJsIncompatibleTypeOfFuncSignature = (signature) => {
 	for (const param of signature.args) {
 		if (!JS_COMPAT_TYPES.has(param)) {
 			return `${param} as parameter`;
@@ -63,15 +63,6 @@ const decoderOpts = {
 };
 
 class WebAssemblyParser extends Parser {
-	/**
-	 * @param {{}=} options parser options
-	 */
-	constructor(options) {
-		super();
-		this.hooks = Object.freeze({});
-		this.options = options;
-	}
-
 	/**
 	 * @param {string | Buffer | PreparsedAst} source the source to parse
 	 * @param {ParserState} state the parser state
@@ -101,8 +92,9 @@ class WebAssemblyParser extends Parser {
 		/** @type {Record<string, string> | undefined} */
 		let jsIncompatibleExports = (buildMeta.jsIncompatibleExports = undefined);
 
-		/** @type {TODO[]} */
+		/** @type {(ModuleImport | null)[]} */
 		const importedGlobals = [];
+
 		t.traverse(module, {
 			ModuleExport({ node }) {
 				const descriptor = node.descr;
@@ -129,14 +121,14 @@ class WebAssemblyParser extends Parser {
 				exports.push(node.name);
 
 				if (node.descr && node.descr.exportType === "Global") {
-					const refNode =
-						importedGlobals[/** @type {TODO} */ (node.descr.id.value)];
+					const refNode = importedGlobals[node.descr.id.value];
 					if (refNode) {
 						const dep = new WebAssemblyExportImportedDependency(
 							node.name,
 							refNode.module,
 							refNode.name,
-							refNode.descr.valtype
+							/** @type {string} */
+							(refNode.descr.valtype)
 						);
 
 						state.module.addDependency(dep);
@@ -170,7 +162,8 @@ class WebAssemblyParser extends Parser {
 					onlyDirectImport = "Table";
 				} else if (t.isFuncImportDescr(node.descr) === true) {
 					const incompatibleType = getJsIncompatibleType(
-						/** @type {t.Signature} */ (node.descr.signature)
+						/** @type {t.Signature} */
+						(node.descr.signature)
 					);
 					if (incompatibleType) {
 						onlyDirectImport = `Non-JS-compatible Func Signature (${incompatibleType})`;

package/lib/wasm-sync/WebAssemblyUtils.js

@@ -62,5 +62,5 @@ const getUsedDependencies = (moduleGraph, module, mangle) => {
 	return array;
 };
 
-module.exports.getUsedDependencies = getUsedDependencies;
 module.exports.MANGLED_MODULE = MANGLED_MODULE;
+module.exports.getUsedDependencies = getUsedDependencies;

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -21,13 +21,13 @@ class FetchCompileAsyncWasmPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+		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 isEnabledForChunk = (chunk) => {
 				const options = chunk.getEntryOptions();
 				const wasmLoading =
 					options && options.wasmLoading !== undefined
@@ -39,7 +39,7 @@ class FetchCompileAsyncWasmPlugin {
 			 * @param {string} path path to the wasm file
 			 * @returns {string} code to load the wasm file
 			 */
-			const generateLoadBinaryCode = path =>
+			const generateLoadBinaryCode = (path) =>
 				`fetch(${RuntimeGlobals.publicPath} + ${path})`;
 
 			compilation.hooks.runtimeRequirementInTree
@@ -49,7 +49,7 @@ class FetchCompileAsyncWasmPlugin {
 					if (
 						!chunkGraph.hasModuleInGraph(
 							chunk,
-							m => m.type === WEBASSEMBLY_MODULE_TYPE_ASYNC
+							(m) => m.type === WEBASSEMBLY_MODULE_TYPE_ASYNC
 						)
 					) {
 						return;

package/lib/web/FetchCompileWasmPlugin.js

@@ -14,16 +14,14 @@ const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRunt
 
 /**
  * @typedef {object} FetchCompileWasmPluginOptions
- * @property {boolean} [mangleImports] mangle imports
+ * @property {boolean=} mangleImports mangle imports
  */
 
-// TODO webpack 6 remove
-
 const PLUGIN_NAME = "FetchCompileWasmPlugin";
 
 class FetchCompileWasmPlugin {
 	/**
-	 * @param {FetchCompileWasmPluginOptions} [options] options
+	 * @param {FetchCompileWasmPluginOptions=} options options
 	 */
 	constructor(options = {}) {
 		this.options = options;
@@ -35,13 +33,13 @@ class FetchCompileWasmPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+		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 isEnabledForChunk = (chunk) => {
 				const options = chunk.getEntryOptions();
 				const wasmLoading =
 					options && options.wasmLoading !== undefined
@@ -53,7 +51,7 @@ class FetchCompileWasmPlugin {
 			 * @param {string} path path to the wasm file
 			 * @returns {string} code to load the wasm file
 			 */
-			const generateLoadBinaryCode = path =>
+			const generateLoadBinaryCode = (path) =>
 				`fetch(${RuntimeGlobals.publicPath} + ${path})`;
 
 			compilation.hooks.runtimeRequirementInTree
@@ -63,7 +61,7 @@ class FetchCompileWasmPlugin {
 					if (
 						!chunkGraph.hasModuleInGraph(
 							chunk,
-							m => m.type === WEBASSEMBLY_MODULE_TYPE_SYNC
+							(m) => m.type === WEBASSEMBLY_MODULE_TYPE_SYNC
 						)
 					) {
 						return;