webpack 5.42.0 → 5.45.0

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -29,8 +29,16 @@ const HarmonyImportDependency = require("./HarmonyImportDependency");
 const idsSymbol = Symbol("HarmonyImportSpecifierDependency.ids");
 
 class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
-	constructor(request, sourceOrder, ids, name, range, strictExportPresence) {
-		super(request, sourceOrder);
+	constructor(
+		request,
+		sourceOrder,
+		ids,
+		name,
+		range,
+		strictExportPresence,
+		assertions
+	) {
+		super(request, sourceOrder, assertions);
 		this.ids = ids;
 		this.name = name;
 		this.range = range;

package/lib/dependencies/ModuleDependency.js

@@ -22,13 +22,20 @@ class ModuleDependency extends Dependency {
 		this.request = request;
 		this.userRequest = request;
 		this.range = undefined;
+		// assertions must be serialized by subclasses that use it
+		/** @type {Record<string, any> | undefined} */
+		this.assertions = undefined;
 	}
 
 	/**
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
-		return `module${this.request}`;
+		let str = `module${this.request}`;
+		if (this.assertions !== undefined) {
+			str += JSON.stringify(this.assertions);
+		}
+		return str;
 	}
 
 	/**

package/lib/dependencies/WorkerPlugin.js

@@ -270,7 +270,7 @@ class WorkerPlugin {
 							entryOptions.name = options.name;
 						}
 
-						if (!entryOptions.runtime) {
+						if (entryOptions.runtime === undefined) {
 							let i = workerIndexMap.get(parser.state) || 0;
 							workerIndexMap.set(parser.state, i + 1);
 							let name = `${cachedContextify(

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeModule = require("../RuntimeModule");
+
+class ExportWebpackRequireRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("export webpack runtime", RuntimeModule.STAGE_ATTACH);
+	}
+
+	/**
+	 * @returns {boolean} true, if the runtime module should get it's own scope
+	 */
+	shouldIsolate() {
+		return false;
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		return "export default __webpack_require__;";
+	}
+}
+
+module.exports = ExportWebpackRequireRuntimeModule;

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -5,13 +5,18 @@
 
 "use strict";
 
-const { ConcatSource } = require("webpack-sources");
+const { ConcatSource, RawSource } = require("webpack-sources");
 const { RuntimeGlobals } = require("..");
 const HotUpdateChunk = require("../HotUpdateChunk");
 const Template = require("../Template");
 const {
-	getCompilationHooks
+	getCompilationHooks,
+	getChunkFilenameTemplate
 } = require("../javascript/JavascriptModulesPlugin");
+const {
+	generateEntryStartup,
+	updateHashForEntryStartup
+} = require("../javascript/StartupHelpers");
 
 /** @typedef {import("../Compiler")} Compiler */
 
@@ -30,8 +35,9 @@ class ModuleChunkFormatPlugin {
 					(chunk, set) => {
 						if (chunk.hasRuntime()) return;
 						if (compilation.chunkGraph.getNumberOfEntryModules(chunk) > 0) {
-							set.add(RuntimeGlobals.onChunksLoaded);
 							set.add(RuntimeGlobals.require);
+							set.add(RuntimeGlobals.startupEntrypoint);
+							set.add(RuntimeGlobals.externalInstallChunk);
 						}
 					}
 				);
@@ -39,7 +45,7 @@ class ModuleChunkFormatPlugin {
 				hooks.renderChunk.tap(
 					"ModuleChunkFormatPlugin",
 					(modules, renderContext) => {
-						const { chunk, chunkGraph } = renderContext;
+						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
 						const hotUpdateChunk =
 							chunk instanceof HotUpdateChunk ? chunk : null;
 						const source = new ConcatSource();
@@ -68,9 +74,84 @@ class ModuleChunkFormatPlugin {
 								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
 							);
 							if (entries.length > 0) {
-								throw new Error(
-									"Entry modules in chunk is not implemented for module chunk format yet"
+								const runtimeChunk = entries[0][1].getRuntimeChunk();
+								const currentOutputName = compilation
+									.getPath(
+										getChunkFilenameTemplate(chunk, compilation.outputOptions),
+										{
+											chunk,
+											contentHashType: "javascript"
+										}
+									)
+									.split("/");
+								const runtimeOutputName = compilation
+									.getPath(
+										getChunkFilenameTemplate(
+											runtimeChunk,
+											compilation.outputOptions
+										),
+										{
+											chunk: runtimeChunk,
+											contentHashType: "javascript"
+										}
+									)
+									.split("/");
+
+								// remove filename, we only need the directory
+								const outputFilename = currentOutputName.pop();
+
+								// remove common parts
+								while (
+									currentOutputName.length > 0 &&
+									runtimeOutputName.length > 0 &&
+									currentOutputName[0] === runtimeOutputName[0]
+								) {
+									currentOutputName.shift();
+									runtimeOutputName.shift();
+								}
+
+								// create final path
+								const runtimePath =
+									(currentOutputName.length > 0
+										? "../".repeat(currentOutputName.length)
+										: "./") + runtimeOutputName.join("/");
+
+								const entrySource = new ConcatSource();
+								entrySource.add(source);
+								entrySource.add(";\n\n// load runtime\n");
+								entrySource.add(
+									`import __webpack_require__ from ${JSON.stringify(
+										runtimePath
+									)};\n`
+								);
+								entrySource.add(
+									`import * as __webpack_self_exports__ from ${JSON.stringify(
+										"./" + outputFilename
+									)};\n`
+								);
+								entrySource.add(
+									`${RuntimeGlobals.externalInstallChunk}(__webpack_self_exports__);\n`
+								);
+								const startupSource = new RawSource(
+									generateEntryStartup(
+										chunkGraph,
+										runtimeTemplate,
+										entries,
+										chunk,
+										false
+									)
+								);
+								entrySource.add(
+									hooks.renderStartup.call(
+										startupSource,
+										entries[entries.length - 1][0],
+										{
+											...renderContext,
+											inlined: false
+										}
+									)
 								);
+								return entrySource;
 							}
 						}
 						return source;
@@ -82,11 +163,10 @@ class ModuleChunkFormatPlugin {
 						if (chunk.hasRuntime()) return;
 						hash.update("ModuleChunkFormatPlugin");
 						hash.update("1");
-						// TODO
-						// const entries = Array.from(
-						// 	chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-						// );
-						// updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+						const entries = Array.from(
+							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+						);
+						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
 					}
 				);
 			}

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
+const ExportWebpackRequireRuntimeModule = require("./ExportWebpackRequireRuntimeModule");
 const ModuleChunkLoadingRuntimeModule = require("./ModuleChunkLoadingRuntimeModule");
 
 /** @typedef {import("../Compiler")} Compiler */
@@ -45,9 +46,21 @@ class ModuleChunkLoadingPlugin {
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.baseURI)
 					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.externalInstallChunk)
