webpack 5.2.1 → 5.4.0

package/lib/optimize/ConcatenatedModule.js

@@ -25,6 +25,14 @@ const createHash = require("../util/createHash");
 const contextify = require("../util/identifier").contextify;
 const makeSerializable = require("../util/makeSerializable");
 const propertyAccess = require("../util/propertyAccess");
+const {
+	filterRuntime,
+	intersectRuntime,
+	mergeRuntimeCondition,
+	mergeRuntimeConditionNonFalse,
+	runtimeConditionToString,
+	subtractRuntimeCondition
+} = require("../util/runtime");
 
 /** @typedef {import("eslint-scope").Scope} Scope */
 /** @typedef {import("webpack-sources").Source} Source */
@@ -76,6 +84,7 @@ const propertyAccess = require("../util/propertyAccess");
  */
 
 /** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo } ModuleInfo */
+/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo | ReferenceToModuleInfo } ModuleInfoOrReference */
 
 /**
  * @typedef {Object} ConcatenatedModuleInfo
@@ -95,6 +104,8 @@ const propertyAccess = require("../util/propertyAccess");
  * @property {string} namespaceObjectName
  * @property {boolean} interopNamespaceObjectUsed
  * @property {string} interopNamespaceObjectName
+ * @property {boolean} interopNamespaceObject2Used
+ * @property {string} interopNamespaceObject2Name
  * @property {boolean} interopDefaultAccessUsed
  * @property {string} interopDefaultAccessName
  */
@@ -103,14 +114,24 @@ const propertyAccess = require("../util/propertyAccess");
  * @typedef {Object} ExternalModuleInfo
  * @property {"external"} type
  * @property {Module} module
+ * @property {RuntimeSpec | boolean} runtimeCondition
  * @property {number} index
  * @property {string} name
  * @property {boolean} interopNamespaceObjectUsed
  * @property {string} interopNamespaceObjectName
+ * @property {boolean} interopNamespaceObject2Used
+ * @property {string} interopNamespaceObject2Name
  * @property {boolean} interopDefaultAccessUsed
  * @property {string} interopDefaultAccessName
  */
 
