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

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -7,20 +7,13 @@
 
 const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
-const { getPresentKinds } = require("../TemplatedPathPlugin");
+const { usesFullHashDigest } = require("../TemplatedPathPlugin");
+const { needsRuntimeFullHash } = require("../wasm/wasmModuleFilename");
 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");
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "FetchCompileAsyncWasmPlugin";
 
@@ -53,13 +46,36 @@ class FetchCompileAsyncWasmPlugin {
 				return wasmLoading === "fetch";
 			};
 			/**
-			 * Generates the runtime expression that downloads the emitted wasm
-			 * binary for an async WebAssembly module.
+			 * Downloads the emitted wasm binary through the runtime
+			 * `__webpack_require__.p` public path.
 			 * @param {string} path path to the wasm file
 			 * @returns {string} code to load the wasm file
 			 */
 			const generateLoadBinaryCode = (path) =>
 				`fetch(${RuntimeGlobals.publicPath} + ${path})`;
+			/**
+			 * ESM-output variant: the analyzable `fetch(new URL(path, import.meta.url))`
+			 * form (relative to the chunk, no runtime public-path global) that other
+			 * bundlers and webpack itself can statically follow to the emitted wasm.
+			 * @param {string} path path to the wasm file
+			 * @returns {string} code to load the wasm file
+			 */
+			const generateAnalyzableLoadBinaryCode = (path) =>
+				`fetch(${compilation.runtimeTemplate.importMetaUrl(path)})`;
+			/**
+			 * The call site already passes a complete `URL`, so no base is applied here.
+			 * @param {string} path the wasm binary's URL expression
+			 * @returns {string} code to load the wasm file
+			 */
+			const generateBakedLoadBinaryCode = (path) => `fetch(${path})`;
+			/**
+			 * A settled public path is the same string the global would hold, and `fetch`
+			 * reads both against the document, so the runtime module is not needed.
+			 * @param {string} constant the settled public path
+			 * @returns {(path: string) => string} code to load the wasm file
+			 */
+			const generateConstantLoadBinaryCode = (constant) => (path) =>
+				`fetch(${JSON.stringify(constant)} + ${path})`;
 
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.instantiateWasm)
@@ -73,16 +89,49 @@ class FetchCompileAsyncWasmPlugin {
 					) {
 						return;
 					}
-					set.add(RuntimeGlobals.publicPath);
+					const baked = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm",
+						undefined,
+						undefined,
+						chunk.runtime
+					);
+					const analyzable =
+						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					// A baked URL carries the public path already, and a settled one is written
+					// out below; only a path nothing but the global knows asks for it.
+					const constant =
+						baked || analyzable
+							? undefined
+							: compilation.runtimeTemplate.constantPublicPath();
+					if (!baked && !analyzable && constant === undefined) {
+						set.add(RuntimeGlobals.publicPath);
+					}
+					// A baked URL is already a literal, so nothing interpolates the name.
 					if (
-						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+						!baked &&
+						needsRuntimeFullHash(
+							/** @type {string} */ (
+								compilation.outputOptions.webassemblyModuleFilename
+							)
+						)
 					) {
 						set.add(RuntimeGlobals.getFullHash);
 					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmLoadingRuntimeModule({
-							generateLoadBinaryCode,
+							fullHashDigest: usesFullHashDigest(
+								/** @type {string} */ (
+									compilation.outputOptions.webassemblyModuleFilename
+								)
+							),
+							generateLoadBinaryCode: baked
+								? generateBakedLoadBinaryCode
+								: analyzable
+									? generateAnalyzableLoadBinaryCode
+									: constant === undefined
+										? generateLoadBinaryCode
+										: generateConstantLoadBinaryCode(constant),
 							supportsStreaming: true
 						})
 					);
@@ -100,16 +149,49 @@ class FetchCompileAsyncWasmPlugin {
 					) {
 						return;
 					}
