webpack 5.36.2 → 5.38.1

package/lib/util/serialization.js

@@ -4,72 +4,121 @@
 
 "use strict";
 
-const BinaryMiddleware = require("../serialization/BinaryMiddleware");
-const FileMiddleware = require("../serialization/FileMiddleware");
-const ObjectMiddleware = require("../serialization/ObjectMiddleware");
-const Serializer = require("../serialization/Serializer");
-const SerializerMiddleware = require("../serialization/SerializerMiddleware");
-const SingleItemMiddleware = require("../serialization/SingleItemMiddleware");
-const internalSerializables = require("./internalSerializables");
+const memoize = require("./memoize");
 
+/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_END_OPERATION_TYPE} MEASURE_END_OPERATION */
+/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_START_OPERATION_TYPE} MEASURE_START_OPERATION */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/Serializer")} Serializer */
 
-const { register, registerLoader, registerNotSerializable } = ObjectMiddleware;
+const getBinaryMiddleware = memoize(() =>
+	require("../serialization/BinaryMiddleware")
+);
+const getObjectMiddleware = memoize(() =>
+	require("../serialization/ObjectMiddleware")
+);
+const getSingleItemMiddleware = memoize(() =>
+	require("../serialization/SingleItemMiddleware")
+);
+const getSerializer = memoize(() => require("../serialization/Serializer"));
+const getSerializerMiddleware = memoize(() =>
+	require("../serialization/SerializerMiddleware")
+);
 
-const binaryMiddleware = new BinaryMiddleware();
+const getBinaryMiddlewareInstance = memoize(
+	() => new (getBinaryMiddleware())()
+);
 
-// Expose serialization API
-exports.register = register;
-exports.registerLoader = registerLoader;
-exports.registerNotSerializable = registerNotSerializable;
-exports.NOT_SERIALIZABLE = ObjectMiddleware.NOT_SERIALIZABLE;
-exports.MEASURE_START_OPERATION = BinaryMiddleware.MEASURE_START_OPERATION;
-exports.MEASURE_END_OPERATION = BinaryMiddleware.MEASURE_END_OPERATION;
-exports.buffersSerializer = new Serializer([
-	new SingleItemMiddleware(),
-	new ObjectMiddleware(context => {
-		if (context.write) {
-			context.writeLazy = value => {
-				context.write(SerializerMiddleware.createLazy(value, binaryMiddleware));
-			};
+const registerSerializers = memoize(() => {
+	require("./registerExternalSerializer");
+
+	// Load internal paths with a relative require
+	// This allows bundling all internal serializers
+	const internalSerializables = require("./internalSerializables");
+	getObjectMiddleware().registerLoader(/^webpack\/lib\//, req => {
+		const loader = internalSerializables[req.slice("webpack/lib/".length)];
+		if (loader) {
+			loader();
+		} else {
+			console.warn(`${req} not found in internalSerializables`);
 		}
-	}),
-	binaryMiddleware
-]);
-exports.createFileSerializer = fs => {
-	const fileMiddleware = new FileMiddleware(fs);
-	return new Serializer([
-		new SingleItemMiddleware(),
-		new ObjectMiddleware(context => {
-			if (context.write) {
-				context.writeLazy = value => {
-					context.write(
-						SerializerMiddleware.createLazy(value, binaryMiddleware)
-					);
-				};
-				context.writeSeparate = (value, options) => {
-					context.write(
-						SerializerMiddleware.createLazy(value, fileMiddleware, options)
-					);
-				};
-			}
-		}),
-		binaryMiddleware,
-		fileMiddleware
-	]);
-};
+		return true;
+	});
+});
 
-require("./registerExternalSerializer");
+/** @type {Serializer} */
+let buffersSerializer;
 
-// Load internal paths with a relative require
-// This allows bundling all internal serializers
-registerLoader(/^webpack\/lib\//, req => {
-	const loader = internalSerializables[req.slice("webpack/lib/".length)];
-	if (loader) {
-		loader();
-	} else {
-		console.warn(`${req} not found in internalSerializables`);
+// Expose serialization API
+module.exports = {
+	get register() {
+		return getObjectMiddleware().register;
+	},
+	get registerLoader() {
+		return getObjectMiddleware().registerLoader;
+	},
+	get registerNotSerializable() {
+		return getObjectMiddleware().registerNotSerializable;
+	},
+	get NOT_SERIALIZABLE() {
+		return getObjectMiddleware().NOT_SERIALIZABLE;
+	},
+	/** @type {MEASURE_START_OPERATION} */
+	get MEASURE_START_OPERATION() {
+		return getBinaryMiddleware().MEASURE_START_OPERATION;
+	},
+	/** @type {MEASURE_END_OPERATION} */
+	get MEASURE_END_OPERATION() {
+		return getBinaryMiddleware().MEASURE_END_OPERATION;
+	},
+	get buffersSerializer() {
+		if (buffersSerializer !== undefined) return buffersSerializer;
+		registerSerializers();
+		const Serializer = getSerializer();
+		const binaryMiddleware = getBinaryMiddlewareInstance();
+		const SerializerMiddleware = getSerializerMiddleware();
+		const SingleItemMiddleware = getSingleItemMiddleware();
+		return (buffersSerializer = new Serializer([
+			new SingleItemMiddleware(),
+			new (getObjectMiddleware())(context => {
+				if (context.write) {
+					context.writeLazy = value => {
+						context.write(
+							SerializerMiddleware.createLazy(value, binaryMiddleware)
+						);
+					};
+				}
+			}),
+			binaryMiddleware
+		]));
+	},
+	createFileSerializer: fs => {
+		registerSerializers();
+		const Serializer = getSerializer();
+		const FileMiddleware = require("../serialization/FileMiddleware");
+		const fileMiddleware = new FileMiddleware(fs);
+		const binaryMiddleware = getBinaryMiddlewareInstance();
+		const SerializerMiddleware = getSerializerMiddleware();
+		const SingleItemMiddleware = getSingleItemMiddleware();
+		return new Serializer([
+			new SingleItemMiddleware(),
+			new (getObjectMiddleware())(context => {
+				if (context.write) {
+					context.writeLazy = value => {
+						context.write(
+							SerializerMiddleware.createLazy(value, binaryMiddleware)
+						);
+					};
+					context.writeSeparate = (value, options) => {
+						context.write(
+							SerializerMiddleware.createLazy(value, fileMiddleware, options)
+						);
+					};
+				}
+			}),
+			binaryMiddleware,
+			fileMiddleware
+		]);
 	}
-	return true;
-});
+};

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");'
 						]),
 						"}",