webpack 5.1.2 → 5.3.0

package/lib/ChunkGraph.js

@@ -200,6 +200,8 @@ class ChunkGraph {
 		this._chunks = new WeakMap();
 		/** @private @type {WeakMap<AsyncDependenciesBlock, ChunkGroup>} */
 		this._blockChunkGroups = new WeakMap();
+		/** @private @type {Map<string, string | number>} */
+		this._runtimeIds = new Map();
 		/** @type {ModuleGraph} */
 		this.moduleGraph = moduleGraph;
 
@@ -1144,6 +1146,23 @@ class ChunkGraph {
 		cgm.id = id;
 	}
 
+	/**
+	 * @param {string} runtime runtime
+	 * @returns {string | number} the id of the runtime
+	 */
+	getRuntimeId(runtime) {
+		return this._runtimeIds.get(runtime);
+	}
+
+	/**
+	 * @param {string} runtime runtime
+	 * @param {string | number} id the id of the runtime
+	 * @returns {void}
+	 */
+	setRuntimeId(runtime, id) {
+		this._runtimeIds.set(runtime, id);
+	}
+
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime the runtime

package/lib/Compilation.js

@@ -179,9 +179,11 @@ const { getRuntimeKey } = require("./util/runtime");
  * @property {string | string[]=} chunkhash the value(s) of the chunk hash used for this asset
  * @property {string | string[]=} modulehash the value(s) of the module hash used for this asset
  * @property {string | string[]=} contenthash the value(s) of the content hash used for this asset
+ * @property {string=} sourceFilename when asset was created from a source file (potentially transformed), the original filename relative to compilation context
  * @property {number=} size size in bytes, only set after asset has been emitted
  * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets
  * @property {boolean=} hotModuleReplacement true, when asset ships data for updating an existing application (HMR)
+ * @property {boolean=} javascriptModule true, when asset is javascript and an ESM
  * @property {Record<string, string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
  */
 
@@ -1937,6 +1939,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					this.hooks.optimizeChunkIds.call(this.chunks);
 					this.hooks.afterOptimizeChunkIds.call(this.chunks);
 
+					this.assignRuntimeIds();
+
 					this.sortItemsWithChunkIds();
 
 					if (shouldRecord) {
@@ -2554,6 +2558,21 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 	}
 
+	assignRuntimeIds() {
+		const { chunkGraph } = this;
+		const processEntrypoint = ep => {
+			const runtime = ep.options.runtime || ep.name;
+			const chunk = ep.getRuntimeChunk();
+			chunkGraph.setRuntimeId(runtime, chunk.id);
+		};
+		for (const ep of this.entrypoints.values()) {
+			processEntrypoint(ep);
+		}
+		for (const ep of this.asyncEntrypoints) {
+			processEntrypoint(ep);
+		}
+	}
+
 	sortItemsWithChunkIds() {
 		for (const chunkGroup of this.chunkGroups) {
 			chunkGroup.sortItems();
@@ -2590,7 +2609,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 	createModuleHashes() {
 		let statModulesHashed = 0;
-		const chunkGraph = this.chunkGraph;
+		const { chunkGraph, runtimeTemplate } = this;
 		const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
 		for (const module of this.modules) {
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
@@ -2598,7 +2617,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				const moduleHash = createHash(hashFunction);
 				module.updateHash(moduleHash, {
 					chunkGraph,
-					runtime
+					runtime,
+					runtimeTemplate
 				});
 				const moduleHashDigest = /** @type {string} */ (moduleHash.digest(
 					hashDigest
@@ -2621,6 +2641,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	createHash() {
 		this.logger.time("hashing: initialize hash");
 		const chunkGraph = this.chunkGraph;
+		const runtimeTemplate = this.runtimeTemplate;
 		const outputOptions = this.outputOptions;
 		const hashFunction = outputOptions.hashFunction;
 		const hashDigest = outputOptions.hashDigest;
@@ -2705,7 +2726,8 @@ This prevents using hashes of each other and should be avoided.`
 					const moduleHash = createHash(hashFunction);
 					module.updateHash(moduleHash, {
 						chunkGraph,
-						runtime: chunk.runtime
+						runtime: chunk.runtime,
+						runtimeTemplate
 					});
 					const moduleHashDigest = /** @type {string} */ (moduleHash.digest(
 						hashDigest
@@ -2767,7 +2789,8 @@ This prevents using hashes of each other and should be avoided.`
 				const moduleHash = createHash(hashFunction);
 				module.updateHash(moduleHash, {
 					chunkGraph,
-					runtime: chunk.runtime
+					runtime: chunk.runtime,
+					runtimeTemplate
 				});
 				const moduleHashDigest = /** @type {string} */ (moduleHash.digest(
 					hashDigest
@@ -3148,7 +3171,12 @@ This prevents using hashes of each other and should be avoided.`
 										fileManifest.pathOptions
 									);
 									file = pathAndInfo.path;
-									assetInfo = pathAndInfo.info;
+									assetInfo = fileManifest.info
+										? {
+												...pathAndInfo.info,
+												...fileManifest.info
+										  }
+										: pathAndInfo.info;
 								}
 
 								if (err) {
@@ -3443,14 +3471,14 @@ Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE = 1000;
 Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING = 2000;
 
 /**
- * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
+ * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
  */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH = 2500;
 
 /**
- * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
+ * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
  */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH = 3500;
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
 
 /**
  * Analyse existing assets.

package/lib/Compiler.js

@@ -97,6 +97,20 @@ const sortObject = (obj, keys) => {
 	return o;
 };
 
+/**
+ * @param {string} filename filename
+ * @param {string | string[] | undefined} hashes list of hashes
+ * @returns {boolean} true, if the filename contains any hash
+ */
+const includesHash = (filename, hashes) => {
+	if (!hashes) return false;
+	if (Array.isArray(hashes)) {
+		return hashes.some(hash => filename.includes(hash));
+	} else {
+		return filename.includes(hashes);
+	}
+};
+
 class Compiler {
 	/**
 	 * @param {string} context the compilation path
@@ -522,9 +536,19 @@ class Compiler {
 				15,
 				({ name: file, source, info }, callback) => {
 					let targetFile = file;
+					let immutable = info.immutable;
 					const queryStringIdx = targetFile.indexOf("?");
 					if (queryStringIdx >= 0) {
 						targetFile = targetFile.substr(0, queryStringIdx);
+						// We may remove the hash, which is in the query string
+						// So we recheck if the file is immutable
+						// This doesn't cover all cases, but immutable is only a performance optimization anyway
+						immutable =
+							immutable &&
+							(includesHash(targetFile, info.contenthash) ||
+								includesHash(targetFile, info.chunkhash) ||
+								includesHash(targetFile, info.modulehash) ||
+								includesHash(targetFile, info.fullhash));
 					}
 
 					const writeOut = err => {
@@ -639,7 +663,7 @@ ${other}`);
 
 						const processExistingFile = stats => {
 							// skip emitting if it's already there and an immutable file
-							if (info.immutable) {
+							if (immutable) {
 								updateWithReplacementSource(stats.size);
 								return alreadyWritten();
 							}
@@ -693,7 +717,7 @@ ${other}`);
 								return callback();
 							}
 
-							if (!info.immutable) {
+							if (!immutable) {
 								// We wrote to this file before which has very likely a different content
 								// skip comparing and assume content is different for performance
 								// This case happens often during watch mode.

package/lib/ConditionalInitFragment.js

@@ -0,0 +1,109 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { ConcatSource, PrefixSource } = require("webpack-sources");
+const InitFragment = require("./InitFragment");
+const Template = require("./Template");
+const { mergeRuntime } = require("./util/runtime");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Generator").GenerateContext} GenerateContext */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+
+const wrapInCondition = (condition, source) => {
+	if (typeof source === "string") {
+		return Template.asString([
+			`if (${condition}) {`,
+			Template.indent(source),
+			"}",
+			""
+		]);
+	} else {
+		return new ConcatSource(
+			`if (${condition}) {\n`,
+			new PrefixSource("\t", source),
+			"}\n"
+		);
+	}
+};
+
+class ConditionalInitFragment extends InitFragment {
+	/**
+	 * @param {string|Source} content the source code that will be included as initialization code
+	 * @param {number} stage category of initialization code (contribute to order)
+	 * @param {number} position position in the category (contribute to order)
+	 * @param {string} key unique key to avoid emitting the same initialization code twice
+	 * @param {RuntimeSpec | boolean} runtimeCondition in which runtime this fragment should be executed
+	 * @param {string|Source=} endContent the source code that will be included at the end of the module
+	 */
+	constructor(
+		content,
+		stage,
+		position,
+		key,
+		runtimeCondition = true,
+		endContent
+	) {
+		super(content, stage, position, key, endContent);
+		this.runtimeCondition = runtimeCondition;
+	}
+
+	/**
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {string|Source} the source code that will be included as initialization code
+	 */
+	getContent(generateContext) {
+		if (this.runtimeCondition === false || !this.content) return "";
+		if (this.runtimeCondition === true) return this.content;
+		const expr = generateContext.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: generateContext.chunkGraph,
+			runtimeRequirements: generateContext.runtimeRequirements,
+			runtime: generateContext.runtime,
+			runtimeCondition: this.runtimeCondition
+		});
+		if (expr === "true") return this.content;
+		return wrapInCondition(expr, this.content);
+	}
+
+	/**
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {string|Source=} the source code that will be included at the end of the module
+	 */
+	getEndContent(generateContext) {
+		if (this.runtimeCondition === false || !this.endContent) return "";
+		if (this.runtimeCondition === true) return this.endContent;
+		const expr = generateContext.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: generateContext.chunkGraph,
+			runtimeRequirements: generateContext.runtimeRequirements,
+			runtime: generateContext.runtime,
+			runtimeCondition: this.runtimeCondition
+		});
+		if (expr === "true") return this.endContent;
+		return wrapInCondition(expr, this.endContent);
+	}
+
+	merge(other) {
+		if (this.runtimeCondition === true) return this;
+		if (other.runtimeCondition === true) return other;
+		if (this.runtimeCondition === false) return other;
+		if (other.runtimeCondition === false) return this;
+		const runtimeCondition = mergeRuntime(
+			this.runtimeCondition,
+			other.runtimeCondition
+		);
+		return new ConditionalInitFragment(
+			this.content,
+			this.stage,
+			this.position,
+			this.key,
+			runtimeCondition,
+			this.endContent
+		);
+	}
+}
+
+module.exports = ConditionalInitFragment;

package/lib/ContextModule.js

@@ -980,7 +980,7 @@ module.exports = webpackEmptyAsyncContext;`;
 	}
 
 	getSource(sourceString) {
-		if (this.useSourceMap) {
+		if (this.useSourceMap || this.useSimpleSourceMap) {
 			return new OriginalSource(sourceString, this.identifier());
 		}
 		return new RawSource(sourceString);

package/lib/DelegatedModule.js

@@ -154,7 +154,7 @@ class DelegatedModule extends Module {
 		}
 
 		const sources = new Map();
-		if (this.useSourceMap) {
+		if (this.useSourceMap || this.useSimpleSourceMap) {
 			sources.set("javascript", new OriginalSource(str, this.identifier()));
 		} else {
 			sources.set("javascript", new RawSource(str));

package/lib/Dependency.js

@@ -21,6 +21,7 @@
  * @typedef {Object} UpdateHashContext
  * @property {ChunkGraph} chunkGraph
  * @property {RuntimeSpec} runtime
+ * @property {RuntimeTemplate=} runtimeTemplate
  */
 
 /**

package/lib/ExportsInfo.js

@@ -416,7 +416,7 @@ class ExportsInfo {
 
 	/**
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when the module is used in any way
+	 * @returns {boolean} true, when the module exports are used in any way
 	 */
 	isUsed(runtime) {
 		if (this._redirectTo !== undefined) {
@@ -436,6 +436,17 @@ class ExportsInfo {
 		return false;
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when the module is used in any way
+	 */
+	isModuleUsed(runtime) {
+		if (this.isUsed(runtime)) return true;
+		if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused)
+			return true;
+		return false;
+	}
+
 	/**
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @returns {SortableSet<string> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
@@ -752,6 +763,8 @@ class ExportInfo {
 		this.name = name;
 		/** @private @type {string | null} */
 		this._usedName = initFrom ? initFrom._usedName : null;
+		/** @private @type {UsageStateType} */
+		this._globalUsed = initFrom ? initFrom._globalUsed : undefined;
 		/** @private @type {Map<string, RuntimeUsageStateType>} */
 		this._usedInRuntime =
 			initFrom && initFrom._usedInRuntime
@@ -907,7 +920,17 @@ class ExportInfo {
 	 * @returns {boolean} true when something has changed
 	 */
 	setUsedConditionally(condition, newValue, runtime) {
-		if (this._usedInRuntime === undefined) {
+		if (runtime === undefined) {
+			if (this._globalUsed === undefined) {
+				this._globalUsed = newValue;
+				return true;
+			} else {
+				if (this._globalUsed !== newValue && condition(this._globalUsed)) {
+					this._globalUsed = newValue;
+					return true;
+				}
+			}
+		} else if (this._usedInRuntime === undefined) {
 			if (newValue !== UsageState.Unused && condition(UsageState.Unused)) {
 				this._usedInRuntime = new Map();
 				forEachRuntime(runtime, runtime =>
@@ -944,7 +967,12 @@ class ExportInfo {
 	 * @returns {boolean} true when something has changed
 	 */
 	setUsed(newValue, runtime) {
-		if (this._usedInRuntime === undefined) {
+		if (runtime === undefined) {
+			if (this._globalUsed !== newValue) {
+				this._globalUsed = newValue;
+				return true;
+			}
+		} else if (this._usedInRuntime === undefined) {
 			if (newValue !== UsageState.Unused) {
 				this._usedInRuntime = new Map();
 				forEachRuntime(runtime, runtime =>
@@ -1023,6 +1051,7 @@ class ExportInfo {
 	 */
 	getUsed(runtime) {
 		if (!this._hasUseInRuntimeInfo) return UsageState.NoInfo;
+		if (this._globalUsed !== undefined) return this._globalUsed;
 		if (this._usedInRuntime === undefined) {
 			return UsageState.Unused;
 		} else if (typeof runtime === "string") {
@@ -1062,18 +1091,22 @@ class ExportInfo {
 	 */
 	getUsedName(fallbackName, runtime) {
 		if (this._hasUseInRuntimeInfo) {
-			if (this._usedInRuntime === undefined) return false;
-			if (typeof runtime === "string") {
-				if (!this._usedInRuntime.has(runtime)) {
-					return false;
-				}
-			} else if (runtime !== undefined) {
-				if (
-					Array.from(runtime).every(
-						runtime => !this._usedInRuntime.has(runtime)
-					)
-				) {
-					return false;
+			if (this._globalUsed !== undefined) {
+				if (this._globalUsed === UsageState.Unused) return false;
+			} else {
+				if (this._usedInRuntime === undefined) return false;
+				if (typeof runtime === "string") {
+					if (!this._usedInRuntime.has(runtime)) {
+						return false;
+					}
+				} else if (runtime !== undefined) {
+					if (
+						Array.from(runtime).every(
+							runtime => !this._usedInRuntime.has(runtime)
+						)
+					) {
+						return false;
+					}
 				}
 			}
 		}
@@ -1282,7 +1315,20 @@ class ExportInfo {
 	}
 
 	getUsedInfo() {
-		if (this._usedInRuntime !== undefined) {
+		if (this._globalUsed !== undefined) {
+			switch (this._globalUsed) {
+				case UsageState.Unused:
+					return "unused";
+				case UsageState.NoInfo:
+					return "no usage info";
+				case UsageState.Unknown:
+					return "maybe used (runtime-defined)";
+				case UsageState.Used:
+					return "used";
+				case UsageState.OnlyPropertiesUsed:
+					return "only properties used";
+			}
+		} else if (this._usedInRuntime !== undefined) {
 			/** @type {Map<RuntimeUsageStateType, string[]>} */
 			const map = new Map();
 			for (const [runtime, used] of this._usedInRuntime) {

package/lib/ExternalModule.js

@@ -293,7 +293,7 @@ class ExternalModule extends Module {
 			exportsType: undefined
 		};
 		this.buildInfo = {
-			strict: true
+			strict: this.externalType !== "this"
 		};
 		this.buildMeta.exportsType = "dynamic";
 		let canMangle = false;
@@ -412,22 +412,23 @@ class ExternalModule extends Module {
 			chunkGraph
 		);
 
-		let sourceString;
+		let sourceString = sourceData.expression;
+		if (sourceData.iife)
+			sourceString = `(function() { return ${sourceString}; }())`;
 		if (concatenationScope) {
 			sourceString = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
 				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
-			} = ${sourceData.expression};`;
+			} = ${sourceString};`;
 			concatenationScope.registerNamespaceExport(
 				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
 			);
 		} else {
-			sourceString = `module.exports = ${sourceData.expression};`;
+			sourceString = `module.exports = ${sourceString};`;
 		}
-		if (sourceData.iife) sourceString = `(function() { ${sourceString} })();`;
 		if (sourceData.init) sourceString = `${sourceData.init}\n${sourceString}`;
 
 		const sources = new Map();
-		if (this.useSourceMap) {
+		if (this.useSourceMap || this.useSimpleSourceMap) {
 			sources.set(
 				"javascript",
 				new OriginalSource(sourceString, this.identifier())

package/lib/FlagDependencyUsagePlugin.js

@@ -7,13 +7,10 @@
 
 const Dependency = require("./Dependency");
 const { UsageState } = require("./ExportsInfo");
+const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { STAGE_DEFAULT } = require("./OptimizationStages");
 const TupleQueue = require("./util/TupleQueue");
-const {
-	getEntryRuntime,
-	mergeRuntime,
-	mergeRuntimeOwned
-} = require("./util/runtime");
+const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
 
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
@@ -63,9 +60,15 @@ class FlagDependencyUsagePlugin {
 					 * @param {Module} module module to process
 					 * @param {(string[] | ReferencedExport)[]} usedExports list of used exports
 					 * @param {RuntimeSpec} runtime part of which runtime
+					 * @param {boolean} forceSideEffects always apply side effects
 					 * @returns {void}
 					 */
-					const processReferencedModule = (module, usedExports, runtime) => {
+					const processReferencedModule = (
+						module,
+						usedExports,
+						runtime,
+						forceSideEffects
+					) => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
 						if (usedExports.length > 0) {
 							if (!module.buildMeta || !module.buildMeta.exportsType) {
@@ -143,10 +146,12 @@ class FlagDependencyUsagePlugin {
 							// This module won't be evaluated in this case
 							// TODO webpack 6 remove this check
 							if (
+								!forceSideEffects &&
 								module.factoryMeta !== undefined &&
 								module.factoryMeta.sideEffectFree
-							)
+							) {
 								return;
+							}
 							if (exportsInfo.setUsedForSideEffectsOnly(runtime)) {
 								queue.enqueue(module, runtime);
 							}
@@ -166,7 +171,11 @@ class FlagDependencyUsagePlugin {
 						const queue = [module];
 						for (const block of queue) {
 							for (const b of block.blocks) {
-								if (b.groupOptions && b.groupOptions.entryOptions) {
+								if (
+									!this.global &&
+									b.groupOptions &&
+									b.groupOptions.entryOptions
+								) {
 									processModule(b, b.groupOptions.entryOptions.runtime);
 								} else {
 									queue.push(b);
@@ -174,14 +183,16 @@ class FlagDependencyUsagePlugin {
 							}
 							for (const dep of block.dependencies) {
 								const connection = moduleGraph.getConnection(dep);
-								if (
-									!connection ||
-									!connection.module ||
-									!connection.isTargetActive(runtime)
-								) {
+								if (!connection || !connection.module) {
 									continue;
 								}
+								const activeState = connection.getActiveState(runtime);
+								if (activeState === false) continue;
 								const { module } = connection;
+								if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
+									processModule(module, runtime);
+									continue;
+								}
 								const oldReferencedExports = map.get(module);
 								if (oldReferencedExports === EXPORTS_OBJECT_REFERENCED) {
 									continue;
@@ -242,12 +253,18 @@ class FlagDependencyUsagePlugin {
 
 						for (const [module, referencedExports] of map) {
 							if (Array.isArray(referencedExports)) {
-								processReferencedModule(module, referencedExports, runtime);
+								processReferencedModule(
+									module,
+									referencedExports,
+									runtime,
+									false
+								);
 							} else {
 								processReferencedModule(
 									module,
 									Array.from(referencedExports.values()),
-									runtime
+									runtime,
+									false
 								);
 							}
 						}
@@ -270,8 +287,12 @@ class FlagDependencyUsagePlugin {
 					const processEntryDependency = (dep, runtime) => {
 						const module = moduleGraph.getModule(dep);
 						if (module) {
-							processReferencedModule(module, NO_EXPORTS_REFERENCED, runtime);
-							queue.enqueue(module, runtime);
+							processReferencedModule(
+								module,
+								NO_EXPORTS_REFERENCED,
+								runtime,
+								true
+							);
 						}
 					};
 					/** @type {RuntimeSpec} */
@@ -305,31 +326,6 @@ class FlagDependencyUsagePlugin {
 					logger.timeEnd("trace exports usage in graph");
 				}
 			);
-			if (!this.global) {
-				compilation.hooks.afterChunks.tap("FlagDependencyUsagePlugin", () => {
-					/** @type {Map<Chunk, string>} */
-					const runtimeChunks = new Map();
-					for (const entrypoint of compilation.entrypoints.values()) {
-						runtimeChunks.set(
-							entrypoint.getRuntimeChunk(),
-							entrypoint.options.runtime
-						);
-					}
-					for (const entrypoint of compilation.asyncEntrypoints) {
-						runtimeChunks.set(
-							entrypoint.getRuntimeChunk(),
-							entrypoint.options.runtime
-						);
-					}
-
-					for (const [runtimeChunk, runtimeName] of runtimeChunks) {
-						const runtime = runtimeName || runtimeChunk.name;
-						for (const chunk of runtimeChunk.getAllReferencedChunks()) {
-							chunk.runtime = mergeRuntime(chunk.runtime, runtime);
-						}
-					}
-				});
-			}
 		});
 	}
 }