-					set.add(RuntimeGlobals.publicPath);
+					const baked = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm",
+						undefined,
+						undefined,
+						chunk.runtime
+					);
+					const analyzable =
+						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					// A baked URL carries the public path already, and a settled one is written
+					// out below; only a path nothing but the global knows asks for it.
+					const constant =
+						baked || analyzable
+							? undefined
+							: compilation.runtimeTemplate.constantPublicPath();
+					if (!baked && !analyzable && constant === undefined) {
+						set.add(RuntimeGlobals.publicPath);
+					}
+					// A baked URL is already a literal, so nothing interpolates the name.
 					if (
-						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+						!baked &&
+						needsRuntimeFullHash(
+							/** @type {string} */ (
+								compilation.outputOptions.webassemblyModuleFilename
+							)
+						)
 					) {
 						set.add(RuntimeGlobals.getFullHash);
 					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmCompileRuntimeModule({
-							generateLoadBinaryCode,
+							fullHashDigest: usesFullHashDigest(
+								/** @type {string} */ (
+									compilation.outputOptions.webassemblyModuleFilename
+								)
+							),
+							generateLoadBinaryCode: baked
+								? generateBakedLoadBinaryCode
+								: analyzable
+									? generateAnalyzableLoadBinaryCode
+									: constant === undefined
+										? generateLoadBinaryCode
+										: generateConstantLoadBinaryCode(constant),
 							supportsStreaming: true
 						})
 					);

package/lib/web/FetchCompileWasmPlugin.js

@@ -7,19 +7,12 @@
 
 const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
-const { getPresentKinds } = require("../TemplatedPathPlugin");
+const { usesFullHashDigest } = require("../TemplatedPathPlugin");
+const { needsRuntimeFullHash } = require("../wasm/wasmModuleFilename");
 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");
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
 
 /**
  * Options that influence how synchronous WebAssembly modules are emitted for
@@ -68,13 +61,30 @@ class FetchCompileWasmPlugin {
 				return wasmLoading === "fetch";
 			};
 			/**
-			 * Generates the runtime expression that downloads the emitted wasm
-			 * binary for a module.
+			 * Downloads the emitted wasm binary through the runtime
+			 * `__webpack_require__.p` public path.
 			 * @param {string} path path to the wasm file
 			 * @returns {string} code to load the wasm file
 			 */
 			const generateLoadBinaryCode = (path) =>
 				`fetch(${RuntimeGlobals.publicPath} + ${path})`;
