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

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
@@ -105,7 +107,11 @@ ${moduleChains.map((s) => `* ${s}`).join("\n")}`;
 
 		/** @type {string} */
 		this.name = "WebAssemblyInInitialChunkError";
+		/** @type {boolean} */
 		this.hideStack = true;
+		/** @type {Module} */
 		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

@@ -27,24 +27,35 @@ const getWebAssemblyJavascriptGenerator = memoize(() =>
 	require("./WebAssemblyJavascriptGenerator")
 );
 const getWebAssemblyParser = memoize(() => require("./WebAssemblyParser"));
+const getSyncWasmModule = memoize(() => require("./SyncWasmModule"));
 
 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) {
+		/** @type {WebAssemblyModulesPluginOptions} */
 		this.options = options;
 	}
 
 	/**
-	 * 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}
 	 */
@@ -62,6 +73,14 @@ class WebAssemblyModulesPlugin {
 					normalModuleFactory
 				);
 
+				normalModuleFactory.hooks.createModuleClass
+					.for(WEBASSEMBLY_MODULE_TYPE_SYNC)
+					.tap(PLUGIN_NAME, (createData, _resolveData) => {
+						const SyncWasmModule = getSyncWasmModule();
+
+						return new SyncWasmModule(createData);
+					});
+
 				normalModuleFactory.hooks.createParser
 					.for(WEBASSEMBLY_MODULE_TYPE_SYNC)
 					.tap(PLUGIN_NAME, () => {

package/lib/wasm-sync/WebAssemblyParser.js

@@ -16,12 +16,14 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @typedef {import("@webassemblyjs/ast").ModuleImport} ModuleImport */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("./SyncWasmModule").SyncWasmModuleBuildMeta} SyncWasmModuleBuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
 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
  */
@@ -38,7 +40,8 @@ const getJsIncompatibleType = (signature) => {
 };
 
 /**
- * TODO why are there two different Signature types?
+ * Same check for the other `@webassemblyjs` signature shape: imports carry the
+ * AST `Signature` node (above), the module context uses plain `FuncSignature`.
  * @param {t.FuncSignature} signature the func signature
  * @returns {null | string} the type incompatible with js types
  */
@@ -64,6 +67,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
@@ -88,7 +92,9 @@ class WebAssemblyParser extends Parser {
 		// extract imports and exports
 		/** @type {string[]} */
 		const exports = [];
-		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		const buildMeta = /** @type {SyncWasmModuleBuildMeta} */ (
+			state.module.buildMeta
+		);
 		/** @type {Record<string, string> | undefined} */
 		let jsIncompatibleExports = (buildMeta.jsIncompatibleExports = undefined);
 
@@ -112,7 +118,7 @@ class WebAssemblyParser extends Parser {
 					if (incompatibleType) {
 						if (jsIncompatibleExports === undefined) {
 							jsIncompatibleExports =
-								/** @type {BuildMeta} */
+								/** @type {SyncWasmModuleBuildMeta} */
 								(state.module.buildMeta).jsIncompatibleExports = {};
 						}
 						jsIncompatibleExports[node.name] = incompatibleType;

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

@@ -7,17 +7,31 @@
 
 const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
+const { getPresentKinds } = require("../TemplatedPathPlugin");
 const AsyncWasmCompileRuntimeModule = require("../wasm-async/AsyncWasmCompileRuntimeModule");
 const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * The wasm runtime inlines `[fullhash]` as a runtime `getFullHash()` call, so
+ * that runtime module must be requested (`[hash]` is the per-module hash here).
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} whether it references the compilation `[fullhash]`
+ */
+const usesFullHash = (filename) => getPresentKinds(filename).has("fullhash");
+
 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 +39,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 +53,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
 			 */
@@ -56,6 +74,11 @@ class FetchCompileAsyncWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.publicPath);
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmLoadingRuntimeModule({
@@ -78,6 +101,11 @@ class FetchCompileAsyncWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.publicPath);
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmCompileRuntimeModule({

package/lib/web/FetchCompileWasmPlugin.js

@@ -7,20 +7,36 @@
 
 const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
+const { getPresentKinds } = require("../TemplatedPathPlugin");
 const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
+ * The wasm runtime inlines `[fullhash]` as a runtime `getFullHash()` call, so
+ * that runtime module must be requested (`[hash]` is the per-module hash here).
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} whether it references the compilation `[fullhash]`
+ */
+const usesFullHash = (filename) => getPresentKinds(filename).has("fullhash");
+
+/**
+ * Options that influence how synchronous WebAssembly modules are emitted for
+ * the fetch-based wasm loading runtime.
  * @typedef {object} FetchCompileWasmPluginOptions
  * @property {boolean=} mangleImports mangle imports
  */
 
 const PLUGIN_NAME = "FetchCompileWasmPlugin";
 
+/**
+ * Enables synchronous WebAssembly chunk loading that fetches `.wasm` files and
+ * compiles them in browser-like environments.
+ */
 class FetchCompileWasmPlugin {
 	/**
+	 * Stores options that affect generated synchronous WebAssembly runtime code.
 	 * @param {FetchCompileWasmPluginOptions=} options options
 	 */
 	constructor(options = {}) {
@@ -29,7 +45,8 @@ class FetchCompileWasmPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Registers compilation hooks that attach the fetch-based synchronous wasm
+	 * runtime module to chunks containing sync WebAssembly modules.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -37,6 +54,8 @@ class FetchCompileWasmPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalWasmLoading = compilation.outputOptions.wasmLoading;
 			/**
+			 * Determines whether the chunk should load synchronous WebAssembly
+			 * binaries through the `fetch` backend.
 			 * @param {Chunk} chunk chunk
 			 * @returns {boolean} true, if wasm loading is enabled for the chunk
 			 */
@@ -49,6 +68,8 @@ class FetchCompileWasmPlugin {
 				return wasmLoading === "fetch";
 			};
 			/**
+			 * Generates the runtime expression that downloads the emitted wasm
+			 * binary for a module.
 			 * @param {string} path path to the wasm file
 			 * @returns {string} code to load the wasm file
 			 */
@@ -69,6 +90,11 @@ class FetchCompileWasmPlugin {
 					}
 					set.add(RuntimeGlobals.moduleCache);
 					set.add(RuntimeGlobals.publicPath);
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new WasmChunkLoadingRuntimeModule({

package/lib/web/JsonpChunkLoadingPlugin.js

@@ -14,9 +14,15 @@ const JsonpChunkLoadingRuntimeModule = require("./JsonpChunkLoadingRuntimeModule
 
 const PLUGIN_NAME = "JsonpChunkLoadingPlugin";
 
+/**
+ * Enables browser-side JavaScript chunk loading through the JSONP runtime and
+ * adds the supporting runtime requirements for matching chunks.
+ */
 class JsonpChunkLoadingPlugin {
 	/**
-	 * Apply the plugin
+	 * Registers compilation hooks that attach the JSONP chunk-loading runtime
+	 * module and its dependent runtime globals to chunks using `chunkLoading:
+	 * "jsonp"`.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -24,6 +30,8 @@ class JsonpChunkLoadingPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalChunkLoading = compilation.outputOptions.chunkLoading;
 			/**
+			 * Determines whether the chunk resolves JavaScript chunks through the
+			 * JSONP loading backend.
 			 * @param {Chunk} chunk chunk
 			 * @returns {boolean} true, if wasm loading is enabled for the chunk
 			 */
@@ -38,6 +46,8 @@ class JsonpChunkLoadingPlugin {
 			/** @type {WeakSet<Chunk>} */
 			const onceForChunkSet = new WeakSet();
 			/**
+			 * Adds the JSONP runtime module to a chunk once, along with the core
+			 * runtime globals it relies on.
 			 * @param {Chunk} chunk chunk
 			 * @param {RuntimeRequirements} set runtime requirements
 			 */

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -5,7 +5,7 @@
 "use strict";
 
 const { SyncWaterfallHook } = require("tapable");
-const Compilation = require("../Compilation");
+/** @typedef {import("../Compilation")} Compilation */
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
@@ -15,6 +15,7 @@ const {
 const chunkHasJs = require("../javascript/JavascriptModulesPlugin").chunkHasJs;
 const { getInitialChunkIds } = require("../javascript/StartupHelpers");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
+const createHooksRegistry = require("../util/createHooksRegistry");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
@@ -26,31 +27,7 @@ const compileBooleanMatcher = require("../util/compileBooleanMatcher");
  * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
  */
 
-/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
-const compilationHooksMap = new WeakMap();
-
 class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {JsonpCompilationPluginHooks} 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 = {
-				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
-				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
 	/**
 	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
@@ -74,6 +51,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -130,21 +108,24 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_jsonp`
 			: undefined;
 
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
+		const installedChunksObject = `{\n${Template.indent(
+			Array.from(initialChunkIds, (id) => `${JSON.stringify(id)}: 0`).join(
+				",\n"
+			)
+		)}\n}`;
 		return Template.asString([
 			withBaseURI ? this._generateBaseUri(chunk) : "// no baseURI",
 			"",
 			"// object to store loaded and loading chunks",
 			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
 			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, (id) => `${JSON.stringify(id)}: 0`).join(
-					",\n"
-				)
-			),
-			"};",
+			`${cst} installedChunks = ${
+				stateExpression
+					? runtimeTemplate.assignOr(stateExpression, installedChunksObject)
+					: installedChunksObject
+			};`,
 			"",
 			withLoading
 				? Template.asString([
@@ -153,7 +134,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 							hasJsMatcher !== false
 								? Template.indent([
 										"// JSONP chunk loading for javascript",
-										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+										`${lt} installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
 										'if(installedChunkData !== 0) { // 0 means "already installed".',
 										Template.indent([
 											"",
@@ -169,17 +150,17 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 													: `if(${hasJsMatcher("chunkId")}) {`,
 												Template.indent([
 													"// setup Promise in chunk cache",
-													`var promise = new Promise(${runtimeTemplate.expressionFunction(
+													`${cst} promise = new Promise(${runtimeTemplate.expressionFunction(
 														"installedChunkData = installedChunks[chunkId] = [resolve, reject]",
 														"resolve, reject"
 													)});`,
 													"promises.push(installedChunkData[2] = promise);",
 													"",
 													"// start chunk loading",
-													`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
+													`${cst} url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
 													"// create error before stack unwound to get useful stacktrace later",
-													"var error = new Error();",
-													`var loadingEnded = ${runtimeTemplate.basicFunction(
+													`${cst} error = new Error();`,
+													`${cst} loadingEnded = ${runtimeTemplate.basicFunction(
 														"event",
 														[
 															`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
@@ -188,12 +169,13 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 																"if(installedChunkData !== 0) installedChunks[chunkId] = undefined;",
 																"if(installedChunkData) {",
 																Template.indent([
-																	"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
-																	"var realSrc = event && event.target && event.target.src;",
+																	`${cst} errorType = event && (event.type === 'load' ? 'missing' : event.type);`,
+																	`${cst} realSrc = event && event.target && event.target.src;`,
 																	"error.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
 																	"error.name = 'ChunkLoadError';",
 																	"error.type = errorType;",
 																	"error.request = realSrc;",
+																	"error.event = event;",
 																	"installedChunkData[1](error);"
 																]),
 																"}"
@@ -233,7 +215,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 							"installedChunks[chunkId] = null;",
 							linkPrefetch.call(
 								Template.asString([
-									"var link = document.createElement('link');",
+									`${cst} link = document.createElement('link');`,
 									charset ? "link.charset = 'utf-8';" : "",
 									crossOriginLoading
 										? `link.crossOrigin = ${JSON.stringify(
@@ -270,7 +252,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 							"installedChunks[chunkId] = null;",
 							linkPreload.call(
 								Template.asString([
-									"var link = document.createElement('link');",
+									`${cst} link = document.createElement('link');`,
 									scriptType && scriptType !== "module"
 										? `link.type = ${JSON.stringify(scriptType)};`
 										: "",
@@ -309,8 +291,8 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 			"",
 			withHmr
 				? Template.asString([
-						"var currentUpdatedModulesList;",
-						"var waitingUpdateResolves = {};",
+						`${lt} currentUpdatedModulesList;`,
+						`${cst} waitingUpdateResolves = {};`,
 						"function loadUpdateChunk(chunkId, updatedModulesList) {",
 						Template.indent([
 							"currentUpdatedModulesList = updatedModulesList;",
@@ -319,23 +301,27 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 								[
 									"waitingUpdateResolves[chunkId] = resolve;",
 									"// start update chunk loading",
-									`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId);`,
+									`${cst} url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId);`,
 									"// create error before stack unwound to get useful stacktrace later",
-									"var error = new Error();",
-									`var loadingEnded = ${runtimeTemplate.basicFunction("event", [
-										"if(waitingUpdateResolves[chunkId]) {",
-										Template.indent([
-											"waitingUpdateResolves[chunkId] = undefined",
-											"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
-											"var realSrc = event && event.target && event.target.src;",
-											"error.message = 'Loading hot update chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
-											"error.name = 'ChunkLoadError';",
-											"error.type = errorType;",
-											"error.request = realSrc;",
-											"reject(error);"
-										]),
-										"}"
-									])};`,
+									`${cst} error = new Error();`,
+									`${cst} loadingEnded = ${runtimeTemplate.basicFunction(
+										"event",
+										[
+											"if(waitingUpdateResolves[chunkId]) {",
+											Template.indent([
+												"waitingUpdateResolves[chunkId] = undefined",
+												`${cst} errorType = event && (event.type === 'load' ? 'missing' : event.type);`,
+												`${cst} realSrc = event && event.target && event.target.src;`,
+												"error.message = 'Loading hot update chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
+												"error.name = 'ChunkLoadError';",
+												"error.type = errorType;",
+												"error.request = realSrc;",
+												"error.event = event;",
+												"reject(error);"
+											]),
+											"}"
+										]
+									)};`,
 									`${RuntimeGlobals.loadScript}(url, loadingEnded);`
 								]
 							)});`
@@ -352,7 +338,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 									`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
 									Template.indent([
 										"currentUpdate[moduleId] = moreModules[moduleId];",
-										"if(currentUpdatedModulesList) currentUpdatedModulesList.push(moduleId);"
+										`${runtimeTemplate.optionalChaining("currentUpdatedModulesList", "push(moduleId)")};`
 									]),
 									"}"
 								]),
@@ -400,7 +386,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 			withCallback || withLoading
 				? Template.asString([
 						"// install a JSONP callback for chunk loading",
-						`var webpackJsonpCallback = ${runtimeTemplate.basicFunction(
+						`${cst} webpackJsonpCallback = ${runtimeTemplate.basicFunction(
 							"parentChunkLoadingFunction, data",
 							[
 								runtimeTemplate.destructureArray(
@@ -443,7 +429,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 							]
 						)}`,
 						"",
-						`var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
+						`${cst} chunkLoadingGlobal = ${runtimeTemplate.assignOr(chunkLoadingGlobalExpr, "[]")};`,
 						"chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));",
 						"chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));"
 					])
@@ -452,4 +438,12 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 }
 
+JsonpChunkLoadingRuntimeModule.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {JsonpCompilationPluginHooks} */ ({
+			linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+			linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
+		})
+);
+
 module.exports = JsonpChunkLoadingRuntimeModule;

package/lib/web/JsonpTemplatePlugin.js

@@ -15,6 +15,7 @@ const JsonpChunkLoadingRuntimeModule = require("./JsonpChunkLoadingRuntimeModule
 // TODO webpack 6 remove this class
 class JsonpTemplatePlugin {
 	/**
+	 * Returns hooks.
 	 * @deprecated use JsonpChunkLoadingRuntimeModule.getCompilationHooks instead
 	 * @param {Compilation} compilation the compilation
 	 * @returns {JsonpChunkLoadingRuntimeModule.JsonpCompilationPluginHooks} hooks
@@ -24,7 +25,7 @@ class JsonpTemplatePlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */