webpack 5.59.0 → 5.94.0

package/lib/web/FetchCompileWasmPlugin.js

@@ -5,16 +5,28 @@
 
 "use strict";
 
+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;
 	}
 
 	/**
@@ -23,48 +35,53 @@ class FetchCompileWasmPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"FetchCompileWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === "fetch";
-				};
-				const generateLoadBinaryCode = path =>
-					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
+		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 =
+					options && options.wasmLoading !== undefined
+						? options.wasmLoading
+						: 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})`;
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("FetchCompileWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === "webassembly/sync"
-							)
-						) {
-							return;
-						}
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.publicPath);
-						compilation.addRuntimeModule(
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkHandlers)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					const chunkGraph = compilation.chunkGraph;
+					if (
+						!chunkGraph.hasModuleInGraph(
 							chunk,
-							new WasmChunkLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: true,
-								mangleImports: this.options.mangleImports,
-								runtimeRequirements: set
-							})
-						);
-					});
-			}
-		);
+							m => m.type === WEBASSEMBLY_MODULE_TYPE_SYNC
+						)
+					) {
+						return;
+					}
+					set.add(RuntimeGlobals.moduleCache);
+					set.add(RuntimeGlobals.publicPath);
+					compilation.addRuntimeModule(
+						chunk,
+						new WasmChunkLoadingRuntimeModule({
+							generateLoadBinaryCode,
+							supportsStreaming: true,
+							mangleImports: this.options.mangleImports,
+							runtimeRequirements: set
+						})
+					);
+				});
+		});
 	}
 }
 

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

@@ -14,9 +14,11 @@ const { getInitialChunkIds } = require("../javascript/StartupHelpers");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
 /**
- * @typedef {Object} JsonpCompilationPluginHooks
+ * @typedef {object} JsonpCompilationPluginHooks
  * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
  * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
  */
@@ -46,26 +48,42 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 		return hooks;
 	}
 
+	/**
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
+	 */
 	constructor(runtimeRequirements) {
 		super("jsonp chunk loading", RuntimeModule.STAGE_ATTACH);
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @private
+	 * @param {Chunk} chunk chunk
+	 * @returns {string} generated code
+	 */
+	_generateBaseUri(chunk) {
+		const options = chunk.getEntryOptions();
+		if (options && options.baseUri) {
+			return `${RuntimeGlobals.baseURI} = ${JSON.stringify(options.baseUri)};`;
+		}
+		return `${RuntimeGlobals.baseURI} = document.baseURI || self.location.href;`;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunkGraph, compilation, chunk } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const {
 			runtimeTemplate,
 			outputOptions: {
-				globalObject,
 				chunkLoadingGlobal,
 				hotUpdateGlobal,
 				crossOriginLoading,
 				scriptType
 			}
 		} = compilation;
+		const globalObject = runtimeTemplate.globalObject;
 		const { linkPreload, linkPrefetch } =
 			JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
 		const fn = RuntimeGlobals.ensureChunkHandlers;
@@ -91,23 +109,24 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 		const withPreload = this._runtimeRequirements.has(
 			RuntimeGlobals.preloadChunkHandlers
 		);
+		const withFetchPriority = this._runtimeRequirements.has(
+			RuntimeGlobals.hasFetchPriority
+		);
 		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
 			chunkLoadingGlobal
 		)}]`;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
 		const stateExpression = withHmr
 			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_jsonp`
 			: undefined;
 
 		return Template.asString([
-			withBaseURI
-				? Template.asString([
-						`${RuntimeGlobals.baseURI} = document.baseURI || self.location.href;`
-				  ])
-				: "// no baseURI",
+			withBaseURI ? this._generateBaseUri(chunk) : "// no baseURI",
 			"",
 			"// object to store loaded and loading chunks",
 			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
@@ -125,7 +144,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 			withLoading
 				? Template.asString([
 						`${fn}.j = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
+							`chunkId, promises${withFetchPriority ? ", fetchPriority" : ""}`,
 							hasJsMatcher !== false
 								? Template.indent([
 										"// JSONP chunk loading for javascript",
@@ -146,7 +165,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 												Template.indent([
 													"// setup Promise in chunk cache",
 													`var promise = new Promise(${runtimeTemplate.expressionFunction(
-														`installedChunkData = installedChunks[chunkId] = [resolve, reject]`,
+														"installedChunkData = installedChunks[chunkId] = [resolve, reject]",
 														"resolve, reject"
 													)});`,
 													"promises.push(installedChunkData[2] = promise);",
@@ -177,23 +196,29 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 															"}"
 														]
 													)};`,
-													`${RuntimeGlobals.loadScript}(url, loadingEnded, "chunk-" + chunkId, chunkId);`
+													`${
+														RuntimeGlobals.loadScript
+													}(url, loadingEnded, "chunk-" + chunkId, chunkId${
+														withFetchPriority ? ", fetchPriority" : ""
+													});`
 												]),
-												"} else installedChunks[chunkId] = 0;"
+												hasJsMatcher === true
+													? "}"
+													: "} else installedChunks[chunkId] = 0;"
 											]),
 											"}"
 										]),
 										"}"