+			/**
+			 * ESM-output variant: the analyzable `fetch(new URL(path, import.meta.url))`
+			 * form (relative to the chunk, no runtime public-path global) that other
+			 * bundlers and webpack itself can statically follow to the emitted wasm.
+			 * @param {string} path path to the wasm file
+			 * @returns {string} code to load the wasm file
+			 */
+			const generateAnalyzableLoadBinaryCode = (path) =>
+				`fetch(${compilation.runtimeTemplate.importMetaUrl(path)})`;
+			/**
+			 * A public path that never changes is the same string the global would hold,
+			 * so it is inlined and the runtime module that sets it is not needed.
+			 * @param {string} constant the settled public path
+			 * @returns {(path: string) => string} code to load the wasm file
+			 */
+			const generateConstantLoadBinaryCode = (constant) => (path) =>
+				`fetch(${JSON.stringify(constant)} + ${path})`;
 
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.ensureChunkHandlers)
@@ -89,16 +99,36 @@ class FetchCompileWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.moduleCache);
-					set.add(RuntimeGlobals.publicPath);
+					const analyzable =
+						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const constant = analyzable
+						? undefined
+						: compilation.runtimeTemplate.constantPublicPath();
+					if (!analyzable && constant === undefined) {
+						set.add(RuntimeGlobals.publicPath);
+					}
 					if (
-						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+						needsRuntimeFullHash(
+							/** @type {string} */ (
+								compilation.outputOptions.webassemblyModuleFilename
+							)
+						)
 					) {
 						set.add(RuntimeGlobals.getFullHash);
 					}
 					compilation.addRuntimeModule(
 						chunk,
 						new WasmChunkLoadingRuntimeModule({
-							generateLoadBinaryCode,
+							fullHashDigest: usesFullHashDigest(
+								/** @type {string} */ (
+									compilation.outputOptions.webassemblyModuleFilename
+								)
+							),
+							generateLoadBinaryCode: analyzable
+								? generateAnalyzableLoadBinaryCode
+								: constant === undefined
+									? generateLoadBinaryCode
+									: generateConstantLoadBinaryCode(constant),
 							supportsStreaming: true,
 							mangleImports: this.options.mangleImports,
 							runtimeRequirements: set

package/lib/web/JsonpChunkLoadingPlugin.js

@@ -6,11 +6,16 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
-const JsonpChunkLoadingRuntimeModule = require("./JsonpChunkLoadingRuntimeModule");
+const lazyModule = require("../util/lazyModule");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
+/** @import { RuntimeRequirements } from "../Module" */
+
+// only a chunk that loads other chunks at runtime emits this
+const getJsonpChunkLoadingRuntimeModule = lazyModule(() =>
+	require("./JsonpChunkLoadingRuntimeModule")
+);
 
 const PLUGIN_NAME = "JsonpChunkLoadingPlugin";
 
@@ -55,28 +60,47 @@ class JsonpChunkLoadingPlugin {
 				if (onceForChunkSet.has(chunk)) return;
 				onceForChunkSet.add(chunk);
 				if (!isEnabledForChunk(chunk)) return;
-				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-				set.add(RuntimeGlobals.hasOwnProperty);
-				compilation.addRuntimeModule(
+				compilation.addLazyRuntimeModule(
 					chunk,
-					new JsonpChunkLoadingRuntimeModule(set)
+					getJsonpChunkLoadingRuntimeModule,
+					(Ctor) => new Ctor(set)
 				);
 			};
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunkHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadManifest)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.baseURI)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.onChunksLoaded)
-				.tap(PLUGIN_NAME, handler);
+			/**
+			 * Installing a chunk, on load or on a hot update, is the only part that writes
+			 * the module factories and looks a chunk id up; a base uri or `onChunksLoaded`
+			 * comes without either. Kept off `handler`, which runs once per chunk and so
+			 * cannot see which of the requirements below the chunk ends up with.
+			 * @param {Chunk} chunk chunk to check
+			 * @param {RuntimeRequirements} set runtime requirements
+			 */
+			const installHandler = (chunk, set) => {
+				if (!isEnabledForChunk(chunk)) return;
+				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+				set.add(RuntimeGlobals.hasOwnProperty);
+			};
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.hmrDownloadUpdateHandlers,
+				RuntimeGlobals.hmrDownloadManifest,
+				RuntimeGlobals.baseURI,
+				RuntimeGlobals.onChunksLoaded
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, handler);
+			}
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.chunkCallback,
+				RuntimeGlobals.hmrDownloadUpdateHandlers,
+				RuntimeGlobals.prefetchChunkHandlers,
+				RuntimeGlobals.preloadChunkHandlers
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, installHandler);
+			}
 
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.ensureChunkHandlers)

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -5,7 +5,7 @@
 "use strict";
 
 const { SyncWaterfallHook } = require("tapable");
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Compilation from "../Compilation" */
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
@@ -14,12 +14,13 @@ const {
 } = require("../hmr/JavascriptHotModuleReplacementHelper");
 const chunkHasJs = require("../javascript/JavascriptModulesPlugin").chunkHasJs;
 const { getInitialChunkIds } = require("../javascript/StartupHelpers");