+					.tap("ModuleChunkLoadingPlugin", handler);
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.onChunksLoaded)
 					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.externalInstallChunk)
+					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						compilation.addRuntimeModule(
+							chunk,
+							new ExportWebpackRequireRuntimeModule()
+						);
+					});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.ensureChunkHandlers)

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -67,6 +67,9 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		} = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withExternalInstallChunk = this._runtimeRequirements.has(
+			RuntimeGlobals.externalInstallChunk
+		);
 		const withLoading = this._runtimeRequirements.has(
 			RuntimeGlobals.ensureChunkHandlers
 		);
@@ -110,6 +113,38 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			),
 			"};",
 			"",
+			withLoading || withExternalInstallChunk
+				? `var installChunk = ${runtimeTemplate.basicFunction("data", [
+						runtimeTemplate.destructureObject(
+							["ids", "modules", "runtime"],
+							"data"
+						),
+						'// add "modules" to the modules object,',
+						'// then flag all "ids" as loaded and fire callback',
+						"var moduleId, chunkId, i = 0;",
+						"for(moduleId in modules) {",
+						Template.indent([
+							`if(${RuntimeGlobals.hasOwnProperty}(modules, moduleId)) {`,
+							Template.indent(
+								`${RuntimeGlobals.moduleFactories}[moduleId] = modules[moduleId];`
+							),
+							"}"
+						]),
+						"}",
+						"if(runtime) runtime(__webpack_require__);",
+						"for(;i < ids.length; i++) {",
+						Template.indent([
+							"chunkId = ids[i];",
+							`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
+							Template.indent("installedChunks[chunkId][0]();"),
+							"}",
+							"installedChunks[ids[i]] = 0;"
+						]),
+						"}",
+						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
+				  ])}`
+				: "// no install chunk",
+			"",
 			withLoading
 				? Template.asString([
 						`${fn}.j = ${runtimeTemplate.basicFunction(
@@ -137,45 +172,13 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 														rootOutputDir
 													)} + ${
 														RuntimeGlobals.getChunkScriptFilename
-													}(chunkId)).then(${runtimeTemplate.basicFunction(
-														"data",
+													}(chunkId)).then(installChunk, ${runtimeTemplate.basicFunction(
+														"e",
 														[
-															runtimeTemplate.destructureObject(
-																["ids", "modules", "runtime"],
-																"data"
-															),
-															'// add "modules" to the modules object,',
-															'// then flag all "ids" as loaded and fire callback',
-															"var moduleId, chunkId, i = 0;",
-															"for(moduleId in modules) {",
-															Template.indent([
-																`if(${RuntimeGlobals.hasOwnProperty}(modules, moduleId)) {`,
-																Template.indent(
-																	`${RuntimeGlobals.moduleFactories}[moduleId] = modules[moduleId];`
-																),
-																"}"
-															]),
-															"}",
-															"if(runtime) runtime(__webpack_require__);",
-															"for(;i < ids.length; i++) {",
-															Template.indent([
-																"chunkId = ids[i];",
-																`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
-																Template.indent(
-																	"installedChunks[chunkId][0]();"
-																),
-																"}",
-																"installedChunks[ids[i]] = 0;"
-															]),
-															"}",
-															withOnChunkLoad
-																? `${RuntimeGlobals.onChunksLoaded}();`
-																: ""
+															"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
+															"throw e;"
 														]
-													)}, ${runtimeTemplate.basicFunction("e", [
-														"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
-														"throw e;"
-													])});`,
+													)});`,
 													`var promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
 														`installedChunkData = installedChunks[chunkId] = [resolve]`,
 														"resolve"
@@ -193,6 +196,12 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 				  ])
 				: "// no chunk on demand loading",
 			"",
+			withExternalInstallChunk
+				? Template.asString([
+						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
+				  ])
+				: "// no external install chunk",
+			"",
 			withOnChunkLoad
 				? `${
 						RuntimeGlobals.onChunksLoaded

package/lib/hmr/lazyCompilationBackend.js

@@ -20,7 +20,7 @@ module.exports = (compiler, client, callback) => {
 	const activeModules = new Map();
 	const prefix = "/lazy-compilation-using-";
 
-	const server = http.createServer((req, res) => {
+	const requestListener = (req, res) => {
 		const keys = req.url.slice(prefix.length).split("@");
 		req.socket.on("close", () => {
 			setTimeout(() => {
@@ -51,7 +51,8 @@ module.exports = (compiler, client, callback) => {
 			}
 		}
 		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
-	});
+	};
+	const server = http.createServer(requestListener);
 	let isClosing = false;
 	/** @type {Set<import("net").Socket>} */
 	const sockets = new Set();
@@ -78,6 +79,8 @@ module.exports = (compiler, client, callback) => {
 		callback(null, {
 			dispose(callback) {
 				isClosing = true;
+				// Removing the listener is a workaround for a memory leak in node.js
+				server.off("request", requestListener);
 				server.close(err => {
 					callback(err);
 				});

package/lib/javascript/JavascriptParser.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { Parser: AcornParser } = require("acorn");
+const { importAssertions } = require("acorn-import-assertions");
 const { SyncBailHook, HookMap } = require("tapable");
 const vm = require("vm");
 const Parser = require("../Parser");
@@ -42,6 +43,10 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").Node} AnyNode */
 /** @typedef {import("estree").Program} ProgramNode */
 /** @typedef {import("estree").Statement} StatementNode */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclarationNode */
+/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclarationNode */
+/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclarationNode */
+/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclarationNode */
 /** @typedef {import("estree").Super} SuperNode */
 /** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpressionNode */
 /** @typedef {import("estree").TemplateLiteral} TemplateLiteralNode */
@@ -61,7 +66,7 @@ const ALLOWED_MEMBER_TYPES_ALL = 0b11;
 
 // Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
 
-const parser = AcornParser;
+const parser = AcornParser.extend(importAssertions);
 
 class VariableInfo {
 	/**
@@ -190,31 +195,31 @@ class JavascriptParser extends Parser {
 			]),
 			/** @type {HookMap<SyncBailHook<[LabeledStatementNode], boolean | void>>} */
 			label: new HookMap(() => new SyncBailHook(["statement"])),
-			/** @type {SyncBailHook<[StatementNode, ImportSource], boolean | void>} */
+			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource], boolean | void>} */
 			import: new SyncBailHook(["statement", "source"]),
-			/** @type {SyncBailHook<[StatementNode, ImportSource, string, string], boolean | void>} */
+			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource, string, string], boolean | void>} */
 			importSpecifier: new SyncBailHook([
 				"statement",
 				"source",
 				"exportName",
 				"identifierName"
 			]),
-			/** @type {SyncBailHook<[StatementNode], boolean | void>} */
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode], boolean | void>} */
 			export: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[StatementNode, ImportSource], boolean | void>} */
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource], boolean | void>} */
 			exportImport: new SyncBailHook(["statement", "source"]),
-			/** @type {SyncBailHook<[StatementNode, DeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, DeclarationNode], boolean | void>} */
 			exportDeclaration: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[StatementNode, DeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[ExportDefaultDeclarationNode, DeclarationNode], boolean | void>} */
 			exportExpression: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[StatementNode, string, string, number | undefined], boolean | void>} */
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, string, string, number | undefined], boolean | void>} */
 			exportSpecifier: new SyncBailHook([
 				"statement",
 				"identifierName",
 				"exportName",
 				"index"
 			]),
-			/** @type {SyncBailHook<[StatementNode, ImportSource, string, string, number | undefined], boolean | void>} */
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource, string, string, number | undefined], boolean | void>} */
 			exportImportSpecifier: new SyncBailHook([
 				"statement",
 				"source",

package/lib/json/JsonData.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { register } = require("../util/serialization");
+
+class JsonData {
+	constructor(data) {
+		this._buffer = undefined;
+		this._data = undefined;
+		if (Buffer.isBuffer(data)) {
+			this._buffer = data;
+		} else {
+			this._data = data;
+		}
+	}
+
+	get() {
+		if (this._data === undefined && this._buffer !== undefined) {
+			this._data = JSON.parse(this._buffer.toString());
+		}
+		return this._data;
+	}
+}
+
+register(JsonData, "webpack/lib/json/JsonData", null, {
+	serialize(obj, { write }) {
+		if (obj._buffer === undefined && obj._data !== undefined) {
+			obj._buffer = Buffer.from(JSON.stringify(obj._data));
+		}
+		write(obj._buffer);
+	},
+	deserialize({ read }) {
+		return new JsonData(read());
+	}
+});
+
+module.exports = JsonData;

package/lib/json/JsonGenerator.js

@@ -116,7 +116,10 @@ class JsonGenerator extends Generator {
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
-		let data = module.buildInfo.jsonData;
+		let data =
+			module.buildInfo &&
+			module.buildInfo.jsonData &&
+			module.buildInfo.jsonData.get();
 		if (!data) return 0;
 		return stringifySafe(data).length + 10;
 	}
@@ -145,7 +148,10 @@ class JsonGenerator extends Generator {
 			concatenationScope
 		}
 	) {
-		const data = module.buildInfo.jsonData;
+		const data =
+			module.buildInfo &&
+			module.buildInfo.jsonData &&
+			module.buildInfo.jsonData.get();
 		if (data === undefined) {
 			return new RawSource(
 				runtimeTemplate.missingModuleStatement({

package/lib/json/JsonParser.js

@@ -8,6 +8,7 @@
 const parseJson = require("json-parse-better-errors");
 const Parser = require("../Parser");
 const JsonExportsDependency = require("../dependencies/JsonExportsDependency");
+const JsonData = require("./JsonData");
 
 /** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
 /** @typedef {import("../Parser").ParserState} ParserState */
@@ -41,7 +42,7 @@ class JsonParser extends Parser {
 				? source
 				: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
 
-		state.module.buildInfo.jsonData = data;
+		state.module.buildInfo.jsonData = new JsonData(data);
 		state.module.buildInfo.strict = true;
 		state.module.buildMeta.exportsType = "default";
 		state.module.buildMeta.defaultObject =

package/lib/library/SystemLibraryPlugin.js

@@ -72,7 +72,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 	render(source, { chunkGraph, moduleGraph, chunk }, { options, compilation }) {
 		const modules = chunkGraph
 			.getChunkModules(chunk)
-			.filter(m => m instanceof ExternalModule);
+			.filter(m => m instanceof ExternalModule && m.externalType === "system");
 		const externals = /** @type {ExternalModule[]} */ (modules);
 
 		// The name this bundle should be registered as with System

package/lib/optimize/ConcatenatedModule.js

@@ -45,6 +45,7 @@ const {
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @template T @typedef {import("../InitFragment")<T>} InitFragment */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
@@ -55,6 +56,7 @@ const {
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
@@ -104,6 +106,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {Object} ast
  * @property {Source} internalSource
  * @property {ReplaceSource} source
+ * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
  * @property {Iterable<string>} runtimeRequirements
  * @property {Scope} globalScope
  * @property {Scope} moduleScope
@@ -1508,6 +1511,8 @@ ${defineGetters}`
 			}
 		}
 
