webpack 5.97.1 → 5.104.1

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -10,9 +10,10 @@ const Template = require("../Template");
 const { first } = require("../util/SetHelpers");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../Compilation").HashWithLengthFunction} HashWithLengthFunction */
 /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 
 class GetChunkFilenameRuntimeModule extends RuntimeModule {
@@ -20,7 +21,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	 * @param {string} contentType the contentType to use the content hash for
 	 * @param {string} name kind of filename
 	 * @param {string} global function name to be assigned
-	 * @param {function(Chunk): TemplatePath | false} getFilenameForChunk functor to get the filename or function
+	 * @param {(chunk: Chunk) => TemplatePath | false} getFilenameForChunk functor to get the filename or function
 	 * @param {boolean} allChunks when false, only async chunks are included
 	 */
 	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
@@ -52,7 +53,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		 * @param {Chunk} c the chunk
 		 * @returns {void}
 		 */
-		const addChunk = c => {
+		const addChunk = (c) => {
 			const chunkFilename = getFilenameForChunk(c);
 			if (chunkFilename) {
 				let set = chunkFilenames.get(chunkFilename);
@@ -100,8 +101,8 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				.getTreeRuntimeRequirements(chunk)
 				.has(RuntimeGlobals.ensureChunkIncludeEntries);
 			if (includeEntries) {
-				includedChunksMessages.push("sibling chunks for the entrypoint");
-				for (const c of chunkGraph.getChunkEntryDependentChunksIterable(
+				includedChunksMessages.push("chunks that the entrypoint depends on");
+				for (const c of chunkGraph.getRuntimeChunkDependentChunksIterable(
 					chunk
 				)) {
 					addChunk(c);
@@ -124,10 +125,10 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		 */
 		const addStaticUrl = (c, chunkFilename) => {
 			/**
-			 * @param {string | number} value a value
+			 * @param {ChunkId} value a value
 			 * @returns {string} string to put in quotes
 			 */
-			const unquotedStringify = value => {
+			const unquotedStringify = (value) => {
 				const str = `${value}`;
 				if (str.length >= 5 && str === `${c.id}`) {
 					// This is shorter and generates the same result
@@ -138,9 +139,9 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 			};
 			/**
 			 * @param {string} value string
-			 * @returns {function(number): string} string to put in quotes with length
+			 * @returns {HashWithLengthFunction} string to put in quotes with length
 			 */
-			const unquotedStringifyWithLength = value => length =>
+			const unquotedStringifyWithLength = (value) => (length) =>
 				unquotedStringify(`${value}`.slice(0, length));
 			const chunkFilenameValue =
 				typeof chunkFilename === "function"
@@ -153,17 +154,15 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 					: JSON.stringify(chunkFilename);
 			const staticChunkFilename = compilation.getPath(chunkFilenameValue, {
 				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
+				hashWithLength: (length) =>
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				chunk: {
-					id: unquotedStringify(/** @type {number | string} */ (c.id)),
+					id: unquotedStringify(/** @type {ChunkId} */ (c.id)),
 					hash: unquotedStringify(/** @type {string} */ (c.renderedHash)),
 					hashWithLength: unquotedStringifyWithLength(
 						/** @type {string} */ (c.renderedHash)
 					),
-					name: unquotedStringify(
-						c.name || /** @type {number | string} */ (c.id)
-					),
+					name: unquotedStringify(c.name || /** @type {ChunkId} */ (c.id)),
 					contentHash: {
 						[contentType]: unquotedStringify(c.contentHash[contentType])
 					},
@@ -191,14 +190,14 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		}
 
 		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
+		 * @param {(chunk: Chunk) => string | number} fn function from chunk to value
 		 * @returns {string} code with static mapping of results of fn
 		 */
-		const createMap = fn => {
-			/** @type {Record<number | string, number | string>} */
+		const createMap = (fn) => {
+			/** @type {Record<ChunkId, ChunkId>} */
 			const obj = {};
 			let useId = false;
-			/** @type {number | string | undefined} */
+			/** @type {ChunkId | undefined} */
 			let lastKey;
 			let entries = 0;
 			for (const c of dynamicUrlChunks) {
@@ -206,8 +205,8 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				if (value === c.id) {
 					useId = true;
 				} else {
-					obj[/** @type {number | string} */ (c.id)] = value;
-					lastKey = /** @type {number | string} */ (c.id);
+					obj[/** @type {ChunkId} */ (c.id)] = value;
+					lastKey = /** @type {ChunkId} */ (c.id);
 					entries++;
 				}
 			}
@@ -215,9 +214,9 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 			if (entries === 1) {
 				return useId
 					? `(chunkId === ${JSON.stringify(lastKey)} ? ${JSON.stringify(
-							obj[/** @type {number | string} */ (lastKey)]
+							obj[/** @type {ChunkId} */ (lastKey)]
 						)} : chunkId)`
-					: JSON.stringify(obj[/** @type {number | string} */ (lastKey)]);
+					: JSON.stringify(obj[/** @type {ChunkId} */ (lastKey)]);
 			}
 			return useId
 				? `(${JSON.stringify(obj)}[chunkId] || chunkId)`
@@ -225,36 +224,36 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		};
 
 		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
+		 * @param {(chunk: Chunk) => string | number} fn function from chunk to value
 		 * @returns {string} code with static mapping of results of fn for including in quoted string
 		 */
-		const mapExpr = fn => `" + ${createMap(fn)} + "`;
+		const mapExpr = (fn) => `" + ${createMap(fn)} + "`;
 
 		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
-		 * @returns {function(number): string} function which generates code with static mapping of results of fn for including in quoted string for specific length
+		 * @param {(chunk: Chunk) => string | number} fn function from chunk to value
+		 * @returns {HashWithLengthFunction} function which generates code with static mapping of results of fn for including in quoted string for specific length
 		 */
-		const mapExprWithLength = fn => length =>
-			`" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;
+		const mapExprWithLength = (fn) => (length) =>
+			`" + ${createMap((c) => `${fn(c)}`.slice(0, length))} + "`;
 
 		const url =
 			dynamicFilename &&
 			compilation.getPath(JSON.stringify(dynamicFilename), {
 				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
+				hashWithLength: (length) =>
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				chunk: {
 					id: '" + chunkId + "',
-					hash: mapExpr(c => /** @type {string} */ (c.renderedHash)),
+					hash: mapExpr((c) => /** @type {string} */ (c.renderedHash)),
 					hashWithLength: mapExprWithLength(
-						c => /** @type {string} */ (c.renderedHash)
+						(c) => /** @type {string} */ (c.renderedHash)
 					),
-					name: mapExpr(c => c.name || /** @type {number | string} */ (c.id)),
+					name: mapExpr((c) => c.name || /** @type {ChunkId} */ (c.id)),
 					contentHash: {
-						[contentType]: mapExpr(c => c.contentHash[contentType])
+						[contentType]: mapExpr((c) => c.contentHash[contentType])
 					},
 					contentHashWithLength: {
-						[contentType]: mapExprWithLength(c => c.contentHash[contentType])
+						[contentType]: mapExprWithLength((c) => c.contentHash[contentType])
 					}
 				},
 				contentHashType: contentType
@@ -278,7 +277,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 											? `chunkId === ${JSON.stringify(first(ids))}`
 											: `{${Array.from(
 													ids,
-													id => `${JSON.stringify(id)}:1`
+													(id) => `${JSON.stringify(id)}:1`
 												).join(",")}}[chunkId]`;
 									return `if (${condition}) return ${url};`;
 								})

package/lib/runtime/GetMainFilenameRuntimeModule.js

@@ -33,7 +33,7 @@ class GetMainFilenameRuntimeModule extends RuntimeModule {
 		const { runtimeTemplate } = compilation;
 		const url = compilation.getPath(JSON.stringify(filename), {
 			hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-			hashWithLength: length =>
+			hashWithLength: (length) =>
 				`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 			chunk,
 			runtime: chunk.runtime

package/lib/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -69,7 +69,7 @@ class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
 										`policy = trustedTypes.createPolicy(${JSON.stringify(
 											trustedTypes.policyName
 										)}, policy);`
-									].map(line =>
+									].map((line) =>
 										wrapPolicyCreationInTryCatch ? Template.indent(line) : line
 									),
 									...(wrapPolicyCreationInTryCatch

package/lib/runtime/LoadScriptRuntimeModule.js

@@ -11,7 +11,6 @@ const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
 
 /**
  * @typedef {object} LoadScriptCompilationHooks
@@ -74,7 +73,6 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 			"script = document.createElement('script');",
 			scriptType ? `script.type = ${JSON.stringify(scriptType)};` : "",
 			charset ? "script.charset = 'utf-8';" : "",
-			`script.timeout = ${/** @type {number} */ (loadTimeout) / 1000};`,
 			`if (${RuntimeGlobals.scriptNonce}) {`,
 			Template.indent(
 				`script.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -0,0 +1,248 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("../Module").ExportsType} ExportsType */
+/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
+
+/**
+ * @param {ExportsType} exportsType exports type
+ * @returns {string} mode
+ */
+function getMakeDeferredNamespaceModeFromExportsType(exportsType) {
+	if (exportsType === "namespace") return `/* ${exportsType} */ 0`;
+	if (exportsType === "default-only") return `/* ${exportsType} */ 1`;
+	if (exportsType === "default-with-named") return `/* ${exportsType} */ 2`;
+	if (exportsType === "dynamic") return `/* ${exportsType} */ 3`;
+	return "";
+}
+
+/**
+ * @param {string} moduleId moduleId
+ * @param {ExportsType} exportsType exportsType
+ * @param {(ModuleId | null)[]} asyncDepsIds asyncDepsIds
+ * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+ * @returns {string} call make optimized deferred namespace object
+ */
+function getOptimizedDeferredModule(
+	moduleId,
+	exportsType,
+	asyncDepsIds,
+	runtimeRequirements
+) {
+	runtimeRequirements.add(RuntimeGlobals.makeOptimizedDeferredNamespaceObject);
+	const mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);
+	return `${RuntimeGlobals.makeOptimizedDeferredNamespaceObject}(${moduleId}, ${mode}${
+		asyncDepsIds.length > 0
+			? `, ${JSON.stringify(asyncDepsIds.filter((x) => x !== null))}`
+			: ""
+	})`;
+}
+
+class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {boolean} hasAsyncRuntime if async module is used.
+	 */
+	constructor(hasAsyncRuntime) {
+		super("make optimized deferred namespace object");
+		this.hasAsyncRuntime = hasAsyncRuntime;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		if (!this.compilation) return null;
+		const fn = RuntimeGlobals.makeOptimizedDeferredNamespaceObject;
+		const hasAsync = this.hasAsyncRuntime;
+		return Template.asString([
+			// Note: must be a function (not arrow), because this is used in body!
+			`${fn} = function(moduleId, mode${hasAsync ? ", asyncDeps" : ""}) {`,
+			Template.indent([
+				"// mode: 0 => namespace (esm)",
+				"// mode: 1 => default-only (esm strict cjs)",
+				"// mode: 2 => default-with-named (esm-cjs compat)",
+				"// mode: 3 => dynamic (if exports has __esModule, then esm, otherwise default-with-named)",
+				"var r = this;",
+				hasAsync ? "var isAsync = asyncDeps && asyncDeps.length;" : "",
+				"var obj = {",
+				Template.indent([
+					"get a() {",
+					Template.indent([
+						"var exports = r(moduleId);",
+						hasAsync
+							? `if(isAsync) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
+							: "",
+						// if exportsType is "namespace" we can generate the most optimized code,
+						// on the second access, we can avoid trigger the getter.
+						// we can also do this if exportsType is "dynamic" and there is a "__esModule" property on it.
+						'if(mode == 0 || (mode == 3 && exports.__esModule)) Object.defineProperty(this, "a", { value: exports });',
+						"return exports;"
+					]),
+					"}"
+				]),
+				"};",
+				hasAsync
+					? `if(isAsync) obj[${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol}] = asyncDeps;`
+					: "",
+				"return obj;"
+			]),
+			"};"
+		]);
+	}
+}
+
+class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {boolean} hasAsyncRuntime if async module is used.
+	 */
+	constructor(hasAsyncRuntime) {
+		super("make deferred namespace object");
+		this.hasAsyncRuntime = hasAsyncRuntime;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		if (!this.compilation) return null;
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.makeDeferredNamespaceObject;
+		const hasAsync = this.hasAsyncRuntime;
+		const init = runtimeTemplate.supportsOptionalChaining()
+			? "init?.();"
+			: "if (init) init();";
+		return `${fn} = ${runtimeTemplate.basicFunction("moduleId, mode", [
+			"// mode: 0 => namespace (esm)",
+			"// mode: 1 => default-only (esm strict cjs)",
+			"// mode: 2 => default-with-named (esm-cjs compat)",
+			"// mode: 3 => dynamic (if exports has __esModule, then esm, otherwise default-with-named)",
+			"",
+			"var cachedModule = __webpack_module_cache__[moduleId];",
+			"if (cachedModule && cachedModule.error === undefined) {",
+			Template.indent([
+				"var exports = cachedModule.exports;",
+				hasAsync
+					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in exports) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
+					: "",
+				"if (mode == 0) return exports;",
+				`if (mode == 1) return ${RuntimeGlobals.createFakeNamespaceObject}(exports);`,
+				`if (mode == 2) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 2);`,
+				`if (mode == 3) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 6);` // 2 | 4
+			]),
+			"}",
+			"",
+			`var init = ${runtimeTemplate.basicFunction("", [
+				`ns = ${RuntimeGlobals.require}(moduleId);`,
+				hasAsync
+					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in ns) ns = ns[${RuntimeGlobals.asyncModuleExportSymbol}];`
+					: "",
+				"init = null;",
+				"if (mode == 0 || mode == 3 && ns.__esModule && typeof ns === 'object') {",
+				Template.indent([
+					"delete handler.defineProperty;",
+					"delete handler.deleteProperty;",
+					"delete handler.set;",
+					"delete handler.get;",
+					"delete handler.has;",
+					"delete handler.ownKeys;",
+					"delete handler.getOwnPropertyDescriptor;"
+				]),
+				"} else if (mode == 1) {",
+				Template.indent([
+					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns);`
+				]),
+				"} else if (mode == 2) {",
+				Template.indent([
+					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, 2);`
+				]),
+				"} else if (mode == 3) {",
+				Template.indent([
+					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, 6);`
+				]),
+				"}"
+			])};`,
+			"",
+			"var ns = __webpack_module_deferred_exports__[moduleId] || (__webpack_module_deferred_exports__[moduleId] = { __proto__: null });",
+			"var handler = {",
+			Template.indent([
+				"__proto__: null,",
+				`get: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent([
+						'case "__esModule": return true;',
+						'case Symbol.toStringTag: return "Deferred Module";',
+						'case "then": return undefined;'
+					]),
+					"}",
+					init,
+					"return ns[name];"
+				])},`,
+				`has: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent(
+						[
+							'case "__esModule":',
+							"case Symbol.toStringTag:",
+							hasAsync
+								? `case ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol}:`
+								: "",
+							Template.indent("return true;"),
+							'case "then":',
+							Template.indent("return false;")
+						].filter(Boolean)
+					),
+					"}",
+					init,
+					"return name in ns;"
+				])},`,
+				`ownKeys: ${runtimeTemplate.basicFunction("", [
+					init,
+					`var keys = Reflect.ownKeys(ns).filter(${runtimeTemplate.expressionFunction('x !== "then" && x !== Symbol.toStringTag', "x")}).concat([Symbol.toStringTag]);`,
+					"return keys;"
+				])},`,
+				`getOwnPropertyDescriptor: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent([
+						'case "__esModule": return { value: true, configurable: !!mode };',
+						'case Symbol.toStringTag: return { value: "Deferred Module", configurable: !!mode };',
+						'case "then": return undefined;'
+					]),
+					"}",
+					init,
+					"var desc = Reflect.getOwnPropertyDescriptor(ns, name);",
+					'if (mode == 2 && name == "default" && !desc) {',
+					Template.indent("desc = { value: ns, configurable: true };"),
+					"}",
+					"return desc;"
+				])},`,
+				`defineProperty: ${runtimeTemplate.basicFunction("_, name", [
+					init,
+					// Note: This behavior does not match the spec one, but since webpack does not do it either
+					// for a normal Module Namespace object (in MakeNamespaceObjectRuntimeModule), let's keep it simple.
+					"return false;"
+				])},`,
+				`deleteProperty: ${runtimeTemplate.returningFunction("false")},`,
+				`set: ${runtimeTemplate.returningFunction("false")},`
+			]),
+			"}",
+			// we don't fully emulate ES Module semantics in this Proxy to align with normal webpack esm namespace object.
+			"return new Proxy(ns, handler);"
+		])};`;
+	}
+}
+
+module.exports.MakeDeferredNamespaceObjectRuntimeModule =
+	MakeDeferredNamespaceObjectRuntimeModule;
+module.exports.MakeOptimizedDeferredNamespaceObjectRuntimeModule =
+	MakeOptimizedDeferredNamespaceObjectRuntimeModule;
+module.exports.getMakeDeferredNamespaceModeFromExportsType =
+	getMakeDeferredNamespaceModeFromExportsType;
+module.exports.getOptimizedDeferredModule = getOptimizedDeferredModule;

package/lib/runtime/PublicPathRuntimeModule.js

@@ -7,12 +7,12 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("../../declarations/WebpackOptions").PublicPath} PublicPath */
 /** @typedef {import("../Compilation")} Compilation */
 
 class PublicPathRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {OutputOptions["publicPath"]} publicPath public path
+	 * @param {PublicPath} publicPath public path
 	 */
 	constructor(publicPath) {
 		super("publicPath", RuntimeModule.STAGE_BASIC);

package/lib/runtime/RuntimeIdRuntimeModule.js

@@ -22,8 +22,9 @@ class RuntimeIdRuntimeModule extends RuntimeModule {
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const runtime = chunk.runtime;
-		if (typeof runtime !== "string")
+		if (typeof runtime !== "string") {
 			throw new Error("RuntimeIdRuntimeModule must be in a single runtime");
+		}
 		const id = chunkGraph.getRuntimeId(runtime);
 		return `${RuntimeGlobals.runtimeId} = ${JSON.stringify(id)};`;
 	}

package/lib/runtime/StartupChunkDependenciesPlugin.js

@@ -18,6 +18,8 @@ const StartupEntrypointRuntimeModule = require("./StartupEntrypointRuntimeModule
  * @property {boolean=} asyncChunkLoading
  */
 
+const PLUGIN_NAME = "StartupChunkDependenciesPlugin";
+
 class StartupChunkDependenciesPlugin {
 	/**
 	 * @param {Options} options options
@@ -36,53 +38,48 @@ class StartupChunkDependenciesPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"StartupChunkDependenciesPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				/**
-				 * @param {Chunk} chunk chunk to check
-				 * @returns {boolean} true, when the plugin is enabled for the chunk
-				 */
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === this.chunkLoading;
-				};
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"StartupChunkDependenciesPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (!isEnabledForChunk(chunk)) return;
-						if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
-							set.add(RuntimeGlobals.startup);
-							set.add(RuntimeGlobals.ensureChunk);
-							set.add(RuntimeGlobals.ensureChunkIncludeEntries);
-							compilation.addRuntimeModule(
-								chunk,
-								new StartupChunkDependenciesRuntimeModule(
-									this.asyncChunkLoading
-								)
-							);
-						}
-					}
-				);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.startupEntrypoint)
-					.tap("StartupChunkDependenciesPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.require);
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			const globalChunkLoading = compilation.outputOptions.chunkLoading;
+			/**
+			 * @param {Chunk} chunk chunk to check
+			 * @returns {boolean} true, when the plugin is enabled for the chunk
+			 */
+			const isEnabledForChunk = (chunk) => {
+				const options = chunk.getEntryOptions();
+				const chunkLoading =
+					options && options.chunkLoading !== undefined
+						? options.chunkLoading
+						: globalChunkLoading;
+				return chunkLoading === this.chunkLoading;
+			};
+			compilation.hooks.additionalTreeRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph }) => {
+					if (!isEnabledForChunk(chunk)) return;
+					if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
+						set.add(RuntimeGlobals.startup);
 						set.add(RuntimeGlobals.ensureChunk);
 						set.add(RuntimeGlobals.ensureChunkIncludeEntries);
 						compilation.addRuntimeModule(
 							chunk,
-							new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
+							new StartupChunkDependenciesRuntimeModule(this.asyncChunkLoading)
 						);
-					});
-			}
-		);
+					}
+				}
+			);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.startupEntrypoint)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.require);
+					set.add(RuntimeGlobals.ensureChunk);
+					set.add(RuntimeGlobals.ensureChunkIncludeEntries);
+					compilation.addRuntimeModule(
+						chunk,
+						new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
+					);
+				});
+		});
 	}
 }
 

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -28,9 +28,9 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 	generate() {
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const chunk = /** @type {Chunk} */ (this.chunk);
-		const chunkIds = Array.from(
-			chunkGraph.getChunkEntryDependentChunksIterable(chunk)
-		).map(chunk => chunk.id);
+		const chunkIds = [
+			...chunkGraph.getChunkEntryDependentChunksIterable(chunk)
+		].map((chunk) => chunk.id);
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
 		return Template.asString([
@@ -38,11 +38,12 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 			`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(
 				"",
 				!this.asyncChunkLoading
-					? chunkIds
-							.map(
-								id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)});`
-							)
-							.concat("return next();")
+					? [
+							...chunkIds.map(
+								(id) => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)});`
+							),
+							"return next();"
+						]
 					: chunkIds.length === 1
 						? `return ${RuntimeGlobals.ensureChunk}(${JSON.stringify(
 								chunkIds[0]
@@ -60,7 +61,7 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 									Template.indent(
 										chunkIds
 											.map(
-												id =>
+												(id) =>
 													`${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)})`
 											)
 											.join(",\n")

package/lib/runtime/StartupEntrypointRuntimeModule.js

@@ -8,7 +8,6 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../MainTemplate")} MainTemplate */
 
 class StartupEntrypointRuntimeModule extends RuntimeModule {
 	/**

package/lib/runtime/SystemContextRuntimeModule.js

@@ -7,8 +7,6 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
-/** @typedef {import("../Compilation")} Compilation */
-
 class SystemContextRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("__system_context__");