webpack 5.83.1 → 5.85.0

package/lib/util/makeSerializable.js

@@ -6,6 +6,8 @@
 
 const { register } = require("./serialization");
 
+/** @typedef {import("../serialization/ObjectMiddleware").Constructor} Constructor */
+
 class ClassSerializer {
 	constructor(Constructor) {
 		this.Constructor = Constructor;
@@ -25,6 +27,11 @@ class ClassSerializer {
 	}
 }
 
+/**
+ * @param {Constructor} Constructor the constructor
+ * @param {string} request the request which will be required when deserializing
+ * @param {string | null} [name] the name to make multiple serializer unique when sharing a request
+ */
 module.exports = (Constructor, request, name = null) => {
 	register(Constructor, request, name, new ClassSerializer(Constructor));
 };

package/lib/util/serialization.js

@@ -11,6 +11,8 @@ const memoize = require("./memoize");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../serialization/Serializer")} Serializer */
+/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
 const getBinaryMiddleware = memoize(() =>
 	require("../serialization/BinaryMiddleware")
@@ -72,6 +74,9 @@ module.exports = {
 	get MEASURE_END_OPERATION() {
 		return getBinaryMiddleware().MEASURE_END_OPERATION;
 	},
+	/**
+	 * @returns {Serializer} buffer serializer
+	 */
 	get buffersSerializer() {
 		if (buffersSerializer !== undefined) return buffersSerializer;
 		registerSerializers();
@@ -93,6 +98,11 @@ module.exports = {
 			binaryMiddleware
 		]));
 	},
+	/**
+	 * @param {IntermediateFileSystem} fs filesystem
+	 * @param {string | Hash} hashFunction hash function to use
+	 * @returns {Serializer} file serializer
+	 */
 	createFileSerializer: (fs, hashFunction) => {
 		registerSerializers();
 		const Serializer = getSerializer();

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -9,7 +9,16 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/**
+ * @typedef {Object} AsyncWasmLoadingRuntimeModuleOptions
+ * @property {function(string): string} generateLoadBinaryCode
+ * @property {boolean} supportsStreaming
+ */
+
 class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {AsyncWasmLoadingRuntimeModuleOptions} options options
+	 */
 	constructor({ generateLoadBinaryCode, supportsStreaming }) {
 		super("wasm loading", RuntimeModule.STAGE_NORMAL);
 		this.generateLoadBinaryCode = generateLoadBinaryCode;

package/lib/wasm-async/AsyncWebAssemblyGenerator.js

@@ -13,7 +13,15 @@ const Generator = require("../Generator");
 
 const TYPES = new Set(["webassembly"]);
 
+/**
+ * @typedef {Object} AsyncWebAssemblyGeneratorOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 class AsyncWebAssemblyGenerator extends Generator {
+	/**
+	 * @param {AsyncWebAssemblyGeneratorOptions} options options
+	 */
 	constructor(options) {
 		super();
 		this.options = options;
@@ -46,7 +54,7 @@ class AsyncWebAssemblyGenerator extends Generator {
 	 * @returns {Source} generated code
 	 */
 	generate(module, generateContext) {
-		return module.originalSource();
+		return /** @type {Source} */ (module.originalSource());
 	}
 }
 

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -13,6 +13,7 @@ const Template = require("../Template");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
@@ -21,7 +22,14 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 
 const TYPES = new Set(["webassembly"]);
 
+/**
+ * @typedef {{ request: string, importVar: string }} ImportObjRequestItem
+ */
+
 class AsyncWebAssemblyJavascriptGenerator extends Generator {
+	/**
+	 * @param {OutputOptions["webassemblyModuleFilename"]} filenameTemplate template for the WebAssembly module filename
+	 */
 	constructor(filenameTemplate) {
 		super();
 		this.filenameTemplate = filenameTemplate;
@@ -61,9 +69,9 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 		runtimeRequirements.add(RuntimeGlobals.moduleId);
 		runtimeRequirements.add(RuntimeGlobals.exports);
 		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
-		/** @type {InitFragment[]} */
+		/** @type {InitFragment<InitFragment<string>>[]} */
 		const initFragments = [];
-		/** @type {Map<Module, { request: string, importVar: string }>} */
+		/** @type {Map<Module, ImportObjRequestItem>} */
 		const depModules = new Map();
 		/** @type {Map<string, WebAssemblyImportDependency[]>} */
 		const wasmDepsByRequest = new Map();
@@ -113,7 +121,9 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 			([request, deps]) => {
 				const exportItems = deps.map(dep => {
 					const importedModule = moduleGraph.getModule(dep);
-					const importVar = depModules.get(importedModule).importVar;
+					const importVar =
+						/** @type {ImportObjRequestItem} */
+						(depModules.get(importedModule)).importVar;
 					return `${JSON.stringify(
 						dep.name
 					)}: ${runtimeTemplate.exportFromImport({

package/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -15,6 +15,7 @@ const { compareModulesByIdentifier } = require("../util/comparators");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
@@ -25,6 +26,7 @@ const memoize = require("../util/memoize");
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../Template").RenderManifestEntry} RenderManifestEntry */
 /** @typedef {import("../Template").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
 
 const getAsyncWebAssemblyGenerator = memoize(() =>
 	require("./AsyncWebAssemblyGenerator")
@@ -51,6 +53,11 @@ const getAsyncWebAssemblyParser = memoize(() =>
  * @property {SyncWaterfallHook<[Source, Module, WebAssemblyRenderContext]>} renderModuleContent
  */
 
+/**
+ * @typedef {Object} AsyncWebAssemblyModulesPluginOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
@@ -81,6 +88,9 @@ class AsyncWebAssemblyModulesPlugin {
 		return hooks;
 	}
 
+	/**
+	 * @param {AsyncWebAssemblyModulesPluginOptions} options options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -140,7 +150,8 @@ class AsyncWebAssemblyModulesPlugin {
 						)) {
 							if (module.type === WEBASSEMBLY_MODULE_TYPE_ASYNC) {
 								const filenameTemplate =
-									outputOptions.webassemblyModuleFilename;
+									/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
+									(outputOptions.webassemblyModuleFilename);
 
 								result.push({
 									render: () =>
@@ -178,6 +189,12 @@ class AsyncWebAssemblyModulesPlugin {
 		);
 	}
 
+	/**
+	 * @param {Module} module the rendered module
+	 * @param {WebAssemblyRenderContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 * @returns {Source} the newly generated source from rendering
+	 */
 	renderModule(module, renderContext, hooks) {
 		const { codeGenerationResults, chunk } = renderContext;
 		try {
@@ -192,7 +209,7 @@ class AsyncWebAssemblyModulesPlugin {
 				"AsyncWebAssemblyModulesPlugin.getCompilationHooks().renderModuleContent"
 			);
 		} catch (e) {
-			e.module = module;
+			/** @type {WebpackError} */ (e).module = module;
 			throw e;
 		}
 	}

package/lib/wasm-async/AsyncWebAssemblyParser.js

@@ -23,6 +23,9 @@ const decoderOpts = {
 };
 
 class WebAssemblyParser extends Parser {
+	/**
+	 * @param {{}=} options parser options
+	 */
 	constructor(options) {
 		super();
 		this.hooks = Object.freeze({});

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -10,14 +10,22 @@ const Template = require("../Template");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const WebAssemblyUtils = require("./WebAssemblyUtils");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 // TODO webpack 6 remove the whole folder
 
 // Get all wasm modules
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Chunk} chunk the chunk
+ * @returns {Module[]} all wasm modules
+ */
 const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
 	const wasmModules = chunk.getAllAsyncChunks();
 	const array = [];
@@ -39,7 +47,7 @@ const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
  * generates the import object function for a module
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Module} module the module
- * @param {boolean} mangle mangle imports
+ * @param {boolean | undefined} mangle mangle imports
  * @param {string[]} declarations array where declarations are pushed to
  * @param {RuntimeSpec} runtime the runtime
  * @returns {string} source code
@@ -188,7 +196,18 @@ const generateImportObject = (
 	}
 };
 
+/**
+ * @typedef {Object} WasmChunkLoadingRuntimeModuleOptions
+ * @property {(path: string) => string} generateLoadBinaryCode
+ * @property {boolean} [supportsStreaming]
+ * @property {boolean} [mangleImports]
+ * @property {Set<string>} runtimeRequirements
+ */
+
 class WasmChunkLoadingRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {WasmChunkLoadingRuntimeModuleOptions} options options
+	 */
 	constructor({
 		generateLoadBinaryCode,
 		supportsStreaming,
@@ -213,6 +232,7 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 			RuntimeGlobals.hmrDownloadUpdateHandlers
 		);
 		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
+		/** @type {string[]} */
 		const declarations = [];
 		const importObjects = wasmModules.map(module => {
 			return generateImportObject(
@@ -226,6 +246,10 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 		const chunkModuleIdMap = chunkGraph.getChunkModuleIdMap(chunk, m =>
 			m.type.startsWith("webassembly")
 		);
+		/**
+		 * @param {string} content content
+		 * @returns {string} created import object
+		 */
 		const createImportObject = content =>
 			mangleImports
 				? `{ ${JSON.stringify(WebAssemblyUtils.MANGLED_MODULE)}: ${content} }`

package/lib/wasm-sync/WasmFinalizeExportsPlugin.js

@@ -9,6 +9,8 @@ const formatLocation = require("../formatLocation");
 const UnsupportedWebAssemblyFeatureError = require("./UnsupportedWebAssemblyFeatureError");
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
 
 class WasmFinalizeExportsPlugin {
 	/**
@@ -37,12 +39,13 @@ class WasmFinalizeExportsPlugin {
 								// 2. is active and referenced by a non-WebAssembly module
 								if (
 									connection.isTargetActive(undefined) &&
-									connection.originModule.type.startsWith("webassembly") ===
+									/** @type {Module} */
+									(connection.originModule).type.startsWith("webassembly") ===
 										false
 								) {
 									const referencedExports =
 										compilation.getDependencyReferencedExports(
-											connection.dependency,
+											/** @type {Dependency} */ (connection.dependency),
 											undefined
 										);
 
@@ -61,9 +64,15 @@ class WasmFinalizeExportsPlugin {
 											// 4. error
 											const error = new UnsupportedWebAssemblyFeatureError(
 												`Export "${name}" with ${jsIncompatibleExports[name]} can only be used for direct wasm to wasm dependencies\n` +
-													`It's used from ${connection.originModule.readableIdentifier(
-														compilation.requestShortener
-													)} at ${formatLocation(connection.dependency.loc)}.`
+													`It's used from ${
+														/** @type {Module} */
+														(connection.originModule).readableIdentifier(
+															compilation.requestShortener
+														)
+													} at ${formatLocation(
+														/** @type {Dependency} */ (connection.dependency)
+															.loc
+													)}.`
 											);
 											error.module = module;
 											compilation.errors.push(error);

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -27,7 +27,7 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 /** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
 
 /**
- * @typedef {(ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
+ * @typedef {(buf: ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
  */
 
 /**
@@ -62,9 +62,10 @@ const removeStartFunc = state => bin => {
  * Get imported globals
  *
  * @param {Object} ast Module's AST
- * @returns {Array<t.ModuleImport>} - nodes
+ * @returns {t.ModuleImport[]} - nodes
  */
 const getImportedGlobals = ast => {
+	/** @type {t.ModuleImport[]} */
 	const importedGlobals = [];
 
 	t.traverse(ast, {
@@ -318,7 +319,10 @@ const addInitFunction =
 				`${importedGlobal.module}.${importedGlobal.name}`
 			);
 
-			return t.funcParam(importedGlobal.descr.valtype, id);
+			return t.funcParam(
+				/** @type {string} */ (importedGlobal.descr.valtype),
+				id
+			);
 		});
 
 		const funcBody = [];
@@ -344,6 +348,7 @@ const addInitFunction =
 
 		funcBody.push(t.instruction("end"));
 
+		/** @type {string[]} */
 		const funcResults = [];
 
 		// Code section
@@ -369,7 +374,7 @@ const addInitFunction =
  * Extract mangle mappings from module
  * @param {ModuleGraph} moduleGraph module graph
  * @param {Module} module current module
- * @param {boolean} mangle mangle imports
+ * @param {boolean | undefined} mangle mangle imports
  * @returns {Map<string, UsedWasmDependency>} mappings to mangled names
  */
 const getUsedDependencyMap = (moduleGraph, module, mangle) => {
@@ -390,7 +395,15 @@ const getUsedDependencyMap = (moduleGraph, module, mangle) => {
 
 const TYPES = new Set(["webassembly"]);
 
+/**
+ * @typedef {Object} WebAssemblyGeneratorOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 class WebAssemblyGenerator extends Generator {
+	/**
+	 * @param {WebAssemblyGeneratorOptions} options options
+	 */
 	constructor(options) {
 		super();
 		this.options = options;
@@ -423,7 +436,7 @@ class WebAssemblyGenerator extends Generator {
 	 * @returns {Source} generated code
 	 */
 	generate(module, { moduleGraph, runtime }) {
-		const bin = module.originalSource().source();
+		const bin = /** @type {Source} */ (module.originalSource()).source();
 
 		const initFuncId = t.identifier("");
 

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -55,7 +55,7 @@ class WebAssemblyJavascriptGenerator extends Generator {
 			runtimeRequirements,
 			runtime
 		} = generateContext;
-		/** @type {InitFragment[]} */
+		/** @type {InitFragment<InitFragment<string>>[]} */
 		const initFragments = [];
 
 		const exportsInfo = moduleGraph.getExportsInfo(module);

package/lib/wasm-sync/WebAssemblyModulesPlugin.js

@@ -14,6 +14,7 @@ const memoize = require("../util/memoize");
 const WebAssemblyInInitialChunkError = require("./WebAssemblyInInitialChunkError");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleTemplate")} ModuleTemplate */
@@ -29,7 +30,15 @@ const getWebAssemblyParser = memoize(() => require("./WebAssemblyParser"));
 
 const PLUGIN_NAME = "WebAssemblyModulesPlugin";
 
+/**
+ * @typedef {Object} WebAssemblyModulesPluginOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 class WebAssemblyModulesPlugin {
+	/**
+	 * @param {WebAssemblyModulesPluginOptions} options options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -83,7 +92,9 @@ class WebAssemblyModulesPlugin {
 						compareModulesByIdentifier
 					)) {
 						if (module.type === WEBASSEMBLY_MODULE_TYPE_SYNC) {
-							const filenameTemplate = outputOptions.webassemblyModuleFilename;
+							const filenameTemplate =
+								/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
+								(outputOptions.webassemblyModuleFilename);
 
 							result.push({
 								render: () =>

package/lib/wasm-sync/WebAssemblyParser.js

@@ -61,6 +61,9 @@ const decoderOpts = {
 };
 
 class WebAssemblyParser extends Parser {
+	/**
+	 * @param {{}=} options parser options
+	 */
 	constructor(options) {
 		super();
 		this.hooks = Object.freeze({});
@@ -88,10 +91,12 @@ class WebAssemblyParser extends Parser {
 		const moduleContext = moduleContextFromModuleAST(module);
 
 		// extract imports and exports
+		/** @type {string[]} */
 		const exports = [];
 		let jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports =
 			undefined);
 
+		/** @type {TODO[]} */
 		const importedGlobals = [];
 		t.traverse(module, {
 			ModuleExport({ node }) {
@@ -157,12 +162,14 @@ class WebAssemblyParser extends Parser {
 				} else if (t.isTable(node.descr) === true) {
 					onlyDirectImport = "Table";
 				} else if (t.isFuncImportDescr(node.descr) === true) {
-					const incompatibleType = getJsIncompatibleType(node.descr.signature);
+					const incompatibleType = getJsIncompatibleType(
+						/** @type {t.Signature} */ (node.descr.signature)
+					);
 					if (incompatibleType) {
 						onlyDirectImport = `Non-JS-compatible Func Signature (${incompatibleType})`;
 					}
 				} else if (t.isGlobalType(node.descr) === true) {
-					const type = node.descr.valtype;
+					const type = /** @type {string} */ (node.descr.valtype);
 					if (!JS_COMPAT_TYPES.has(type)) {
 						onlyDirectImport = `Non-JS-compatible Global Type (${type})`;
 					}

package/lib/wasm-sync/WebAssemblyUtils.js

@@ -22,7 +22,7 @@ const MANGLED_MODULE = "a";
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {Module} module the module
- * @param {boolean} mangle mangle module and export names
+ * @param {boolean | undefined} mangle mangle module and export names
  * @returns {UsedWasmDependency[]} used dependencies and (mangled) name
  */
 const getUsedDependencies = (moduleGraph, module, mangle) => {

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -9,6 +9,7 @@ const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 class FetchCompileAsyncWasmPlugin {
@@ -22,6 +23,10 @@ class FetchCompileAsyncWasmPlugin {
 			"FetchCompileAsyncWasmPlugin",
 			compilation => {
 				const globalWasmLoading = compilation.outputOptions.wasmLoading;
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @returns {boolean} true, if wasm loading is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const wasmLoading =
@@ -30,6 +35,10 @@ class FetchCompileAsyncWasmPlugin {
 							: globalWasmLoading;
 					return wasmLoading === "fetch";
 				};
+				/**
+				 * @param {string} path path to the wasm file
+				 * @returns {string} code to load the wasm file
+				 */
 				const generateLoadBinaryCode = path =>
 					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
 

package/lib/web/FetchCompileWasmPlugin.js

@@ -9,15 +9,24 @@ const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 // TODO webpack 6 remove
 
 const PLUGIN_NAME = "FetchCompileWasmPlugin";
 
+/**
+ * @typedef {Object} FetchCompileWasmPluginOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 class FetchCompileWasmPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * @param {FetchCompileWasmPluginOptions} [options] options
+	 */
+	constructor(options = {}) {
+		this.options = options;
 	}
 
 	/**
@@ -28,6 +37,10 @@ class FetchCompileWasmPlugin {
 	apply(compiler) {
 		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 options = chunk.getEntryOptions();
 				const wasmLoading =
@@ -36,6 +49,10 @@ class FetchCompileWasmPlugin {
 						: globalWasmLoading;
 				return wasmLoading === "fetch";
 			};
+			/**
+			 * @param {string} path path to the wasm file
+			 * @returns {string} code to load the wasm file
+			 */
 			const generateLoadBinaryCode = path =>
 				`fetch(${RuntimeGlobals.publicPath} + ${path})`;
 

package/lib/web/JsonpChunkLoadingPlugin.js

@@ -8,6 +8,7 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const JsonpChunkLoadingRuntimeModule = require("./JsonpChunkLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 class JsonpChunkLoadingPlugin {
@@ -21,6 +22,10 @@ class JsonpChunkLoadingPlugin {
 			"JsonpChunkLoadingPlugin",
 			compilation => {
 				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @returns {boolean} true, if wasm loading is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =
@@ -30,6 +35,10 @@ class JsonpChunkLoadingPlugin {
 					return chunkLoading === "jsonp";
 				};
 				const onceForChunkSet = new WeakSet();
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @param {Set<string>} set runtime requirements
+				 */
 				const handler = (chunk, set) => {
 					if (onceForChunkSet.has(chunk)) return;
 					onceForChunkSet.add(chunk);

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -46,6 +46,9 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 		return hooks;
 	}
 
+	/**
+	 * @param {Set<string>} runtimeRequirements runtime requirements
+	 */
 	constructor(runtimeRequirements) {
 		super("jsonp chunk loading", RuntimeModule.STAGE_ATTACH);
 		this._runtimeRequirements = runtimeRequirements;
@@ -426,7 +429,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 										"}"
 									]),
 									"}",
-									"if(runtime) var result = runtime(__webpack_require__);"
+									`if(runtime) var result = runtime(${RuntimeGlobals.require});`
 								]),
 								"}",
 								"if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);",

package/lib/webworker/ImportScriptsChunkLoadingPlugin.js

@@ -9,6 +9,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenciesPlugin");
 const ImportScriptsChunkLoadingRuntimeModule = require("./ImportScriptsChunkLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 class ImportScriptsChunkLoadingPlugin {
@@ -26,6 +27,10 @@ class ImportScriptsChunkLoadingPlugin {
 			"ImportScriptsChunkLoadingPlugin",
 			compilation => {
 				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @returns {boolean} true, if wasm loading is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =
@@ -35,6 +40,10 @@ class ImportScriptsChunkLoadingPlugin {
 					return chunkLoading === "import-scripts";
 				};
 				const onceForChunkSet = new WeakSet();
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @param {Set<string>} set runtime requirements
+				 */
 				const handler = (chunk, set) => {
 					if (onceForChunkSet.has(chunk)) return;
 					onceForChunkSet.add(chunk);