webpack 5.106.1 → 5.107.0

package/lib/validateSchema.js

@@ -69,6 +69,7 @@ const REMOVED = {
 /* cSpell:enable */
 
 /**
+ * Processes the provided schema.
  * @param {Parameters<typeof validate>[0]} schema a json schema
  * @param {Parameters<typeof validate>[1]} options the options that should be validated
  * @param {Parameters<typeof validate>[2]=} validationConfiguration configuration for generating errors

package/lib/wasm/EnableWasmLoadingPlugin.js

@@ -14,6 +14,8 @@
 const enabledTypes = new WeakMap();
 
 /**
+ * Returns the set of wasm loading backends that have already been enabled for
+ * the compiler.
  * @param {Compiler} compiler compiler instance
  * @returns {WasmLoadingTypes} enabled types
  */
@@ -27,8 +29,14 @@ const getEnabledTypes = (compiler) => {
 	return set;
 };
 
+/**
+ * Validates and enables named wasm loading backends by applying the plugin
+ * implementations that provide their runtime support.
+ */
 class EnableWasmLoadingPlugin {
 	/**
+	 * Stores the wasm loading backend name that should be enabled for the
+	 * compiler.
 	 * @param {WasmLoadingType} type library type that should be available
 	 */
 	constructor(type) {
@@ -37,6 +45,8 @@ class EnableWasmLoadingPlugin {
 	}
 
 	/**
+	 * Marks a custom or built-in wasm loading type as enabled for the compiler
+	 * without applying additional built-in behavior.
 	 * @param {Compiler} compiler the compiler instance
 	 * @param {WasmLoadingType} type type of library
 	 * @returns {void}
@@ -46,6 +56,8 @@ class EnableWasmLoadingPlugin {
 	}
 
 	/**
+	 * Verifies that a wasm loading type has been enabled before code generation
+	 * attempts to use it.
 	 * @param {Compiler} compiler the compiler instance
 	 * @param {WasmLoadingType} type type of library
 	 * @returns {void}
@@ -63,7 +75,9 @@ class EnableWasmLoadingPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Enables the requested wasm loading backend once and applies the
+	 * environment-specific plugins that provide its parser, generator, and
+	 * runtime support.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/wasm-async/AsyncWasmCompileRuntimeModule.js

@@ -46,6 +46,7 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -47,6 +47,7 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/wasm-async/AsyncWebAssemblyGenerator.js

@@ -16,12 +16,14 @@ const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
 /** @typedef {import("../NormalModule")} NormalModule */
 
 /**
+ * Represents the async web assembly generator runtime component.
  * @typedef {object} AsyncWebAssemblyGeneratorOptions
  * @property {boolean=} mangleImports mangle imports
  */
 
 class AsyncWebAssemblyGenerator extends Generator {
 	/**
+	 * Creates an instance of AsyncWebAssemblyGenerator.
 	 * @param {AsyncWebAssemblyGeneratorOptions} options options
 	 */
 	constructor(options) {
@@ -31,6 +33,7 @@ class AsyncWebAssemblyGenerator extends Generator {
 	}
 
 	/**
+	 * Returns the source types available for this module.
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
@@ -39,6 +42,7 @@ class AsyncWebAssemblyGenerator 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
@@ -52,6 +56,7 @@ class AsyncWebAssemblyGenerator 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
@@ -61,6 +66,7 @@ class AsyncWebAssemblyGenerator 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

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -22,11 +22,13 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @typedef {import("../NormalModule")} NormalModule */
 
 /**
+ * Represents the async web assembly javascript generator runtime component.
  * @typedef {{ request: string, importVar: string, dependency: WebAssemblyImportDependency }} ImportObjRequestItem
  */
 
 class AsyncWebAssemblyJavascriptGenerator extends Generator {
 	/**
+	 * Returns the source types available for this module.
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
@@ -35,6 +37,7 @@ class AsyncWebAssemblyJavascriptGenerator 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
@@ -50,6 +53,7 @@ class AsyncWebAssemblyJavascriptGenerator 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
@@ -253,6 +257,7 @@ class AsyncWebAssemblyJavascriptGenerator 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

package/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -8,10 +8,10 @@
 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 memoize = require("../util/memoize");
@@ -27,7 +27,7 @@ const memoize = require("../util/memoize");
 /** @typedef {import("../NormalModule").NormalModuleCreateData} NormalModuleCreateData */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
@@ -53,6 +53,7 @@ class AsyncWasmModule extends NormalModule {
 	}
 
 	/**
+	 * Returns the unique identifier used to reference this module.
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
@@ -79,6 +80,7 @@ class AsyncWasmModule extends NormalModule {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
@@ -117,6 +119,7 @@ class AsyncWasmModule extends NormalModule {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
@@ -129,6 +132,7 @@ class AsyncWasmModule extends NormalModule {
 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,11 +143,13 @@ 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
  */
@@ -155,6 +161,7 @@ const PLUGIN_NAME = "AsyncWebAssemblyModulesPlugin";
 
 class AsyncWebAssemblyModulesPlugin {
 	/**
+	 * Returns the attached hooks.
 	 * @param {Compilation} compilation the compilation
 	 * @returns {CompilationHooks} the attached hooks
 	 */
@@ -179,6 +186,7 @@ class AsyncWebAssemblyModulesPlugin {
 	}
 
 	/**
+	 * Creates an instance of AsyncWebAssemblyModulesPlugin.
 	 * @param {AsyncWebAssemblyModulesPluginOptions} options options
 	 */
 	constructor(options) {
@@ -187,7 +195,7 @@ class AsyncWebAssemblyModulesPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -286,6 +294,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

package/lib/wasm-async/AsyncWebAssemblyParser.js

@@ -7,10 +7,10 @@
 
 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("../Module").BuildInfo} BuildInfo */
@@ -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,6 +51,8 @@ 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
 			 */
@@ -53,6 +62,8 @@ class UniversalCompileAsyncWasmPlugin {
 					`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/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) {
@@ -17,4 +18,6 @@ module.exports = class UnsupportedWebAssemblyFeatureError extends WebpackError {
 		this.name = "UnsupportedWebAssemblyFeatureError";
 		this.hideStack = true;
 	}
-};
+}
+
+module.exports = UnsupportedWebAssemblyFeatureError;

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -245,6 +245,7 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/wasm-sync/WasmFinalizeExportsPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const formatLocation = require("../formatLocation");
+const formatLocation = require("../util/formatLocation");
 const UnsupportedWebAssemblyFeatureError = require("./UnsupportedWebAssemblyFeatureError");
 
 /** @typedef {import("../Compiler")} Compiler */
@@ -17,7 +17,7 @@ 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}
 	 */

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,12 +414,14 @@ 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) {
@@ -420,6 +430,7 @@ class WebAssemblyGenerator extends Generator {
 	}
 
 	/**
+	 * Returns the source types available for this module.
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
@@ -428,6 +439,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 +453,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 +535,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 +544,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;

package/lib/wasm-sync/WebAssemblyInInitialChunkError.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Module")} Module */
@@ -12,6 +12,7 @@ const WebpackError = require("../WebpackError");
 /** @typedef {import("../RequestShortener")} RequestShortener */
 
 /**
+ * Gets initial module chains.
  * @param {Module} module module to get chains from
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {ChunkGraph} chunkGraph the chunk graph
@@ -82,8 +83,9 @@ const getInitialModuleChains = (
 	return [...results];
 };
 
-module.exports = class WebAssemblyInInitialChunkError extends WebpackError {
+class WebAssemblyInInitialChunkError extends WebpackError {
 	/**
+	 * Creates an instance of WebAssemblyInInitialChunkError.
 	 * @param {Module} module WASM module
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ChunkGraph} chunkGraph the chunk graph
@@ -108,4 +110,6 @@ ${moduleChains.map((s) => `* ${s}`).join("\n")}`;
 		this.hideStack = true;
 		this.module = module;
 	}
-};
+}
+
+module.exports = WebAssemblyInInitialChunkError;

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -25,6 +25,7 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 
 class WebAssemblyJavascriptGenerator extends Generator {
 	/**
+	 * Returns the source types available for this module.
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
@@ -33,6 +34,7 @@ class WebAssemblyJavascriptGenerator 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
@@ -42,6 +44,7 @@ class WebAssemblyJavascriptGenerator 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
@@ -223,6 +226,7 @@ class WebAssemblyJavascriptGenerator 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

package/lib/wasm-sync/WebAssemblyModulesPlugin.js

@@ -31,12 +31,19 @@ const getWebAssemblyParser = memoize(() => require("./WebAssemblyParser"));
 const PLUGIN_NAME = "WebAssemblyModulesPlugin";
 
 /**
+ * Options that influence how synchronous WebAssembly modules are transformed
+ * and emitted.
  * @typedef {object} WebAssemblyModulesPluginOptions
  * @property {boolean=} mangleImports mangle imports
  */
 
+/**
+ * Adds parser, generator, manifest, and validation support for synchronous
+ * WebAssembly modules in the compilation pipeline.
+ */
 class WebAssemblyModulesPlugin {
 	/**
+	 * Stores options that affect generated synchronous WebAssembly output.
 	 * @param {WebAssemblyModulesPluginOptions} options options
 	 */
 	constructor(options) {
@@ -44,7 +51,9 @@ class WebAssemblyModulesPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Registers compilation hooks that parse and generate sync WebAssembly
+	 * modules, emit their binary assets, and report invalid placement in initial
+	 * chunks.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/wasm-sync/WebAssemblyParser.js

@@ -22,6 +22,7 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 const JS_COMPAT_TYPES = new Set(["i32", "i64", "f32", "f64", "externref"]);
 
 /**
+ * Gets js incompatible type.
  * @param {t.Signature} signature the func signature
  * @returns {null | string} the type incompatible with js types
  */
@@ -64,6 +65,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-sync/WebAssemblyUtils.js

@@ -12,6 +12,7 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 
 /**
+ * Defines the used wasm dependency type used by this module.
  * @typedef {object} UsedWasmDependency
  * @property {WebAssemblyImportDependency} dependency the dependency
  * @property {string} name the export name
@@ -21,6 +22,7 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 const MANGLED_MODULE = "a";
 
 /**
+ * Gets used dependencies.
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {Module} module the module
  * @param {boolean | undefined} mangle mangle module and export names

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -15,9 +15,14 @@ const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRun
 
 const PLUGIN_NAME = "FetchCompileAsyncWasmPlugin";
 
+/**
+ * Enables asynchronous WebAssembly loading through `fetch` for environments
+ * that can instantiate fetched binaries at runtime.
+ */
 class FetchCompileAsyncWasmPlugin {
 	/**
-	 * Apply the plugin
+	 * Registers compilation hooks that attach the async fetch-based wasm runtime
+	 * to chunks containing async WebAssembly modules.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -25,6 +30,8 @@ class FetchCompileAsyncWasmPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalWasmLoading = compilation.outputOptions.wasmLoading;
 			/**
+			 * Determines whether the chunk should load async WebAssembly binaries
+			 * through the `fetch` backend.
 			 * @param {Chunk} chunk chunk
 			 * @returns {boolean} true, if wasm loading is enabled for the chunk
 			 */
@@ -37,6 +44,8 @@ class FetchCompileAsyncWasmPlugin {
 				return wasmLoading === "fetch";
 			};
 			/**
+			 * Generates the runtime expression that downloads the emitted wasm
+			 * binary for an async WebAssembly module.
 			 * @param {string} path path to the wasm file
 			 * @returns {string} code to load the wasm file
 			 */