+/**
+ * @typedef {Object} ReferenceToModuleInfo
+ * @property {"reference"} type
+ * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {ConcatenatedModuleInfo | ExternalModuleInfo} target
+ */
+
 const RESERVED_NAMES = [
 	// internal names (should always be renamed)
 	ConcatenationScope.DEFAULT_EXPORT,
@@ -185,6 +206,7 @@ const joinIterableWithComma = iterable => {
  * @typedef {Object} ConcatenationEntry
  * @property {"concatenated" | "external"} type
  * @property {Module} module
+ * @property {RuntimeSpec | boolean} runtimeCondition
  */
 
 /**
@@ -223,6 +245,13 @@ const getFinalBinding = (
 	if (exportName.length === 0) {
 		switch (exportsType) {
 			case "default-only":
+				info.interopNamespaceObject2Used = true;
+				return {
+					info,
+					rawName: info.interopNamespaceObject2Name,
+					ids: exportName,
+					exportName
+				};
 			case "default-with-named":
 				info.interopNamespaceObjectUsed = true;
 				return {
@@ -568,28 +597,17 @@ const getPathInAst = (ast, node) => {
 	}
 };
 
-/**
- * @param {ModuleInfo[]} modulesWithInfo modules
- * @returns {Map<Module, ModuleInfo>} mapping
- */
-const modulesWithInfoToMap = modulesWithInfo => {
-	const moduleToInfoMap = new Map();
-	for (const m of modulesWithInfo) {
-		moduleToInfoMap.set(m.module, m);
-	}
-	return moduleToInfoMap;
-};
-
 const TYPES = new Set(["javascript"]);
 
 class ConcatenatedModule extends Module {
 	/**
 	 * @param {Module} rootModule the root module of the concatenation
 	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
+	 * @param {RuntimeSpec} runtime the runtime
 	 * @param {Object=} associatedObjectForCache object for caching
 	 * @returns {ConcatenatedModule} the module
 	 */
-	static create(rootModule, modules, associatedObjectForCache) {
+	static create(rootModule, modules, runtime, associatedObjectForCache) {
 		const identifier = ConcatenatedModule._createIdentifier(
 			rootModule,
 			modules,
@@ -598,7 +616,8 @@ class ConcatenatedModule extends Module {
 		return new ConcatenatedModule({
 			identifier,
 			rootModule,
-			modules
+			modules,
+			runtime
 		});
 	}
 
@@ -606,9 +625,10 @@ class ConcatenatedModule extends Module {
 	 * @param {Object} options options
 	 * @param {string} options.identifier the identifier of the module
 	 * @param {Module=} options.rootModule the root module of the concatenation
+	 * @param {RuntimeSpec} options.runtime the selected runtime
 	 * @param {Set<Module>=} options.modules all concatenated modules
 	 */
-	constructor({ identifier, rootModule, modules }) {
+	constructor({ identifier, rootModule, modules, runtime }) {
 		super("javascript/esm", null);
 
 		// Info from Factory
@@ -618,6 +638,7 @@ class ConcatenatedModule extends Module {
 		this.rootModule = rootModule;
 		/** @type {Set<Module>} */
 		this._modules = modules;
+		this._runtime = runtime;
 		this.factoryMeta = rootModule && rootModule.factoryMeta;
 
 		// Caching
@@ -637,6 +658,7 @@ class ConcatenatedModule extends Module {
 		this._identifier = m._identifier;
 		this.rootModule = m.rootModule;
 		this._modules = m._modules;
+		this._runtime = m._runtime;
 	}
 	/**
 	 * @returns {Set<string>} types available (do not mutate)
@@ -784,12 +806,12 @@ class ConcatenatedModule extends Module {
 	_createConcatenationList(rootModule, modulesSet, runtime, moduleGraph) {
 		/** @type {ConcatenationEntry[]} */
 		const list = [];
-		/** @type {Set<Module>} */
-		const existingEntries = new Set();
+		/** @type {Map<Module, RuntimeSpec | true>} */
+		const existingEntries = new Map();
 
 		/**
 		 * @param {Module} module a module
-		 * @returns {ModuleGraphConnection[]} imported modules in order
+		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} imported modules in order
 		 */
 		const getConcatenatedImports = module => {
 			let connections = Array.from(moduleGraph.getOutgoingConnections(module));
@@ -816,29 +838,91 @@ class ConcatenatedModule extends Module {
 			references.sort(
 				concatComparators(bySourceOrder, keepOriginalOrder(references))
 			);
-			return references.map(({ connection }) => connection);
+			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} */
+			const referencesMap = new Map();
+			for (const { connection } of references) {
+				const runtimeCondition = filterRuntime(runtime, r =>
+					connection.isTargetActive(r)
+				);
+				if (runtimeCondition === false) continue;
+				const module = connection.module;
+				const entry = referencesMap.get(module);
+				if (entry === undefined) {
+					referencesMap.set(module, { connection, runtimeCondition });
+					continue;
+				}
+				entry.runtimeCondition = mergeRuntimeConditionNonFalse(
+					entry.runtimeCondition,
+					runtimeCondition,
+					runtime
+				);
+			}
+			return referencesMap.values();
 		};
 
 		/**
 		 * @param {ModuleGraphConnection} connection graph connection
+		 * @param {RuntimeSpec | true} runtimeCondition runtime condition
 		 * @returns {void}
 		 */
-		const enterModule = connection => {
+		const enterModule = (connection, runtimeCondition) => {
 			const module = connection.module;
 			if (!module) return;
-			if (existingEntries.has(module)) {
+			const existingEntry = existingEntries.get(module);
+			if (existingEntry === true) {
 				return;
 			}
 			if (modulesSet.has(module)) {
-				existingEntries.add(module);
+				existingEntries.set(module, true);
+				if (runtimeCondition !== true) {
+					throw new Error(
+						`Cannot runtime-conditional concatenate a module (${module.identifier()} in ${this.rootModule.identifier()}, ${runtimeConditionToString(
+							runtimeCondition
+						)}). This should not happen.`
+					);
+				}
 				const imports = getConcatenatedImports(module);
-				imports.forEach(enterModule);
+				for (const { connection, runtimeCondition } of imports)
+					enterModule(connection, runtimeCondition);
 				list.push({
 					type: "concatenated",
-					module: connection.module
+					module: connection.module,
+					runtimeCondition
 				});
 			} else {
-				existingEntries.add(connection.module);
+				if (existingEntry !== undefined) {
+					const reducedRuntimeCondition = subtractRuntimeCondition(
+						runtimeCondition,
+						existingEntry,
+						runtime
+					);
+					if (reducedRuntimeCondition === false) return;
+					runtimeCondition = reducedRuntimeCondition;
+					existingEntries.set(
+						connection.module,
+						mergeRuntimeConditionNonFalse(
+							existingEntry,
+							runtimeCondition,
+							runtime
+						)
+					);
+				} else {
+					existingEntries.set(connection.module, runtimeCondition);
+				}
+				if (list.length > 0) {
+					const lastItem = list[list.length - 1];
+					if (
+						lastItem.type === "external" &&
+						lastItem.module === connection.module
+					) {
+						lastItem.runtimeCondition = mergeRuntimeCondition(
+							lastItem.runtimeCondition,
+							runtimeCondition,
+							runtime
+						);
+						return;
+					}
+				}
 				list.push({
 					type: "external",
 					get module() {
@@ -846,17 +930,20 @@ class ConcatenatedModule extends Module {
 						// could be replaced by some other process (i. e. also replaced with a
 						// concatenated module)
 						return connection.module;
-					}
+					},
+					runtimeCondition
 				});
 			}
 		};
 
-		existingEntries.add(rootModule);
+		existingEntries.set(rootModule, true);
 		const imports = getConcatenatedImports(rootModule);
-		imports.forEach(enterModule);
+		for (const { connection, runtimeCondition } of imports)
+			enterModule(connection, runtimeCondition);
 		list.push({
 			type: "concatenated",
-			module: rootModule
+			module: rootModule,
+			runtimeCondition: true
 		});
 
 		return list;
@@ -908,17 +995,18 @@ class ConcatenatedModule extends Module {
 		runtimeTemplate,
 		moduleGraph,
 		chunkGraph,
-		runtime
+		runtime: generationRuntime
 	}) {
 		/** @type {Set<string>} */
 		const runtimeRequirements = new Set();
+		const runtime = intersectRuntime(generationRuntime, this._runtime);
 
 		const requestShortener = runtimeTemplate.requestShortener;
 		// Meta info for each module
-		const modulesWithInfo = this._getModulesWithInfo(moduleGraph, runtime);
-
-		// Create mapping from module to info
-		const moduleToInfoMap = modulesWithInfoToMap(modulesWithInfo);
+		const [modulesWithInfo, moduleToInfoMap] = this._getModulesWithInfo(
+			moduleGraph,
+			runtime
+		);
 
 		// Set with modules that need a generated namespace object
 		/** @type {Set<ConcatenatedModuleInfo>} */
@@ -926,9 +1014,9 @@ class ConcatenatedModule extends Module {
 
 		// Generate source code and analyse scopes
 		// Prepare a ReplaceSource for the final source
-		for (const info of modulesWithInfo) {
+		for (const info of moduleToInfoMap.values()) {
 			this._analyseModule(
-				modulesWithInfo,
+				moduleToInfoMap,
 				info,
 				dependencyTemplates,
 				runtimeTemplate,
@@ -968,16 +1056,20 @@ class ConcatenatedModule extends Module {
 		// get all global names
 		for (const info of modulesWithInfo) {
 			if (info.type === "concatenated") {
-				const superClassExpressions = [];
-
 				// ignore symbols from moduleScope
 				if (info.moduleScope) {
 					ignoredScopes.add(info.moduleScope);
+				}
 
-					// The super class expression in class scopes behaves weird
-					// We store ranges of all super class expressions to make
-					// renaming to work correctly
-					for (const childScope of info.moduleScope.childScopes) {
+				// The super class expression in class scopes behaves weird
+				// We get ranges of all super class expressions to make
+				// renaming to work correctly
+				const superClassCache = new WeakMap();
+				const getSuperClassExpressions = scope => {
+					const cacheEntry = superClassCache.get(scope);
+					if (cacheEntry !== undefined) return cacheEntry;
+					const superClassExpressions = [];
+					for (const childScope of scope.childScopes) {
 						if (childScope.type !== "class") continue;
 						const block = childScope.block;
 						if (
@@ -991,7 +1083,9 @@ class ConcatenatedModule extends Module {
 							});
 						}
 					}
-				}
+					superClassCache.set(scope, superClassExpressions);
+					return superClassExpressions;
+				};
 
 				// add global symbols
 				if (info.globalScope) {
@@ -1000,9 +1094,12 @@ class ConcatenatedModule extends Module {
 						if (ConcatenationScope.isModuleReference(name)) {
 							const match = ConcatenationScope.matchModuleReference(name);
 							if (!match) continue;
+							const referencedInfo = modulesWithInfo[match.index];
+							if (referencedInfo.type === "reference")
+								throw new Error("Module reference can't point to a reference");
 							const binding = getFinalBinding(
 								moduleGraph,
-								modulesWithInfo[match.index],
+								referencedInfo,
 								match.ids,
 								moduleToInfoMap,
 								runtime,
@@ -1021,7 +1118,7 @@ class ConcatenatedModule extends Module {
 								binding.info.module.identifier(),
 								"name" in binding ? binding.name : ""
 							);
-							for (const expr of superClassExpressions) {
+							for (const expr of getSuperClassExpressions(reference.from)) {
 								if (
 									expr.range[0] <= reference.identifier.range[0] &&
 									expr.range[1] >= reference.identifier.range[1]
@@ -1046,7 +1143,7 @@ class ConcatenatedModule extends Module {
 		}
 
 		// generate names for symbols
-		for (const info of modulesWithInfo) {
+		for (const info of moduleToInfoMap.values()) {
 			const { usedNames: namespaceObjectUsedNames } = getUsedNamesInScopeInfo(
 				info.module.identifier(),
 				""
@@ -1129,12 +1226,7 @@ class ConcatenatedModule extends Module {
 					break;
 				}
 			}
-			if (
-				info.module.buildMeta.exportsType === "default" ||
-				info.module.buildMeta.exportsType === "flagged" ||
-				info.module.buildMeta.exportsType === "dynamic" ||
-				!info.module.buildMeta.exportsType
-			) {
+			if (info.module.buildMeta.exportsType !== "namespace") {
 				const externalNameInterop = this.findNewName(
 					"namespaceObject",
 					allUsedNames,
@@ -1144,6 +1236,19 @@ class ConcatenatedModule extends Module {
 				allUsedNames.add(externalNameInterop);
 				info.interopNamespaceObjectName = externalNameInterop;
 			}
+			if (
+				info.module.buildMeta.exportsType === "default" &&
+				info.module.buildMeta.defaultObject !== "redirect"
+			) {
+				const externalNameInterop = this.findNewName(
+					"namespaceObject2",
+					allUsedNames,
+					namespaceObjectUsedNames,
+					info.module.readableIdentifier(requestShortener)
+				);
+				allUsedNames.add(externalNameInterop);
+				info.interopNamespaceObject2Name = externalNameInterop;
+			}
 			if (
 				info.module.buildMeta.exportsType === "dynamic" ||
 				!info.module.buildMeta.exportsType
@@ -1160,15 +1265,18 @@ class ConcatenatedModule extends Module {
 		}
 
 		// Find and replace references to modules
-		for (const info of modulesWithInfo) {
+		for (const info of moduleToInfoMap.values()) {
 			if (info.type === "concatenated") {
 				for (const reference of info.globalScope.through) {
 					const name = reference.identifier.name;
 					const match = ConcatenationScope.matchModuleReference(name);
 					if (match) {
+						const referencedInfo = modulesWithInfo[match.index];
+						if (referencedInfo.type === "reference")
+							throw new Error("Module reference can't point to a reference");
 						const finalName = getFinalName(
 							moduleGraph,
-							modulesWithInfo[match.index],
+							referencedInfo,
 							match.ids,
 							moduleToInfoMap,
 							runtime,
@@ -1335,8 +1443,10 @@ ${defineGetters}`
 		}
 
 		// evaluate modules in order
-		for (const info of modulesWithInfo) {
+		for (const rawInfo of modulesWithInfo) {
 			let name;
+			let isConditional = false;
+			const info = rawInfo.type === "reference" ? rawInfo.target : rawInfo;
 			switch (info.type) {
 				case "concatenated": {
 					result.add(
@@ -1353,13 +1463,26 @@ ${defineGetters}`
 					name = info.namespaceObjectName;
 					break;
 				}
-				case "external":
+				case "external": {
 					result.add(
 						`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
 							requestShortener
 						)}\n`
 					);
 					runtimeRequirements.add(RuntimeGlobals.require);
+					const {
+						runtimeCondition
+					} = /** @type {ExternalModuleInfo | ReferenceToModuleInfo} */ (rawInfo);
+					const condition = runtimeTemplate.runtimeConditionExpression({
+						chunkGraph,
+						runtimeCondition,
+						runtime,
+						runtimeRequirements
+					});
+					if (condition !== "true") {
+						isConditional = true;
+						result.add(`if (${condition}) {\n`);
+					}
 					result.add(
 						`var ${info.name} = __webpack_require__(${JSON.stringify(
 							chunkGraph.getModuleId(info.module)
@@ -1367,33 +1490,32 @@ ${defineGetters}`
 					);
 					name = info.name;
 					break;
+				}
 				default:
 					// @ts-expect-error never is expected here
 					throw new Error(`Unsupported concatenation entry type ${info.type}`);
 			}
 			if (info.interopNamespaceObjectUsed) {
-				if (info.module.buildMeta.exportsType === "default") {
-					runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-					result.add(
-						`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name}, 2);\n`
-					);
-				} else if (
-					info.module.buildMeta.exportsType === "flagged" ||
-					info.module.buildMeta.exportsType === "dynamic" ||
-					!info.module.buildMeta.exportsType
-				) {
-					runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-					result.add(
-						`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name});\n`
-					);
-				}
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				result.add(
+					`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name}, 2);`
+				);
+			}
+			if (info.interopNamespaceObject2Used) {
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				result.add(
+					`\nvar ${info.interopNamespaceObject2Name} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name});`
+				);
 			}
 			if (info.interopDefaultAccessUsed) {
 				runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
 				result.add(
-					`\nvar ${info.interopDefaultAccessName} = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${name});\n`
+					`\nvar ${info.interopDefaultAccessName} = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${name});`
 				);
 			}
+			if (isConditional) {
+				result.add("\n}");
+			}
 		}
 
 		/** @type {CodeGenerationResult} */
@@ -1406,7 +1528,7 @@ ${defineGetters}`
 	}
 
 	/**
-	 * @param {ModuleInfo[]} modulesWithInfo modulesWithInfo
+	 * @param {Map<Module, ModuleInfo>} modulesMap modulesMap
 	 * @param {ModuleInfo} info info
 	 * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
 	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
@@ -1415,7 +1537,7 @@ ${defineGetters}`
 	 * @param {RuntimeSpec} runtime runtime
 	 */
 	_analyseModule(
-		modulesWithInfo,
+		modulesMap,
 		info,
 		dependencyTemplates,
 		runtimeTemplate,
@@ -1427,10 +1549,7 @@ ${defineGetters}`
 			const m = info.module;
 			try {
 				// Create a concatenation scope to track and capture information
-				const concatenationScope = new ConcatenationScope(
-					modulesWithInfo,
-					info
-				);
+				const concatenationScope = new ConcatenationScope(modulesMap, info);
 
 				// TODO cache codeGeneration results
 				const codeGenResult = m.codeGeneration({
@@ -1502,7 +1621,7 @@ ${defineGetters}`
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {ModuleInfo[]} module info items
+	 * @returns {[ModuleInfoOrReference[], Map<Module, ModuleInfo>]} module info items
 	 */
 	_getModulesWithInfo(moduleGraph, runtime) {
 		const orderedConcatenationList = this._createConcatenationList(
@@ -1511,45 +1630,69 @@ ${defineGetters}`
 			runtime,
 			moduleGraph
 		);
-		return orderedConcatenationList.map((info, index) => {
-			switch (info.type) {
-				case "concatenated": {
-					return {
-						type: "concatenated",
-						module: info.module,
-						index,
-						ast: undefined,
-						internalSource: undefined,
-						runtimeRequirements: undefined,
-						source: undefined,
-						globalScope: undefined,
-						moduleScope: undefined,
-						internalNames: new Map(),
-						exportMap: undefined,
-						rawExportMap: undefined,
-						namespaceExportSymbol: undefined,
-						namespaceObjectName: undefined,
-						interopNamespaceObjectUsed: false,
-						interopNamespaceObjectName: undefined,
-						interopDefaultAccessUsed: false,
-						interopDefaultAccessName: undefined
-					};
+		/** @type {Map<Module, ModuleInfo>} */
+		const map = new Map();
+		const list = orderedConcatenationList.map((info, index) => {
+			let item = map.get(info.module);
+			if (item === undefined) {
+				switch (info.type) {
+					case "concatenated":
+						item = {
+							type: "concatenated",
+							module: info.module,
+							index,
+							ast: undefined,
+							internalSource: undefined,
+							runtimeRequirements: undefined,
+							source: undefined,
+							globalScope: undefined,
+							moduleScope: undefined,
+							internalNames: new Map(),
+							exportMap: undefined,
+							rawExportMap: undefined,
+							namespaceExportSymbol: undefined,
+							namespaceObjectName: undefined,
+							interopNamespaceObjectUsed: false,
+							interopNamespaceObjectName: undefined,
+							interopNamespaceObject2Used: false,
+							interopNamespaceObject2Name: undefined,
+							interopDefaultAccessUsed: false,
+							interopDefaultAccessName: undefined
+						};
+						break;
+					case "external":
+						item = {
+							type: "external",
+							module: info.module,
+							runtimeCondition: info.runtimeCondition,
+							index,
+							name: undefined,
+							interopNamespaceObjectUsed: false,
+							interopNamespaceObjectName: undefined,
+							interopNamespaceObject2Used: false,
+							interopNamespaceObject2Name: undefined,
+							interopDefaultAccessUsed: false,
+							interopDefaultAccessName: undefined
+						};
+						break;
+					default:
+						throw new Error(
+							`Unsupported concatenation entry type ${info.type}`
+						);
 				}
-				case "external":
-					return {
-						type: "external",
-						module: info.module,
-						index,
-						name: undefined,
-						interopNamespaceObjectUsed: false,
-						interopNamespaceObjectName: undefined,
-						interopDefaultAccessUsed: false,
-						interopDefaultAccessName: undefined
-					};
-				default:
-					throw new Error(`Unsupported concatenation entry type ${info.type}`);
+				map.set(item.module, item);
+				return item;
+			} else {
+				/** @type {ReferenceToModuleInfo} */
+				const ref = {
+					type: "reference",
+					runtimeCondition: info.runtimeCondition,
+					target: item
+				};
+				return ref;
 			}
 		});
+		return [list, map];
 	}
 
 	findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
@@ -1601,7 +1744,7 @@ ${defineGetters}`
 		for (const info of this._createConcatenationList(
 			this.rootModule,
 			this._modules,
-			runtime,
+			intersectRuntime(runtime, this._runtime),
 			chunkGraph.moduleGraph
 		)) {
 			switch (info.type) {
@@ -1610,6 +1753,7 @@ ${defineGetters}`
 					break;
 				case "external":
 					hash.update(`${chunkGraph.getModuleId(info.module)}`);
+					// TODO runtimeCondition
 					break;
 			}
 		}
@@ -1620,7 +1764,8 @@ ${defineGetters}`
 		const obj = new ConcatenatedModule({
 			identifier: undefined,
 			rootModule: undefined,
-			modules: undefined
+			modules: undefined,
+			runtime: undefined
 		});
 		obj.deserialize(context);
 		return obj;