webpack 5.36.0 → 5.37.1

package/lib/stats/StatsFactory.js

@@ -71,7 +71,8 @@ class StatsFactory {
 			getItemFactory: new HookMap(() => new SyncBailHook(["item", "context"]))
 		});
 		const hooks = this.hooks;
-		this._caches = /** @type {Record<keyof typeof hooks, Map<string, SyncBailHook<[any[], StatsFactoryContext]>[]>>} */ ({});
+		this._caches =
+			/** @type {Record<keyof typeof hooks, Map<string, SyncBailHook<[any[], StatsFactoryContext]>[]>>} */ ({});
 		for (const key of Object.keys(hooks)) {
 			this._caches[key] = new Map();
 		}

package/lib/stats/StatsPrinter.js

@@ -87,9 +87,9 @@ class StatsPrinter {
 	 * @returns {T[]} hooks
 	 */
 	_getAllLevelHooks(hookMap, type) {
-		let cache = /** @type {Map<string, T[]>} */ (this._levelHookCache.get(
-			hookMap
-		));
+		let cache = /** @type {Map<string, T[]>} */ (
+			this._levelHookCache.get(hookMap)
+		);
 		if (cache === undefined) {
 			cache = new Map();
 			this._levelHookCache.set(hookMap, cache);

package/lib/util/LazyBucketSortedSet.js

@@ -164,9 +164,9 @@ class LazyBucketSortedSet {
 				}
 			};
 		} else {
-			const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (this._map.get(
-				key
-			));
+			const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (
+				this._map.get(key)
+			);
 			const finishUpdate = oldEntry.startUpdate(item);
 			return remove => {
 				if (remove) {

package/lib/util/cleverMerge.js

@@ -539,7 +539,9 @@ const resolveByProperty = (obj, byProperty, ...values) => {
 	}
 	const { [byProperty]: _byValue, ..._remaining } = /** @type {object} */ (obj);
 	const remaining = /** @type {T} */ (_remaining);
-	const byValue = /** @type {Record<string, T> | function(...any[]): T} */ (_byValue);
+	const byValue = /** @type {Record<string, T> | function(...any[]): T} */ (
+		_byValue
+	);
 	if (typeof byValue === "object") {
 		const key = values[0];
 		if (key in byValue) {

package/lib/util/comparators.js

@@ -68,9 +68,8 @@ const compareModulesById = (chunkGraph, a, b) => {
 	return compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
 };
 /** @type {ParameterizedComparator<ChunkGraph, Module>} */
-exports.compareModulesById = createCachedParameterizedComparator(
-	compareModulesById
-);
+exports.compareModulesById =
+	createCachedParameterizedComparator(compareModulesById);
 
 /**
  * @param {number} a number
@@ -138,9 +137,10 @@ const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	return compareIds(a.identifier(), b.identifier());
 };
 /** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPostOrderIndexOrIdentifier = createCachedParameterizedComparator(
-	compareModulesByPostOrderIndexOrIdentifier
-);
+exports.compareModulesByPostOrderIndexOrIdentifier =
+	createCachedParameterizedComparator(
+		compareModulesByPostOrderIndexOrIdentifier
+	);
 
 /**
  * @param {ModuleGraph} moduleGraph the module graph
@@ -157,9 +157,10 @@ const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	return compareIds(a.identifier(), b.identifier());
 };
 /** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPreOrderIndexOrIdentifier = createCachedParameterizedComparator(
-	compareModulesByPreOrderIndexOrIdentifier
-);
+exports.compareModulesByPreOrderIndexOrIdentifier =
+	createCachedParameterizedComparator(
+		compareModulesByPreOrderIndexOrIdentifier
+	);
 
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
@@ -284,10 +285,9 @@ const concatComparators = (c1, c2, ...cRest) => {
 		const [c3, ...cRest2] = cRest;
 		return concatComparators(c1, concatComparators(c2, c3, ...cRest2));
 	}
-	const cacheEntry = /** @type {Comparator<T>} */ (concatComparatorsCache.get(
-		c1,
-		c2
-	));
+	const cacheEntry = /** @type {Comparator<T>} */ (
+		concatComparatorsCache.get(c1, c2)
+	);
 	if (cacheEntry !== undefined) return cacheEntry;
 	/**
 	 * @param {T} a first value

package/lib/util/fs.js

@@ -51,14 +51,14 @@ const path = require("path");
  * @property {string | Buffer} name
  */
 
-/** @typedef {function(NodeJS.ErrnoException=): void} Callback */
-/** @typedef {function(NodeJS.ErrnoException=, Buffer=): void} BufferCallback */
-/** @typedef {function(NodeJS.ErrnoException=, Buffer|string=): void} BufferOrStringCallback */
-/** @typedef {function(NodeJS.ErrnoException=, (string | Buffer)[] | IDirent[]=): void} DirentArrayCallback */
-/** @typedef {function(NodeJS.ErrnoException=, string=): void} StringCallback */
-/** @typedef {function(NodeJS.ErrnoException=, number=): void} NumberCallback */
-/** @typedef {function(NodeJS.ErrnoException=, IStats=): void} StatsCallback */
-/** @typedef {function((NodeJS.ErrnoException | Error)=, any=): void} ReadJsonCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=): void} Callback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer=): void} BufferCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer|string=): void} BufferOrStringCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, (string | Buffer)[] | IDirent[]=): void} DirentArrayCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, string=): void} StringCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, number=): void} NumberCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, IStats=): void} StatsCallback */
+/** @typedef {function((NodeJS.ErrnoException | Error | null)=, any=): void} ReadJsonCallback */
 
 /**
  * @typedef {Object} Watcher

package/lib/util/identifier.js

@@ -244,7 +244,8 @@ const _absolutify = (context, request) => {
 const absolutify = makeCacheable(_absolutify);
 exports.absolutify = absolutify;
 
-const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+const PATH_QUERY_FRAGMENT_REGEXP =
+	/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
 
 /** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
 

package/lib/util/internalSerializables.js

@@ -45,6 +45,8 @@ module.exports = {
 		require("../dependencies/AMDRequireItemDependency"),
 	"dependencies/CachedConstDependency": () =>
 		require("../dependencies/CachedConstDependency"),
+	"dependencies/CreateScriptUrlDependency": () =>
+		require("../dependencies/CreateScriptUrlDependency"),
 	"dependencies/CommonJsRequireContextDependency": () =>
 		require("../dependencies/CommonJsRequireContextDependency"),
 	"dependencies/CommonJsExportRequireDependency": () =>

package/lib/validateSchema.js

@@ -21,8 +21,7 @@ const DID_YOU_MEAN = {
 		"output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
 	ecmaversion:
 		"output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
-	ecma:
-		"output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
+	ecma: "output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
 	path: "output.path",
 	pathinfo: "output.pathinfo",
 	pathInfo: "output.pathinfo",
@@ -109,7 +108,10 @@ const validateSchema = (schema, options, validationConfiguration) => {
 				}
 
 				if (error.keyword === "additionalProperties") {
-					const params = /** @type {import("ajv").AdditionalPropertiesParams} */ (error.params);
+					const params =
+						/** @type {import("ajv").AdditionalPropertiesParams} */ (
+							error.params
+						);
 					if (
 						Object.prototype.hasOwnProperty.call(
 							DID_YOU_MEAN,

package/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -91,9 +91,8 @@ class AsyncWebAssemblyModulesPlugin {
 		compiler.hooks.compilation.tap(
 			"AsyncWebAssemblyModulesPlugin",
 			(compilation, { normalModuleFactory }) => {
-				const hooks = AsyncWebAssemblyModulesPlugin.getCompilationHooks(
-					compilation
-				);
+				const hooks =
+					AsyncWebAssemblyModulesPlugin.getCompilationHooks(compilation);
 				compilation.dependencyFactories.set(
 					WebAssemblyImportDependency,
 					normalModuleFactory
@@ -109,7 +108,8 @@ class AsyncWebAssemblyModulesPlugin {
 				normalModuleFactory.hooks.createGenerator
 					.for("webassembly/async")
 					.tap("AsyncWebAssemblyModulesPlugin", () => {
-						const AsyncWebAssemblyJavascriptGenerator = getAsyncWebAssemblyJavascriptGenerator();
+						const AsyncWebAssemblyJavascriptGenerator =
+							getAsyncWebAssemblyJavascriptGenerator();
 						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
 
 						return Generator.byType({

package/lib/wasm-sync/WasmFinalizeExportsPlugin.js

@@ -40,10 +40,11 @@ class WasmFinalizeExportsPlugin {
 									connection.originModule.type.startsWith("webassembly") ===
 										false
 								) {
-									const referencedExports = compilation.getDependencyReferencedExports(
-										connection.dependency,
-										undefined
-									);
+									const referencedExports =
+										compilation.getDependencyReferencedExports(
+											connection.dependency,
+											undefined
+										);
 
 									for (const info of referencedExports) {
 										const names = Array.isArray(info) ? info : info.name;

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -240,31 +240,27 @@ const rewriteImportedGlobals = state => bin => {
  * @param {RuntimeSpec} state.runtime runtime
  * @returns {ArrayBufferTransform} transform
  */
-const rewriteExportNames = ({
-	ast,
-	moduleGraph,
-	module,
-	externalExports,
-	runtime
-}) => bin => {
-	return editWithAST(ast, bin, {
-		ModuleExport(path) {
-			const isExternal = externalExports.has(path.node.name);
-			if (isExternal) {
-				path.remove();
-				return;
-			}
-			const usedName = moduleGraph
-				.getExportsInfo(module)
-				.getUsedName(path.node.name, runtime);
-			if (!usedName) {
-				path.remove();
-				return;
+const rewriteExportNames =
+	({ ast, moduleGraph, module, externalExports, runtime }) =>
+	bin => {
+		return editWithAST(ast, bin, {
+			ModuleExport(path) {
+				const isExternal = externalExports.has(path.node.name);
+				if (isExternal) {
+					path.remove();
+					return;
+				}
+				const usedName = moduleGraph
+					.getExportsInfo(module)
+					.getUsedName(path.node.name, runtime);
+				if (!usedName) {
+					path.remove();
+					return;
+				}
+				path.node.name = usedName;
 			}
-			path.node.name = usedName;
-		}
-	});
-};
+		});
+	};
 
 /**
  * Mangle import names and modules
@@ -273,20 +269,22 @@ const rewriteExportNames = ({
  * @param {Map<string, UsedWasmDependency>} state.usedDependencyMap mappings to mangle names
  * @returns {ArrayBufferTransform} transform
  */
-const rewriteImports = ({ ast, usedDependencyMap }) => bin => {
-	return editWithAST(ast, bin, {
-		ModuleImport(path) {
-			const result = usedDependencyMap.get(
-				path.node.module + ":" + path.node.name
-			);
+const rewriteImports =
+	({ ast, usedDependencyMap }) =>
+	bin => {
+		return editWithAST(ast, bin, {
+			ModuleImport(path) {
+				const result = usedDependencyMap.get(
+					path.node.module + ":" + path.node.name
+				);
 
-			if (result !== undefined) {
-				path.node.module = result.module;
-				path.node.name = result.name;
+				if (result !== undefined) {
+					path.node.module = result.module;
+					path.node.name = result.name;
+				}
 			}
-		}
-	});
-};
+		});
+	};
 
 /**
  * Add an init function.
@@ -303,63 +301,69 @@ const rewriteImports = ({ ast, usedDependencyMap }) => bin => {
  * @param {t.Index} state.nextTypeIndex index of the next type
  * @returns {ArrayBufferTransform} transform
  */
-const addInitFunction = ({
-	ast,
-	initFuncId,
-	startAtFuncOffset,
-	importedGlobals,
-	additionalInitCode,
-	nextFuncIndex,
-	nextTypeIndex
-}) => bin => {
-	const funcParams = importedGlobals.map(importedGlobal => {
-		// used for debugging
-		const id = t.identifier(`${importedGlobal.module}.${importedGlobal.name}`);
-
-		return t.funcParam(importedGlobal.descr.valtype, id);
-	});
+const addInitFunction =
+	({
+		ast,
+		initFuncId,
+		startAtFuncOffset,
+		importedGlobals,
+		additionalInitCode,
+		nextFuncIndex,
+		nextTypeIndex
+	}) =>
+	bin => {
+		const funcParams = importedGlobals.map(importedGlobal => {
+			// used for debugging
+			const id = t.identifier(
+				`${importedGlobal.module}.${importedGlobal.name}`
+			);
 
-	const funcBody = [];
-	importedGlobals.forEach((importedGlobal, index) => {
-		const args = [t.indexLiteral(index)];
-		const body = [
-			t.instruction("get_local", args),
-			t.instruction("set_global", args)
-		];
+			return t.funcParam(importedGlobal.descr.valtype, id);
+		});
 
-		funcBody.push(...body);
-	});
+		const funcBody = [];
+		importedGlobals.forEach((importedGlobal, index) => {
+			const args = [t.indexLiteral(index)];
+			const body = [
+				t.instruction("get_local", args),
+				t.instruction("set_global", args)
+			];
 
-	if (typeof startAtFuncOffset === "number") {
-		funcBody.push(t.callInstruction(t.numberLiteralFromRaw(startAtFuncOffset)));
-	}
+			funcBody.push(...body);
+		});
 
-	for (const instr of additionalInitCode) {
-		funcBody.push(instr);
-	}
+		if (typeof startAtFuncOffset === "number") {
+			funcBody.push(
+				t.callInstruction(t.numberLiteralFromRaw(startAtFuncOffset))
+			);
+		}
 
-	funcBody.push(t.instruction("end"));
+		for (const instr of additionalInitCode) {
+			funcBody.push(instr);
+		}
 
-	const funcResults = [];
+		funcBody.push(t.instruction("end"));
 
-	// Code section
-	const funcSignature = t.signature(funcParams, funcResults);
-	const func = t.func(initFuncId, funcSignature, funcBody);
+		const funcResults = [];
 
-	// Type section
-	const functype = t.typeInstruction(undefined, funcSignature);
+		// Code section
+		const funcSignature = t.signature(funcParams, funcResults);
+		const func = t.func(initFuncId, funcSignature, funcBody);
 
-	// Func section
-	const funcindex = t.indexInFuncSection(nextTypeIndex);
+		// Type section
+		const functype = t.typeInstruction(undefined, funcSignature);
 
-	// Export section
-	const moduleExport = t.moduleExport(
-		initFuncId.value,
-		t.moduleExportDescr("Func", nextFuncIndex)
-	);
+		// Func section
+		const funcindex = t.indexInFuncSection(nextTypeIndex);
 
-	return addWithAST(ast, bin, [func, moduleExport, funcindex, functype]);
-};
+		// Export section
+		const moduleExport = t.moduleExport(
+			initFuncId.value,
+			t.moduleExportDescr("Func", nextFuncIndex)
+		);
+
+		return addWithAST(ast, bin, [func, moduleExport, funcindex, functype]);
+	};
 
 /**
  * Extract mangle mappings from module
@@ -447,7 +451,9 @@ class WebAssemblyGenerator extends Generator {
 			module.dependencies
 				.filter(d => d instanceof WebAssemblyExportImportedDependency)
 				.map(d => {
-					const wasmDep = /** @type {WebAssemblyExportImportedDependency} */ (d);
+					const wasmDep = /** @type {WebAssemblyExportImportedDependency} */ (
+						d
+					);
 					return wasmDep.exportName;
 				})
 		);

package/lib/wasm-sync/WebAssemblyModulesPlugin.js

@@ -61,7 +61,8 @@ class WebAssemblyModulesPlugin {
 				normalModuleFactory.hooks.createGenerator
 					.for("webassembly/sync")
 					.tap("WebAssemblyModulesPlugin", () => {
-						const WebAssemblyJavascriptGenerator = getWebAssemblyJavascriptGenerator();
+						const WebAssemblyJavascriptGenerator =
+							getWebAssemblyJavascriptGenerator();
 						const WebAssemblyGenerator = getWebAssemblyGenerator();
 
 						return Generator.byType({

package/lib/wasm-sync/WebAssemblyParser.js

@@ -89,7 +89,8 @@ class WebAssemblyParser extends Parser {
 
 		// extract imports and exports
 		const exports = [];
-		let jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports = undefined);
+		let jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports =
+			undefined);
 
 		const importedGlobals = [];
 		t.traverse(module, {
@@ -102,13 +103,13 @@ class WebAssemblyParser extends Parser {
 					/** @type {t.FuncSignature} */
 					const funcSignature = moduleContext.getFunction(funcIdx);
 
-					const incompatibleType = getJsIncompatibleTypeOfFuncSignature(
-						funcSignature
-					);
+					const incompatibleType =
+						getJsIncompatibleTypeOfFuncSignature(funcSignature);
 
 					if (incompatibleType) {
 						if (jsIncompatibleExports === undefined) {
-							jsIncompatibleExports = state.module.buildMeta.jsIncompatibleExports = {};
+							jsIncompatibleExports =
+								state.module.buildMeta.jsIncompatibleExports = {};
 						}
 						jsIncompatibleExports[node.name] = incompatibleType;
 					}

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -66,10 +66,8 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 				scriptType
 			}
 		} = compilation;
-		const {
-			linkPreload,
-			linkPrefetch
-		} = JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
+		const { linkPreload, linkPrefetch } =
+			JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
 		const withLoading = this._runtimeRequirements.has(

package/lib/webpack.js

@@ -36,7 +36,7 @@ const getValidateSchema = memoize(() => require("./validateSchema"));
  */
 
 /**
- * @param {WebpackOptions[]} childOptions options array
+ * @param {ReadonlyArray<WebpackOptions>} childOptions options array
  * @param {MultiCompilerOptions} options options
  * @returns {MultiCompiler} a multi-compiler
  */
@@ -92,14 +92,14 @@ const createCompiler = rawOptions => {
 
 /**
  * @callback WebpackFunctionMulti
- * @param {WebpackOptions[] & MultiCompilerOptions} options options objects
+ * @param {ReadonlyArray<WebpackOptions> & MultiCompilerOptions} options options objects
  * @param {Callback<MultiStats>=} callback callback
  * @returns {MultiCompiler} the multi compiler object
  */
 
 const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
 	/**
-	 * @param {WebpackOptions | (WebpackOptions[] & MultiCompilerOptions)} options options
+	 * @param {WebpackOptions | (ReadonlyArray<WebpackOptions> & MultiCompilerOptions)} options options
 	 * @param {Callback<Stats> & Callback<MultiStats>=} callback callback
 	 * @returns {Compiler | MultiCompiler}
 	 */
@@ -115,14 +115,18 @@ const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
 			let watchOptions;
 			if (Array.isArray(options)) {
 				/** @type {MultiCompiler} */
-				compiler = createMultiCompiler(options, options);
+				compiler = createMultiCompiler(
+					options,
+					/** @type {MultiCompilerOptions} */ (options)
+				);
 				watch = options.some(options => options.watch);
 				watchOptions = options.map(options => options.watchOptions || {});
 			} else {
+				const webpackOptions = /** @type {WebpackOptions} */ (options);
 				/** @type {Compiler} */
-				compiler = createCompiler(options);
-				watch = options.watch;
-				watchOptions = options.watchOptions || {};
+				compiler = createCompiler(webpackOptions);
+				watch = webpackOptions.watch;
+				watchOptions = webpackOptions.watchOptions || {};
 			}
 			return { compiler, watch, watchOptions };
 		};

package/lib/webworker/ImportScriptsChunkLoadingPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
+const CreateScriptUrlRuntimeModule = require("../runtime/CreateScriptUrlRuntimeModule");
 const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenciesPlugin");
 const ImportScriptsChunkLoadingRuntimeModule = require("./ImportScriptsChunkLoadingRuntimeModule");
 
@@ -39,11 +40,13 @@ class ImportScriptsChunkLoadingPlugin {
 					if (onceForChunkSet.has(chunk)) return;
 					onceForChunkSet.add(chunk);
 					if (!isEnabledForChunk(chunk)) return;
+					const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
 					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
 					set.add(RuntimeGlobals.hasOwnProperty);
+					if (withCreateScriptUrl) set.add(RuntimeGlobals.createScriptUrl);
 					compilation.addRuntimeModule(
 						chunk,
-						new ImportScriptsChunkLoadingRuntimeModule(set)
+						new ImportScriptsChunkLoadingRuntimeModule(set, withCreateScriptUrl)
 					);
 				};
 				compilation.hooks.runtimeRequirementInTree
@@ -58,6 +61,15 @@ 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)

package/lib/webworker/ImportScriptsChunkLoadingRuntimeModule.js

@@ -16,9 +16,10 @@ const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const { getUndoPath } = require("../util/identifier");
 
 class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
-	constructor(runtimeRequirements) {
+	constructor(runtimeRequirements, withCreateScriptUrl) {
 		super("importScripts chunk loading", RuntimeModule.STAGE_ATTACH);
 		this.runtimeRequirements = runtimeRequirements;
+		this._withCreateScriptUrl = withCreateScriptUrl;
 	}
 
 	/**
@@ -31,7 +32,8 @@ class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 			compilation: {
 				runtimeTemplate,
 				outputOptions: { globalObject, chunkLoadingGlobal, hotUpdateGlobal }
-			}
+			},
+			_withCreateScriptUrl: withCreateScriptUrl
 		} = this;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
@@ -121,7 +123,11 @@ class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 												? "if(true) { // all chunks have JS"
 												: `if(${hasJsMatcher("chunkId")}) {`,
 											Template.indent(
-												`importScripts(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId));`
+												`importScripts(${
+													withCreateScriptUrl
+														? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId))`
+														: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId)`
+												});`
 											),
 											"}"
 										]),
@@ -158,7 +164,11 @@ class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 								"success = true;"
 							])};`,
 							"// start update chunk loading",
-							`importScripts(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId));`,
+							`importScripts(${
+								withCreateScriptUrl
+									? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId))`
+									: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId)`
+							});`,
 							'if(!success) throw new Error("Loading update chunk failed for unknown reason");'
 						]),
 						"}",