+const { renderBaseUri } = require("../runtime/baseUri");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const createHooksRegistry = require("../util/createHooksRegistry");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import { ReadOnlyRuntimeRequirements } from "../Module" */
 
 /**
  * @typedef {object} JsonpCompilationPluginHooks
@@ -44,10 +45,10 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 	 */
 	_generateBaseUri(chunk) {
 		const options = chunk.getEntryOptions();
-		if (options && options.baseUri) {
-			return `${RuntimeGlobals.baseURI} = ${JSON.stringify(options.baseUri)};`;
-		}
-		return `${RuntimeGlobals.baseURI} = (typeof document !== 'undefined' && document.baseURI) || self.location.href;`;
+		return renderBaseUri(
+			options ? options.baseUri : undefined,
+			"(typeof document !== 'undefined' && document.baseURI) || self.location.href"
+		);
 	}
 
 	/**
@@ -63,9 +64,11 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 				hotUpdateGlobal,
 				crossOriginLoading,
 				scriptType,
-				charset
+				charset,
+				resourceHints
 			}
 		} = compilation;
+		const dedupePrefetch = Boolean(resourceHints && resourceHints.dedupe);
 		const globalObject = runtimeTemplate.globalObject;
 		const { linkPreload, linkPrefetch } =
 			JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
@@ -115,17 +118,33 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 				",\n"
 			)
 		)}\n}`;
+		// Every part below that reads the table. A chunk asking only for `.b` gets this
+		// module for the base uri alone, and then has nothing to look up.
+		const withInstalledChunks =
+			withLoading ||
+			withCallback ||
+			withOnChunkLoad ||
+			withHmr ||
+			withPrefetch ||
+			withPreload;
 		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",
-			`${cst} installedChunks = ${
-				stateExpression
-					? runtimeTemplate.assignOr(stateExpression, installedChunksObject)
-					: installedChunksObject
-			};`,
+			withInstalledChunks
+				? Template.asString([
+						"// object to store loaded and loading chunks",
+						"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
+						"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
+						`${cst} installedChunks = ${
+							stateExpression
+								? runtimeTemplate.assignOr(
+										stateExpression,
+										installedChunksObject
+									)
+								: installedChunksObject
+						};`
+					])
+				: "// no installed chunks",
 			"",
 			withLoading
 				? Template.asString([
@@ -156,8 +175,6 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 													)});`,
 													"promises.push(installedChunkData[2] = promise);",
 													"",
-													"// start chunk loading",
-													`${cst} url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
 													"// create error before stack unwound to get useful stacktrace later",
 													`${cst} error = new Error();`,
 													`${cst} loadingEnded = ${runtimeTemplate.basicFunction(
@@ -185,7 +202,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 													)};`,
 													`${
 														RuntimeGlobals.loadScript
-													}(url, loadingEnded, "chunk-" + chunkId, chunkId${
+													}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId), loadingEnded, "chunk-" + chunkId, chunkId${
 														withFetchPriority ? ", fetchPriority" : ""
 													});`
 												]),
@@ -233,6 +250,19 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 								]),
 								chunk
 							),
+							dedupePrefetch
+								? Template.asString([
+										// Chrome re-requests a resource when a prefetch link is added
+										// after it was already (pre)loaded via markup; skip in that case.
+										`${cst} links = document.getElementsByTagName("link");`,
+										`for(${lt} i = 0; i < links.length; i++) {`,
+										Template.indent([
+											`${cst} l = links[i];`,
+											'if(l.href === link.href && (l.rel === "prefetch" || l.rel === "preload" || l.rel === "modulepreload")) return;'
+										]),
+										"}"
+									])
+								: "",
 							"document.head.appendChild(link);"
 						]),
 						"}"

package/lib/web/JsonpTemplatePlugin.js

@@ -9,8 +9,8 @@ const ArrayPushCallbackChunkFormatPlugin = require("../javascript/ArrayPushCallb
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 const JsonpChunkLoadingRuntimeModule = require("./JsonpChunkLoadingRuntimeModule");
 
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Compilation from "../Compilation" */
+/** @import Compiler from "../Compiler" */
 
 // TODO webpack 6 remove this class
 class JsonpTemplatePlugin {

package/lib/webpack.js

@@ -11,7 +11,6 @@ const webpackOptionsSchema =
 	/** @type {EXPECTED_ANY} */
 	(require("../schemas/WebpackOptions.json"));
 const Compiler = require("./Compiler");
-const MultiCompiler = require("./MultiCompiler");
 const WebpackOptionsApply = require("./WebpackOptionsApply");
 const {
 	applyWebpackOptionsBaseDefaults,
@@ -24,20 +23,31 @@ const {
 const NodeEnvironmentPlugin = require("./node/NodeEnvironmentPlugin");
 const memoize = require("./util/memoize");
 
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
-/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptionsNormalizedWithDefaults */
-/** @typedef {import("./config/normalization").WebpackOptionsInterception} WebpackOptionsInterception */
-/** @typedef {import("./Compiler").WatchOptions} WatchOptions */
-/** @typedef {import("./MultiCompiler").MultiCompilerOptions} MultiCompilerOptions */
-/** @typedef {import("./MultiCompiler").MultiWebpackOptions} MultiWebpackOptions */
-/** @typedef {import("./MultiStats")} MultiStats */
-/** @typedef {import("./Stats")} Stats */
+const getValidateSchema = memoize(() => require("./validateSchema"));
+const getMultiCompiler = memoize(() => require("./MultiCompiler"));
+const getProgressPlugin = memoize(() => require("./ProgressPlugin"));
+
+/**
+ * @import {
+ * 	WebpackOptions,
+ * 	WatchOptions
+ * } from "../declarations/WebpackOptions"
+ */
+/** @import { WebpackOptionsNormalizedWithDefaults } from "./config/defaults" */
+/** @import { WebpackOptionsInterception } from "./config/normalization" */
+/**
+ * @import MultiCompiler, {
+ * 	MultiCompilerOptions,
+ * 	MultiWebpackOptions
+ * } from "./MultiCompiler"
+ */
+/** @import MultiStats from "./MultiStats" */
+/** @import Stats from "./Stats" */
 
 /** @typedef {(this: Compiler, compiler: Compiler) => void} WebpackPluginFunction */
 /** @typedef {(compiler: Compiler) => void} WebpackPluginInstanceApplyFunction */
 
-const getValidateSchema = memoize(() => require("./validateSchema"));
-const getProgressPlugin = memoize(() => require("./ProgressPlugin"));
+// only an array config reaches the multi compiler
 
 /**
  * Whether core should auto-apply progress, from `infrastructureLogging.progress`.
@@ -102,6 +112,7 @@ const applyDefaultProgressPlugin = (compiler, options, hasUserPlugin) => {
  * @returns {MultiCompiler} a multi-compiler
  */
 const createMultiCompiler = (childOptions, options) => {
+	const MultiCompiler = getMultiCompiler();
 	const compilers = childOptions.map((options, index) =>
 		createCompiler(options, index)
 	);

package/lib/webworker/ImportScriptsChunkLoadingPlugin.js

@@ -7,11 +7,16 @@
 
 const RuntimeGlobals = require("../RuntimeGlobals");
 const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenciesPlugin");
-const ImportScriptsChunkLoadingRuntimeModule = require("./ImportScriptsChunkLoadingRuntimeModule");
+const lazyModule = require("../util/lazyModule");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
+/** @import { RuntimeRequirements } from "../Module" */
+
+// only a chunk that loads other chunks at runtime emits this
+const getImportScriptsChunkLoadingRuntimeModule = lazyModule(() =>
+	require("./ImportScriptsChunkLoadingRuntimeModule")
+);
 
 const PLUGIN_NAME = "ImportScriptsChunkLoadingPlugin";
 
@@ -62,31 +67,60 @@ class ImportScriptsChunkLoadingPlugin {
 				const withCreateScriptUrl = Boolean(
 					compilation.outputOptions.trustedTypes
 				);
-				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-				set.add(RuntimeGlobals.hasOwnProperty);
-				if (withCreateScriptUrl) {
-					set.add(RuntimeGlobals.createScriptUrl);
-				}
-				compilation.addRuntimeModule(
+				compilation.addLazyRuntimeModule(
 					chunk,
-					new ImportScriptsChunkLoadingRuntimeModule(set, withCreateScriptUrl)
+					getImportScriptsChunkLoadingRuntimeModule,
+					(Ctor) => new Ctor(set, withCreateScriptUrl)
 				);
 			};
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunkHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadManifest)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.baseURI)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.onChunksLoaded)
-				.tap(PLUGIN_NAME, handler);
+			/**
+			 * Installing a chunk is the only part that writes the module factories and
+			 * looks a chunk id up; a base uri or `onChunksLoaded` comes without either.
+			 * Kept off `handler`, which runs once per chunk and so cannot see which of the
+			 * requirements below the chunk ends up with.
+			 * @param {Chunk} chunk chunk
+			 * @param {RuntimeRequirements} set runtime requirements
+			 */
+			const installHandler = (chunk, set) => {
+				if (!isEnabledForChunk(chunk)) return;
+				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+				set.add(RuntimeGlobals.hasOwnProperty);
+			};
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.hmrDownloadUpdateHandlers,
+				RuntimeGlobals.hmrDownloadManifest,
+				RuntimeGlobals.baseURI,
+				RuntimeGlobals.onChunksLoaded
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, handler);
+			}
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.chunkCallback,
+				RuntimeGlobals.hmrDownloadUpdateHandlers
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, installHandler);
+			}
+			// Both `importScripts` calls the module emits — loading a chunk and loading a
+			// hot update — are wrapped under trusted types.
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.hmrDownloadUpdateHandlers
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						if (compilation.outputOptions.trustedTypes) {
+							set.add(RuntimeGlobals.createScriptUrl);
+						}
+					});
+			}
 
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.ensureChunkHandlers)