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

package/lib/util/semver.js

@@ -11,11 +11,13 @@
 /** @typedef {(SemVerRangeItem | SemVerRangeItem[])[]} SemVerRange */
 
 /**
+ * Returns parsed version.
  * @param {string} str version string
  * @returns {SemVerRange} parsed version
  */
 const parseVersion = (str) => {
 	/**
+	 * Returns result.
 	 * @param {str} str str
 	 * @returns {VersionValue[]} result
 	 */
@@ -49,6 +51,7 @@ module.exports.parseVersion = parseVersion;
 
 /* eslint-disable eqeqeq */
 /**
+ * Returns true, iff a < b.
  * @param {string} a version
  * @param {string} b version
  * @returns {boolean} true, iff a < b
@@ -98,11 +101,13 @@ const versionLt = (a, b) => {
 module.exports.versionLt = versionLt;
 
 /**
+ * Returns parsed range.
  * @param {string} str range string
  * @returns {SemVerRange} parsed range
  */
 module.exports.parseRange = (str) => {
 	/**
+	 * Returns result.
 	 * @param {string} str str
 	 * @returns {VersionValue[]} result
 	 */
@@ -114,6 +119,7 @@ module.exports.parseRange = (str) => {
 
 	// see https://docs.npmjs.com/misc/semver#range-grammar for grammar
 	/**
+	 * Returns the sem ver range item.
 	 * @param {string} str str
 	 * @returns {SemVerRangeItem[]}
 	 */
@@ -143,6 +149,7 @@ module.exports.parseRange = (str) => {
 	};
 
 	/**
+	 * Returns the sem ver range item.
 	 *
 	 * @param {SemVerRangeItem[]} range range
 	 * @returns {SemVerRangeItem[]}
@@ -163,6 +170,7 @@ module.exports.parseRange = (str) => {
 	};
 
 	/**
+	 * Returns result.
 	 *
 	 * @param {SemVerRangeItem[]} range
 	 * @returns {SemVerRangeItem[]} result
@@ -172,6 +180,7 @@ module.exports.parseRange = (str) => {
 	};
 
 	/**
+	 * Returns the sem ver range.
 	 * @param {string} str str
 	 * @returns {SemVerRange}
 	 */
@@ -230,6 +239,7 @@ module.exports.parseRange = (str) => {
 	};
 
 	/**
+	 * Returns result.
 	 *
 	 * @param {SemVerRangeItem[][]} items items
 	 * @param {number} fn fn
@@ -251,6 +261,7 @@ module.exports.parseRange = (str) => {
 	};
 
 	/**
+	 * Returns the sem ver range.
 	 * @param {string} str str
 	 * @returns {SemVerRange}
 	 */
@@ -291,6 +302,7 @@ module.exports.parseRange = (str) => {
 	};
 
 	/**
+	 * Returns the sem ver range.
 	 * @param {string} str str
 	 * @returns {SemVerRange}
 	 */
@@ -309,6 +321,7 @@ module.exports.parseRange = (str) => {
 
 /* eslint-disable eqeqeq */
 /**
+ * Returns the string.
  * @param {SemVerRange} range
  * @returns {string}
  */
@@ -370,6 +383,7 @@ const rangeToString = (range) => {
 module.exports.rangeToString = rangeToString;
 
 /**
+ * Returns if version satisfy the range.
  * @param {SemVerRange} range version range
  * @param {string} version the version
  * @returns {boolean} if version satisfy the range
@@ -531,6 +545,7 @@ const satisfy = (range, version) => {
 module.exports.satisfy = satisfy;
 
 /**
+ * Returns the string.
  * @param {SemVerRange | string | number | false | undefined} json
  * @returns {string}
  */

package/lib/util/serialization.js

@@ -13,6 +13,7 @@ const memoize = require("./memoize");
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
 /**
+ * Defines the serializer type used by this module.
  * @template D, S, C
  * @typedef {import("../serialization/Serializer")<D, S, C>} Serializer
  */
@@ -109,6 +110,7 @@ module.exports = {
 		);
 	},
 	/**
+	 * Creates a file serializer.
 	 * @template D, S, C
 	 * @param {IntermediateFileSystem} fs filesystem
 	 * @param {HashFunction} hashFunction hash function to use

package/lib/util/smartGrouping.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /**
+ * Defines the group options type used by this module.
  * @typedef {object} GroupOptions
  * @property {boolean=} groupChildren
  * @property {boolean=} force
@@ -13,6 +14,7 @@
  */
 
 /**
+ * Defines the group config type used by this module.
  * @template I
  * @template G
  * @typedef {object} GroupConfig
@@ -22,17 +24,20 @@
  */
 
 /**
+ * Defines the group type used by this module.
  * @template I
  * @template G
  * @typedef {{ config: GroupConfig<I, G>, name: string, alreadyGrouped: boolean, items: Items<I, G> | undefined }} Group
  */
 
 /**
+ * Defines the groups type used by this module.
  * @template I, G
  * @typedef {Set<Group<I, G>>} Groups
  */
 
 /**
+ * Defines the item with groups type used by this module.
  * @template I
  * @template G
  * @typedef {object} ItemWithGroups
@@ -41,11 +46,13 @@
  */
 
 /**
+ * Defines the items type used by this module.
  * @template T, G
  * @typedef {Set<ItemWithGroups<T, G>>} Items
  */
 
 /**
+ * Returns grouped items.
  * @template I
  * @template G
  * @template R
@@ -90,6 +97,7 @@ const smartGrouping = (items, groupConfigs) => {
 	}
 
 	/**
+	 * Returns groups items.
 	 * @param {Items<I, G>} itemsWithGroups input items with groups
 	 * @returns {(I | G)[]} groups items
 	 */

package/lib/util/source.js

@@ -6,11 +6,13 @@
 "use strict";
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Hash")} Hash */
 
 /** @type {WeakMap<Source, WeakMap<Source, boolean>>} */
 const equalityCache = new WeakMap();
 
 /**
+ * Checks whether source equal true, when both sources are equal.
  * @param {Source} a a source
  * @param {Source} b another source
  * @returns {boolean} true, when both sources are equal
@@ -29,6 +31,7 @@ const _isSourceEqual = (a, b) => {
 };
 
 /**
+ * Checks whether this object is source equal.
  * @param {Source} a a source
  * @param {Source} b another source
  * @returns {boolean} true, when both sources are equal
@@ -59,4 +62,24 @@ const isSourceEqual = (a, b) => {
 	return result;
 };
 
+// TODO remove in webpack 6, this is protection against authors who directly use `webpack-sources` outdated version
+/**
+ * Feeds the Source's content into a Hash without forcing a single
+ * concatenated Buffer. Uses webpack-sources >= 3.4.0 `buffers()` when
+ * available so `ConcatSource` can stream its children directly.
+ * @param {Hash} hash hash to update
+ * @param {Source} source source whose bytes are appended
+ * @returns {void}
+ */
+const updateHashFromSource = (hash, source) => {
+	// TODO webpack 6: drop the `buffers` check, require webpack-sources >= 3.4
+	// and call `source.buffers()` unconditionally.
+	if (typeof source.buffers === "function") {
+		for (const buf of source.buffers()) hash.update(buf);
+	} else {
+		hash.update(source.buffer());
+	}
+};
+
 module.exports.isSourceEqual = isSourceEqual;
+module.exports.updateHashFromSource = updateHashFromSource;

package/lib/util/topologicalSort.js

@@ -0,0 +1,69 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/**
+ * Topologically sort `nodes` using Kahn's algorithm with source-order
+ * tie-breaking. Nodes that participate in a cycle remain unvisited —
+ * `visit` is never called for them — so the caller can naturally keep
+ * them in their original position by treating "no visit" as "keep
+ * source order".
+ *
+ * Precondition: every node appearing in `graph` (as a key OR inside any
+ * successor set) must also appear in `nodes`. The caller owns this
+ * invariant; the function does not validate it.
+ *
+ * Complexity: O(V·(V + E)). Each outer iteration scans the ready set
+ * linearly to find the smallest source-index node. CSS composes graphs
+ * are small (a handful of files per module) so this is fine; if a much
+ * larger graph ever needs sorting here, swap in a min-heap.
+ * @template T
+ * @param {Map<T, Set<T>>} graph adjacency list (`a -> b` means `a` must come before `b`)
+ * @param {T[]} nodes nodes in source first-appearance order
+ * @param {(node: T, index: number) => void} visit called once per non-cyclic node in topological order
+ * @returns {void}
+ */
+module.exports = (graph, nodes, visit) => {
+	/** @type {Map<T, number>} */
+	const inDegree = new Map();
+	/** @type {Map<T, number>} */
+	const sourceIndex = new Map();
+	for (let i = 0; i < nodes.length; i++) {
+		inDegree.set(nodes[i], 0);
+		sourceIndex.set(nodes[i], i);
+	}
+	for (const successors of graph.values()) {
+		for (const to of successors) {
+			inDegree.set(to, /** @type {number} */ (inDegree.get(to)) + 1);
+		}
+	}
+
+	const ready = nodes.filter((n) => inDegree.get(n) === 0);
+	let index = 0;
+	while (ready.length > 0) {
+		// Smallest-source-index wins ties. Linear scan + swap-with-last
+		// + pop avoids re-sorting the ready set on every iteration.
+		let minIdx = 0;
+		for (let i = 1; i < ready.length; i++) {
+			if (
+				/** @type {number} */ (sourceIndex.get(ready[i])) <
+				/** @type {number} */ (sourceIndex.get(ready[minIdx]))
+			) {
+				minIdx = i;
+			}
+		}
+		const node = ready[minIdx];
+		ready[minIdx] = ready[ready.length - 1];
+		ready.pop();
+		visit(node, index++);
+		const successors = graph.get(node);
+		if (!successors) continue;
+		for (const to of successors) {
+			const newDeg = /** @type {number} */ (inDegree.get(to)) - 1;
+			inDegree.set(to, newDeg);
+			if (newDeg === 0) ready.push(to);
+		}
+	}
+};

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,19 +46,22 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const { outputOptions, runtimeTemplate } = compilation;
+		// Opt-out fallback to non-streaming when the server serves wasm with a wrong MIME type.
+		const streamingFallback = outputOptions.wasmStreamingFallback;
 		const fn = RuntimeGlobals.compileWasm;
 		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: '" + wasmModuleHash + "',
@@ -104,24 +107,28 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 								? this.generateBeforeCompileStreaming()
 								: ""
 						),
-						Template.indent([
-							"return WebAssembly.compileStreaming(res)",
-							Template.indent([
-								".catch(",
-								Template.indent([
-									runtimeTemplate.basicFunction("e", [
-										'if(res.headers.get("Content-Type") !== "application/wasm") {',
+						Template.indent(
+							streamingFallback
+								? [
+										"return WebAssembly.compileStreaming(res)",
 										Template.indent([
-											'console.warn("`WebAssembly.compileStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.compile` which is slower. Original error:\\n", e);',
-											"return fallback();"
-										]),
-										"}",
-										"throw e;"
-									])
-								]),
-								");"
-							])
-						]),
+											".catch(",
+											Template.indent([
+												runtimeTemplate.basicFunction("e", [
+													'if(res.headers.get("Content-Type") !== "application/wasm") {',
+													Template.indent([
+														'console.warn("`WebAssembly.compileStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.compile` which is slower. Original error:\\n", e);',
+														"return fallback();"
+													]),
+													"}",
+													"throw e;"
+												])
+											]),
+											");"
+										])
+									]
+								: ["return WebAssembly.compileStreaming(res);"]
+						),
 						"}",
 						"return fallback();"
 					]),

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -47,19 +47,22 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const { outputOptions, runtimeTemplate } = compilation;
+		// Opt-in fallback to non-streaming when the server serves wasm with a wrong MIME type.
+		const streamingFallback = outputOptions.wasmStreamingFallback;
 		const fn = RuntimeGlobals.instantiateWasm;
 		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: '" + wasmModuleHash + "',
@@ -106,28 +109,37 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 								? this.generateBeforeInstantiateStreaming()
 								: ""
 						),
-						Template.indent([
-							"return WebAssembly.instantiateStreaming(res, importsObj)",
-							Template.indent([
-								".then(",
-								Template.indent([
-									`${runtimeTemplate.returningFunction(
-										"Object.assign(exports, res.instance.exports)",
-										"res"
-									)},`,
-									runtimeTemplate.basicFunction("e", [
-										'if(res.headers.get("Content-Type") !== "application/wasm") {',
+						Template.indent(
+							streamingFallback
+								? [
+										"return WebAssembly.instantiateStreaming(res, importsObj)",
 										Template.indent([
-											'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);',
-											"return fallback();"
-										]),
-										"}",
-										"throw e;"
-									])
-								]),
-								");"
-							])
-						]),
+											".then(",
+											Template.indent([
+												`${runtimeTemplate.returningFunction(
+													"Object.assign(exports, res.instance.exports)",
+													"res"
+												)},`,
+												runtimeTemplate.basicFunction("e", [
+													'if(res.headers.get("Content-Type") !== "application/wasm") {',
+													Template.indent([
+														'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);',
+														"return fallback();"
+													]),
+													"}",
+													"throw e;"
+												])
+											]),
+											");"
+										])
+									]
+								: [
+										`return WebAssembly.instantiateStreaming(res, importsObj).then(${runtimeTemplate.returningFunction(
+											"Object.assign(exports, res.instance.exports)",
+											"res"
+										)});`
+									]
+						),
 						"}",
 						"return fallback();"
 					]),

