@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -6,15 +6,14 @@
 "use strict";
 
 const { SyncWaterfallHook } = require("tapable");
-const Compilation = require("../Compilation");
 const Generator = require("../Generator");
-const { tryRunOrWebpackError } = require("../HookWebpackError");
 const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
-const NormalModule = require("../NormalModule");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
+const { tryRunOrWebpackError } = require("../errors/HookWebpackError");
 const { compareModulesByFullName } = require("../util/comparators");
-const makeSerializable = require("../util/makeSerializable");
+const createHooksRegistry = require("../util/createHooksRegistry");
 const memoize = require("../util/memoize");
+const AsyncWasmModule = require("./AsyncWasmModule");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Chunk")} Chunk */
@@ -23,13 +22,9 @@ const memoize = require("../util/memoize");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Module")} Module */
-/** @typedef {import("../dependencies/ImportPhase").ImportPhaseName} ImportPhaseName */
-/** @typedef {import("../NormalModule").NormalModuleCreateData} NormalModuleCreateData */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 
 const getAsyncWebAssemblyGenerator = memoize(() =>
 	require("./AsyncWebAssemblyGenerator")
@@ -41,94 +36,8 @@ const getAsyncWebAssemblyParser = memoize(() =>
 	require("./AsyncWebAssemblyParser")
 );
 
-/** @typedef {NormalModule & { phase: ImportPhaseName | undefined }} AsyncWasmModuleClass */
-
-class AsyncWasmModule extends NormalModule {
-	/**
-	 * @param {NormalModuleCreateData & { phase: ImportPhaseName | undefined }} options options object
-	 */
-	constructor(options) {
-		super(options);
-		this.phase = options.phase;
-	}
-
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		let str = super.identifier();
-
-		if (this.phase) {
-			str = `${str}|${this.phase}`;
-		}
-
-		return str;
-	}
-
-	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
-	 */
-	updateCacheModule(module) {
-		super.updateCacheModule(module);
-		const m = /** @type {AsyncWasmModule} */ (module);
-		this.phase = m.phase;
-	}
-
-	/**
-	 * @param {ObjectSerializerContext} context context
-	 */
-	serialize(context) {
-		const { write } = context;
-		write(this.phase);
-		super.serialize(context);
-	}
-
-	/**
-	 * @param {ObjectDeserializerContext} context context
-	 * @returns {AsyncWasmModule} the deserialized object
-	 */
-	static deserialize(context) {
-		const obj = new AsyncWasmModule({
-			// will be deserialized by Module
-			layer: /** @type {EXPECTED_ANY} */ (null),
-			type: "",
-			// will be filled by updateCacheModule
-			resource: "",
-			context: "",
-			request: /** @type {EXPECTED_ANY} */ (null),
-			userRequest: /** @type {EXPECTED_ANY} */ (null),
-			rawRequest: /** @type {EXPECTED_ANY} */ (null),
-			loaders: /** @type {EXPECTED_ANY} */ (null),
-			matchResource: /** @type {EXPECTED_ANY} */ (null),
-			parser: /** @type {EXPECTED_ANY} */ (null),
-			parserOptions: /** @type {EXPECTED_ANY} */ (null),
-			generator: /** @type {EXPECTED_ANY} */ (null),
-			generatorOptions: /** @type {EXPECTED_ANY} */ (null),
-			resolveOptions: /** @type {EXPECTED_ANY} */ (null),
-			extractSourceMap: /** @type {EXPECTED_ANY} */ (null),
-			phase: /** @type {EXPECTED_ANY} */ (null)
-		});
-		obj.deserialize(context);
-		return obj;
-	}
-
-	/**
-	 * @param {ObjectDeserializerContext} context context
-	 */
-	deserialize(context) {
-		const { read } = context;
-		this.phase = read();
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(AsyncWasmModule, "webpack/lib/wasm-async/AsyncWasmModule");
-
 /**
+ * Defines the web assembly render context type used by this module.
  * @typedef {object} WebAssemblyRenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
@@ -139,46 +48,22 @@ makeSerializable(AsyncWasmModule, "webpack/lib/wasm-async/AsyncWasmModule");
  */
 
 /**
+ * Defines the compilation hooks type used by this module.
  * @typedef {object} CompilationHooks
  * @property {SyncWaterfallHook<[Source, Module, WebAssemblyRenderContext]>} renderModuleContent
  */
 
 /**
+ * Defines the async web assembly modules plugin options type used by this module.
  * @typedef {object} AsyncWebAssemblyModulesPluginOptions
  * @property {boolean=} mangleImports mangle imports
  */
 
-/** @type {WeakMap<Compilation, CompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
 const PLUGIN_NAME = "AsyncWebAssemblyModulesPlugin";
 
 class AsyncWebAssemblyModulesPlugin {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CompilationHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				renderModuleContent: new SyncWaterfallHook([
-					"source",
-					"module",
-					"renderContext"
-				])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
-	/**
+	 * Creates an instance of AsyncWebAssemblyModulesPlugin.
 	 * @param {AsyncWebAssemblyModulesPluginOptions} options options
 	 */
 	constructor(options) {
@@ -187,7 +72,7 @@ class AsyncWebAssemblyModulesPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -208,8 +93,7 @@ class AsyncWebAssemblyModulesPlugin {
 						PLUGIN_NAME,
 						(createData, resolveData) =>
 							new AsyncWasmModule({
-								.../** @type {NormalModuleCreateData & { type: string }} */
-								(createData),
+								...createData,
 								phase: resolveData.phase
 							})
 					);
@@ -286,6 +170,7 @@ class AsyncWebAssemblyModulesPlugin {
 	}
 
 	/**
+	 * Renders the newly generated source from rendering.
 	 * @param {Module} module the rendered module
 	 * @param {WebAssemblyRenderContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
@@ -311,4 +196,15 @@ class AsyncWebAssemblyModulesPlugin {
 	}
 }
 
+AsyncWebAssemblyModulesPlugin.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {CompilationHooks} */ ({
+			renderModuleContent: new SyncWaterfallHook([
+				"source",
+				"module",
+				"renderContext"
+			])
+		})
+);
+
 module.exports = AsyncWebAssemblyModulesPlugin;

package/lib/wasm-async/AsyncWebAssemblyParser.js

@@ -7,12 +7,12 @@
 
 const t = require("@webassemblyjs/ast");
 const { decode } = require("@webassemblyjs/wasm-parser");
-const EnvironmentNotSupportAsyncWarning = require("../EnvironmentNotSupportAsyncWarning");
 const Parser = require("../Parser");
 const StaticExportsDependency = require("../dependencies/StaticExportsDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
+const EnvironmentNotSupportAsyncWarning = require("../errors/EnvironmentNotSupportAsyncWarning");
 
-/** @typedef {import("./AsyncWebAssemblyModulesPlugin").AsyncWasmModuleClass} AsyncWasmModule */
+/** @typedef {import("./AsyncWasmModule")} AsyncWasmModule */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../NormalModule")} NormalModule */
@@ -31,6 +31,7 @@ const decoderOpts = {
 
 class WebAssemblyParser extends Parser {
 	/**
+	 * Parses the provided source and updates the parser state.
 	 * @param {string | Buffer | PreparsedAst} source the source to parse
 	 * @param {ParserState} state the parser state
 	 * @returns {ParserState} the parser state

package/lib/wasm-async/UniversalCompileAsyncWasmPlugin.js

@@ -16,9 +16,14 @@ const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRun
 
 const PLUGIN_NAME = "UniversalCompileAsyncWasmPlugin";
 
+/**
+ * Enables async WebAssembly loading that works in both browser-like and Node.js
+ * environments by selecting the appropriate binary-loading strategy at runtime.
+ */
 class UniversalCompileAsyncWasmPlugin {
 	/**
-	 * Apply the plugin
+	 * Registers compilation hooks that attach the universal async wasm runtime
+	 * to chunks using `wasmLoading: "universal"`.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -26,6 +31,8 @@ class UniversalCompileAsyncWasmPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalWasmLoading = compilation.outputOptions.wasmLoading;
 			/**
+			 * Determines whether the chunk should use the universal async wasm
+			 * loading backend.
 			 * @param {Chunk} chunk chunk
 			 * @returns {boolean} true, if wasm loading is enabled for the chunk
 			 */
@@ -44,15 +51,19 @@ class UniversalCompileAsyncWasmPlugin {
 					"}"
 				]);
 			/**
+			 * Generates setup code that decides whether the current environment can
+			 * use `fetch` and captures the wasm module URL.
 			 * @param {string} path path
 			 * @returns {string} code
 			 */
 			const generateBeforeLoadBinaryCode = (path) =>
 				Template.asString([
-					"var useFetch = typeof document !== 'undefined' || typeof self !== 'undefined';",
+					`var useFetch = ${compilation.runtimeTemplate.isWebLikePlatformExpression()};`,
 					`var wasmUrl = ${path};`
 				]);
 			/**
+			 * Generates the runtime expression that fetches the binary in browsers
+			 * or reads it from the filesystem in Node.js.
 			 * @type {(path: string) => string}
 			 */
 			const generateLoadBinaryCode = () =>

package/lib/wasm-sync/SyncWasmModule.js

@@ -0,0 +1,39 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const NormalModule = require("../NormalModule");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../NormalModule").NormalModuleCreateData} NormalModuleCreateData */
+
+/**
+ * Defines the build meta properties specific to sync wasm modules.
+ * @typedef {object} KnownSyncWasmModuleBuildMeta
+ * @property {Record<string, string>=} jsIncompatibleExports
+ */
+
+/** @typedef {BuildMeta & KnownSyncWasmModuleBuildMeta} SyncWasmModuleBuildMeta */
+
+/**
+ * Module class for `webassembly/sync` modules. Wasm-specific properties should live here instead of `NormalModule`.
+ */
+class SyncWasmModule extends NormalModule {
+	/**
+	 * @param {NormalModuleCreateData} options options object
+	 */
+	constructor(options) {
+		super(options);
+
+		// Redeclared with the sync wasm specific shape
+		/** @type {SyncWasmModuleBuildMeta | undefined} */
+		this.buildMeta = undefined;
+	}
+}
+
+makeSerializable(SyncWasmModule, "webpack/lib/wasm-sync/SyncWasmModule");
+
+module.exports = SyncWasmModule;

package/lib/wasm-sync/UnsupportedWebAssemblyFeatureError.js

@@ -4,10 +4,11 @@
 
 "use strict";
 
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 
-module.exports = class UnsupportedWebAssemblyFeatureError extends WebpackError {
+class UnsupportedWebAssemblyFeatureError extends WebpackError {
 	/**
+	 * Creates an instance of UnsupportedWebAssemblyFeatureError.
 	 * @param {string} message Error message
 	 */
 	constructor(message) {
@@ -15,6 +16,9 @@ module.exports = class UnsupportedWebAssemblyFeatureError extends WebpackError {
 
 		/** @type {string} */
 		this.name = "UnsupportedWebAssemblyFeatureError";
+		/** @type {boolean} */
 		this.hideStack = true;
 	}
-};
+}
+
+module.exports = UnsupportedWebAssemblyFeatureError;

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -239,12 +239,16 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 	}) {
 		super("wasm chunk loading", RuntimeModule.STAGE_ATTACH);
 		this.generateLoadBinaryCode = generateLoadBinaryCode;
+		/** @type {boolean | undefined} */
 		this.supportsStreaming = supportsStreaming;
+		/** @type {boolean | undefined} */
 		this.mangleImports = mangleImports;
+		/** @type {ReadOnlyRuntimeRequirements} */
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -253,7 +257,7 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 			RuntimeGlobals.hmrDownloadUpdateHandlers
 		);
 		const compilation = /** @type {Compilation} */ (this.compilation);
-		const { moduleGraph, outputOptions } = compilation;
+		const { moduleGraph, outputOptions, runtimeTemplate } = compilation;
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
@@ -280,12 +284,16 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 			mangleImports
 				? `{ ${JSON.stringify(WebAssemblyUtils.MANGLED_MODULE)}: ${content} }`
 				: content;
+		// Opt-in fallback to non-streaming when the server serves wasm with a wrong MIME type.
+		const streamingFallback = outputOptions.wasmStreamingFallback;
+		const streamingMimeFallbackWarning =
+			'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);';
 		const wasmModuleSrcPath = compilation.getPath(
 			JSON.stringify(outputOptions.webassemblyModuleFilename),
 			{
 				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
 				hashWithLength: (length) =>
-					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
+					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				module: {
 					id: '" + wasmModuleId + "',
 					hash: `" + ${JSON.stringify(
@@ -314,8 +322,8 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 		return Template.asString([
 			"// object to store loaded and loading wasm modules",
 			`var installedWasmModules = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{};`,
+				stateExpression ? runtimeTemplate.assignOr(stateExpression, "{}") : "{}"
+			};`,
 			"",
 			// This function is used to delay reading the installed wasm module promises
 			// by a microtask. Sorting them doesn't help because there are edge cases where
@@ -356,24 +364,83 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 						`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
 						"var promise;",
 						this.supportsStreaming
-							? Template.asString([
-									"if(importObject && typeof importObject.then === 'function' && typeof WebAssembly.compileStreaming === 'function') {",
-									Template.indent([
-										"promise = Promise.all([WebAssembly.compileStreaming(req), importObject]).then(function(items) {",
+							? streamingFallback
+								? Template.asString([
+										"if(importObject && typeof importObject.then === 'function' && typeof WebAssembly.compileStreaming === 'function') {",
 										Template.indent([
-											`return WebAssembly.instantiate(items[0], ${createImportObject(
-												"items[1]"
-											)});`
+											"promise = req.then(function(res) {",
+											Template.indent([
+												"return Promise.all([WebAssembly.compileStreaming(res), importObject]).then(function(items) {",
+												Template.indent([
+													`return WebAssembly.instantiate(items[0], ${createImportObject(
+														"items[1]"
+													)});`
+												]),
+												"}, function(e) {",
+												Template.indent([
+													'if(res.headers.get("Content-Type") !== "application/wasm") {',
+													Template.indent([
+														streamingMimeFallbackWarning,
+														"return Promise.all([res.arrayBuffer().then(function(bytes) { return WebAssembly.compile(bytes); }), importObject]).then(function(items) {",
+														Template.indent([
+															`return WebAssembly.instantiate(items[0], ${createImportObject(
+																"items[1]"
+															)});`
+														]),
+														"});"
+													]),
+													"}",
+													"throw e;"
+												]),
+												"});"
+											]),
+											"});"
 										]),
-										"});"
-									]),
-									"} else if(typeof WebAssembly.instantiateStreaming === 'function') {",
-									Template.indent([
-										`promise = WebAssembly.instantiateStreaming(req, ${createImportObject(
-											"importObject"
-										)});`
+										"} else if(typeof WebAssembly.instantiateStreaming === 'function') {",
+										Template.indent([
+											"promise = req.then(function(res) {",
+											Template.indent([
+												`return WebAssembly.instantiateStreaming(res, ${createImportObject(
+													"importObject"
+												)}).then(undefined, function(e) {`,
+												Template.indent([
+													'if(res.headers.get("Content-Type") !== "application/wasm") {',
+													Template.indent([
+														streamingMimeFallbackWarning,
+														"return res.arrayBuffer().then(function(bytes) {",
+														Template.indent([
+															`return WebAssembly.instantiate(bytes, ${createImportObject(
+																"importObject"
+															)});`
+														]),
+														"});"
+													]),
+													"}",
+													"throw e;"
+												]),
+												"});"
+											]),
+											"});"
+										])
+									])
+								: Template.asString([
+										"if(importObject && typeof importObject.then === 'function' && typeof WebAssembly.compileStreaming === 'function') {",
+										Template.indent([
+											"promise = Promise.all([WebAssembly.compileStreaming(req), importObject]).then(function(items) {",
+											Template.indent([
+												`return WebAssembly.instantiate(items[0], ${createImportObject(
+													"items[1]"
+												)});`
+											]),
+											"});"
+										]),
+										"} else if(typeof WebAssembly.instantiateStreaming === 'function') {",
+										Template.indent([
+											`promise = WebAssembly.instantiateStreaming(req, ${createImportObject(
+												"importObject"
+											)});`
+										])
 									])
-								])
 							: Template.asString([
 									"if(importObject && typeof importObject.then === 'function') {",
 									Template.indent([

package/lib/wasm-sync/WasmFinalizeExportsPlugin.js

@@ -5,19 +5,20 @@
 
 "use strict";
 
-const formatLocation = require("../formatLocation");
+const formatLocation = require("../util/formatLocation");
 const UnsupportedWebAssemblyFeatureError = require("./UnsupportedWebAssemblyFeatureError");
 
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("./SyncWasmModule").SyncWasmModuleBuildMeta} SyncWasmModuleBuildMeta */
 
 const PLUGIN_NAME = "WasmFinalizeExportsPlugin";
 
 class WasmFinalizeExportsPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -28,7 +29,7 @@ class WasmFinalizeExportsPlugin {
 					// 1. if a WebAssembly module
 					if (module.type.startsWith("webassembly") === true) {
 						const jsIncompatibleExports =
-							/** @type {BuildMeta} */
+							/** @type {SyncWasmModuleBuildMeta} */
 							(module.buildMeta).jsIncompatibleExports;
 
 						if (jsIncompatibleExports === undefined) {

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -17,11 +17,13 @@ const WebAssemblyUtils = require("./WebAssemblyUtils");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
 /** @typedef {import("@webassemblyjs/ast").Instruction} Instruction */
@@ -31,15 +33,18 @@ const WebAssemblyUtils = require("./WebAssemblyUtils");
 /** @typedef {import("@webassemblyjs/ast").AST} AST */
 /** @typedef {import("@webassemblyjs/ast").GlobalType} GlobalType */
 /**
+ * Defines the node path type used by this module.
  * @template T
  * @typedef {import("@webassemblyjs/ast").NodePath<T>} NodePath
  */
 
 /**
+ * Defines the array buffer transform type used by this module.
  * @typedef {(buf: ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
  */
 
 /**
+ * Returns composed transform.
  * @template T
  * @param {((prev: ArrayBuffer) => ArrayBuffer)[]} fns transforms
  * @returns {(buf: ArrayBuffer) => ArrayBuffer} composed transform
@@ -51,7 +56,7 @@ const compose = (...fns) =>
 	);
 
 /**
- * Removes the start instruction
+ * Removes start func.
  * @param {object} state state
  * @param {AST} state.ast Module's ast
  * @returns {ArrayBufferTransform} transform
@@ -200,6 +205,7 @@ const rewriteImportedGlobals = (state) => (bin) => {
 		// in order to preserve non-imported global's order we need to re-inject
 		// those as well
 		/**
+		 * Processes the provided path.
 		 * @param {NodePath<Global>} path path
 		 */
 		Global(path) {
@@ -252,6 +258,7 @@ const rewriteExportNames =
 	(bin) =>
 		editWithAST(ast, bin, {
 			/**
+			 * Processes the provided path.
 			 * @param {NodePath<ModuleExport>} path path
 			 */
 			ModuleExport(path) {
@@ -285,6 +292,7 @@ const rewriteImports =
 	(bin) =>
 		editWithAST(ast, bin, {
 			/**
+			 * Processes the provided path.
 			 * @param {NodePath<ModuleImport>} path path
 			 */
 			ModuleImport(path) {
@@ -406,20 +414,24 @@ const getUsedDependencyMap = (moduleGraph, module, mangle) => {
 };
 
 /**
+ * Represents the web assembly generator runtime component.
  * @typedef {object} WebAssemblyGeneratorOptions
  * @property {boolean=} mangleImports mangle imports
  */
 
 class WebAssemblyGenerator extends Generator {
 	/**
+	 * Creates an instance of WebAssemblyGenerator.
 	 * @param {WebAssemblyGeneratorOptions} options options
 	 */
 	constructor(options) {
 		super();
+		/** @type {WebAssemblyGeneratorOptions} */
 		this.options = options;
 	}
 
 	/**
+	 * Returns the source types available for this module.
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
@@ -428,6 +440,7 @@ class WebAssemblyGenerator extends Generator {
 	}
 
 	/**
+	 * Returns the estimated size for the requested source type.
 	 * @param {NormalModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
@@ -441,6 +454,7 @@ class WebAssemblyGenerator extends Generator {
 	}
 
 	/**
+	 * Generates generated code for this runtime module.
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
@@ -522,6 +536,7 @@ class WebAssemblyGenerator extends Generator {
 	}
 
 	/**
+	 * Generates fallback output for the provided error condition.
 	 * @param {Error} error the error
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
@@ -530,6 +545,17 @@ class WebAssemblyGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		return new RawSource(error.message);
 	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash that will be modified
+	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 */
+	updateHash(hash, updateHashContext) {
+		if (this.options.mangleImports) {
+			hash.update("mangle-imports");
+		}
+	}
 }
 
 module.exports = WebAssemblyGenerator;