-								  ])
+									])
 								: Template.indent(["installedChunks[chunkId] = 0;"])
 						)};`
-				  ])
+					])
 				: "// no chunk on demand loading",
 			"",
 			withPrefetch && hasJsMatcher !== false
 				? `${
 						RuntimeGlobals.prefetchChunkHandlers
-				  }.j = ${runtimeTemplate.basicFunction("chunkId", [
+					}.j = ${runtimeTemplate.basicFunction("chunkId", [
 						`if((!${
 							RuntimeGlobals.hasOwnProperty
 						}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${
@@ -207,7 +232,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 									crossOriginLoading
 										? `link.crossOrigin = ${JSON.stringify(
 												crossOriginLoading
-										  )};`
+											)};`
 										: "",
 									`if (${RuntimeGlobals.scriptNonce}) {`,
 									Template.indent(
@@ -223,13 +248,13 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 							"document.head.appendChild(link);"
 						]),
 						"}"
-				  ])};`
+					])};`
 				: "// no prefetching",
 			"",
 			withPreload && hasJsMatcher !== false
 				? `${
 						RuntimeGlobals.preloadChunkHandlers
-				  }.j = ${runtimeTemplate.basicFunction("chunkId", [
+					}.j = ${runtimeTemplate.basicFunction("chunkId", [
 						`if((!${
 							RuntimeGlobals.hasOwnProperty
 						}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${
@@ -240,7 +265,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 							linkPreload.call(
 								Template.asString([
 									"var link = document.createElement('link');",
-									scriptType
+									scriptType && scriptType !== "module"
 										? `link.type = ${JSON.stringify(scriptType)};`
 										: "",
 									"link.charset = 'utf-8';",
@@ -249,19 +274,23 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 										`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
 									),
 									"}",
-									'link.rel = "preload";',
-									'link.as = "script";',
+									scriptType === "module"
+										? 'link.rel = "modulepreload";'
+										: 'link.rel = "preload";',
+									scriptType === "module" ? "" : 'link.as = "script";',
 									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
 									crossOriginLoading
-										? Template.asString([
-												"if (link.href.indexOf(window.location.origin + '/') !== 0) {",
-												Template.indent(
-													`link.crossOrigin = ${JSON.stringify(
-														crossOriginLoading
-													)};`
-												),
-												"}"
-										  ])
+										? crossOriginLoading === "use-credentials"
+											? 'link.crossOrigin = "use-credentials";'
+											: Template.asString([
+													"if (link.href.indexOf(window.location.origin + '/') !== 0) {",
+													Template.indent(
+														`link.crossOrigin = ${JSON.stringify(
+															crossOriginLoading
+														)};`
+													),
+													"}"
+												])
 										: ""
 								]),
 								chunk
@@ -269,15 +298,16 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 							"document.head.appendChild(link);"
 						]),
 						"}"
-				  ])};`
+					])};`
 				: "// no preloaded",
 			"",
 			withHmr
 				? Template.asString([
 						"var currentUpdatedModulesList;",
 						"var waitingUpdateResolves = {};",
-						"function loadUpdateChunk(chunkId) {",
+						"function loadUpdateChunk(chunkId, updatedModulesList) {",
 						Template.indent([
+							"currentUpdatedModulesList = updatedModulesList;",
 							`return new Promise(${runtimeTemplate.basicFunction(
 								"resolve, reject",
 								[
@@ -353,7 +383,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 								/\$hmrInvalidateModuleHandlers\$/g,
 								RuntimeGlobals.hmrInvalidateModuleHandlers
 							)
-				  ])
+					])
 				: "// no HMR",
 			"",
 			withHmrManifest
@@ -370,16 +400,16 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 								"return response.json();"
 							])});`
 						])};`