+		const chunkInitFragments = [];
+
 		// evaluate modules in order
 		for (const rawInfo of modulesWithInfo) {
 			let name;
@@ -1521,6 +1526,9 @@ ${defineGetters}`
 						)}\n`
 					);
 					result.add(info.source);
+					if (info.chunkInitFragments) {
+						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
+					}
 					if (info.runtimeRequirements) {
 						for (const r of info.runtimeRequirements) {
 							runtimeRequirements.add(r);
@@ -1583,9 +1591,14 @@ ${defineGetters}`
 			}
 		}
 
+		const data = new Map();
+		if (chunkInitFragments.length > 0)
+			data.set("chunkInitFragments", chunkInitFragments);
+
 		/** @type {CodeGenerationResult} */
 		const resultEntry = {
 			sources: new Map([["javascript", new CachedSource(result)]]),
+			data,
 			runtimeRequirements
 		};
 
@@ -1626,6 +1639,8 @@ ${defineGetters}`
 					concatenationScope
 				});
 				const source = codeGenResult.sources.get("javascript");
+				const data = codeGenResult.data;
+				const chunkInitFragments = data && data.get("chunkInitFragments");
 				const code = source.source().toString();
 				let ast;
 				try {
@@ -1662,6 +1677,7 @@ ${defineGetters}`
 				info.ast = ast;
 				info.internalSource = source;
 				info.source = resultSource;
+				info.chunkInitFragments = chunkInitFragments;
 				info.globalScope = globalScope;
 				info.moduleScope = moduleScope;
 			} catch (err) {

package/lib/optimize/RuntimeChunkPlugin.js

@@ -27,7 +27,7 @@ class RuntimeChunkPlugin {
 				(_, { name: entryName }) => {
 					if (entryName === undefined) return;
 					const data = compilation.entries.get(entryName);
-					if (!data.options.runtime && !data.options.dependOn) {
+					if (data.options.runtime === undefined && !data.options.dependOn) {
 						// Determine runtime chunk name
 						let name = this.options.name;
 						if (typeof name === "function") {