package/lib/wasm-async/AsyncWasmModule.js

@@ -0,0 +1,77 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const NormalModule = require("../NormalModule");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../NormalModule").NormalModuleCreateData} NormalModuleCreateData */
+/** @typedef {import("../dependencies/ImportPhase").ImportPhaseName} ImportPhaseName */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ImportPhaseName | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ImportPhaseName | undefined]>} ObjectSerializerContext */
+
+/**
+ * Module class for `webassembly/async` modules. Wasm-specific properties should live here instead of `NormalModule`.
+ */
+class AsyncWasmModule extends NormalModule {
+	/**
+	 * @param {NormalModuleCreateData & { phase: ImportPhaseName | undefined }} options options object
+	 */
+	constructor(options) {
+		super(options);
+		/** @type {ImportPhaseName | undefined} */
+		this.phase = options.phase;
+	}
+
+	/**
+	 * Returns the unique identifier used to reference this module.
+	 * @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;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.phase);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.phase = context.read();
+		super.deserialize(context.rest);
+	}
+}
+
+makeSerializable(AsyncWasmModule, "webpack/lib/wasm-async/AsyncWasmModule");
+
+module.exports = AsyncWasmModule;

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

@@ -14,7 +14,7 @@ const Template = require("../Template");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./AsyncWebAssemblyModulesPlugin").AsyncWasmModuleClass} AsyncWasmModule */
+/** @typedef {import("./AsyncWasmModule")} AsyncWasmModule */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").SourceType} SourceType */
@@ -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