-				  ])
+					])
 				: "// no HMR manifest",
 			"",
 			withOnChunkLoad
 				? `${
 						RuntimeGlobals.onChunksLoaded
-				  }.j = ${runtimeTemplate.returningFunction(
+					}.j = ${runtimeTemplate.returningFunction(
 						"installedChunks[chunkId] === 0",
 						"chunkId"
-				  )};`
+					)};`
 				: "// no on chunks loaded",
 			"",
 			withCallback || withLoading
@@ -409,7 +439,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 										"}"
 									]),
 									"}",
-									"if(runtime) var result = runtime(__webpack_require__);"
+									`if(runtime) var result = runtime(${RuntimeGlobals.require});`
 								]),
 								"}",
 								"if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);",
@@ -419,7 +449,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 									`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
 									Template.indent("installedChunks[chunkId][0]();"),
 									"}",
-									"installedChunks[chunkIds[i]] = 0;"
+									"installedChunks[chunkId] = 0;"
 								]),
 								"}",
 								withOnChunkLoad
@@ -431,7 +461,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 						`var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
 						"chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));",
 						"chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));"
-				  ])
+					])
 				: "// no jsonp function"
 		]);
 	}

package/lib/webpack.js

@@ -20,6 +20,7 @@ const NodeEnvironmentPlugin = require("./node/NodeEnvironmentPlugin");
 const memoize = require("./util/memoize");
 
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
 /** @typedef {import("./Compiler").WatchOptions} WatchOptions */
 /** @typedef {import("./MultiCompiler").MultiCompilerOptions} MultiCompilerOptions */
 /** @typedef {import("./MultiStats")} MultiStats */
@@ -30,7 +31,7 @@ const getValidateSchema = memoize(() => require("./validateSchema"));
 /**
  * @template T
  * @callback Callback
- * @param {Error=} err
+ * @param {Error | null} err
  * @param {T=} stats
  * @returns {void}
  */
@@ -41,7 +42,9 @@ const getValidateSchema = memoize(() => require("./validateSchema"));
  * @returns {MultiCompiler} a multi-compiler
  */
 const createMultiCompiler = (childOptions, options) => {
-	const compilers = childOptions.map(options => createCompiler(options));
+	const compilers = childOptions.map((options, index) =>
+		createCompiler(options, index)
+	);
 	const compiler = new MultiCompiler(compilers, options);
 	for (const childCompiler of compilers) {
 		if (childCompiler.options.dependencies) {
@@ -56,26 +59,36 @@ const createMultiCompiler = (childOptions, options) => {
 
 /**
  * @param {WebpackOptions} rawOptions options object
+ * @param {number} [compilerIndex] index of compiler
  * @returns {Compiler} a compiler
  */
-const createCompiler = rawOptions => {
+const createCompiler = (rawOptions, compilerIndex) => {
 	const options = getNormalizedWebpackOptions(rawOptions);
 	applyWebpackOptionsBaseDefaults(options);
-	const compiler = new Compiler(options.context);
-	compiler.options = options;
+	const compiler = new Compiler(
+		/** @type {string} */ (options.context),
+		options
+	);
 	new NodeEnvironmentPlugin({
 		infrastructureLogging: options.infrastructureLogging
 	}).apply(compiler);
 	if (Array.isArray(options.plugins)) {
 		for (const plugin of options.plugins) {
 			if (typeof plugin === "function") {
-				plugin.call(compiler, compiler);
-			} else {
+				/** @type {WebpackPluginFunction} */
+				(plugin).call(compiler, compiler);
+			} else if (plugin) {
 				plugin.apply(compiler);
 			}
 		}
 	}
-	applyWebpackOptionsDefaults(options);
+	const resolvedDefaultOptions = applyWebpackOptionsDefaults(
+		options,
+		compilerIndex
+	);
+	if (resolvedDefaultOptions.platform) {
+		compiler.platform = resolvedDefaultOptions.platform;
+	}
 	compiler.hooks.environment.call();
 	compiler.hooks.afterEnvironment.call();
 	new WebpackOptionsApply().process(options, compiler);
@@ -97,19 +110,33 @@ const createCompiler = rawOptions => {
  * @returns {MultiCompiler} the multi compiler object
  */
 
+/**
+ * @template T
+ * @param {Array<T> | T} options options
+ * @returns {Array<T>} array of options
+ */
+const asArray = options =>
+	Array.isArray(options) ? Array.from(options) : [options];
+
 const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
 	/**
 	 * @param {WebpackOptions | (ReadonlyArray<WebpackOptions> & MultiCompilerOptions)} options options
 	 * @param {Callback<Stats> & Callback<MultiStats>=} callback callback
-	 * @returns {Compiler | MultiCompiler}
+	 * @returns {Compiler | MultiCompiler | null} Compiler or MultiCompiler
 	 */
 	(options, callback) => {
 		const create = () => {
-			if (!webpackOptionsSchemaCheck(options)) {
+			if (!asArray(options).every(webpackOptionsSchemaCheck)) {
 				getValidateSchema()(webpackOptionsSchema, options);
+				util.deprecate(
+					() => {},
+					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
+					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
+				)();
 			}
 			/** @type {MultiCompiler|Compiler} */
 			let compiler;
+			/** @type {boolean | undefined} */
 			let watch = false;
 			/** @type {WatchOptions|WatchOptions[]} */
 			let watchOptions;
@@ -138,13 +165,17 @@ const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
 				} else {
 					compiler.run((err, stats) => {
 						compiler.close(err2 => {
-							callback(err || err2, stats);
+							callback(
+								err || err2,
+								/** @type {options extends WebpackOptions ? Stats : MultiStats} */
+								(stats)
+							);
 						});
 					});
 				}
 				return compiler;
 			} catch (err) {
-				process.nextTick(() => callback(err));
+				process.nextTick(() => callback(/** @type {Error} */ (err)));
 				return null;
 			}
 		} else {

package/lib/webworker/ImportScriptsChunkLoadingPlugin.js

@@ -6,10 +6,10 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
-const CreateScriptUrlRuntimeModule = require("../runtime/CreateScriptUrlRuntimeModule");
 const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenciesPlugin");
 const ImportScriptsChunkLoadingRuntimeModule = require("./ImportScriptsChunkLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 class ImportScriptsChunkLoadingPlugin {
@@ -27,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 =
@@ -36,14 +40,22 @@ 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);
 					if (!isEnabledForChunk(chunk)) return;
-					const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
+					const withCreateScriptUrl = Boolean(
+						compilation.outputOptions.trustedTypes
+					);
 					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
 					set.add(RuntimeGlobals.hasOwnProperty);
-					if (withCreateScriptUrl) set.add(RuntimeGlobals.createScriptUrl);
+					if (withCreateScriptUrl) {
+						set.add(RuntimeGlobals.createScriptUrl);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new ImportScriptsChunkLoadingRuntimeModule(set, withCreateScriptUrl)
@@ -61,15 +73,6 @@ class ImportScriptsChunkLoadingPlugin {
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.baseURI)
 					.tap("ImportScriptsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.createScriptUrl)
-					.tap("RuntimePlugin", (chunk, set) => {
-						compilation.addRuntimeModule(
-							chunk,
-							new CreateScriptUrlRuntimeModule()
-						);
-						return true;
-					});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.ensureChunkHandlers)