webpack 5.2.1 → 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

@@ -1939,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) {
@@ -2556,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();
@@ -2592,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)) {
@@ -2600,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
@@ -2623,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;
@@ -2707,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
@@ -2769,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

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/Dependency.js

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

package/lib/RuntimeGlobals.js

@@ -173,6 +173,11 @@ exports.loadScript = "__webpack_require__.l";
  */
 exports.chunkName = "__webpack_require__.cn";
 
+/**
+ * the runtime id of the current runtime
+ */
+exports.runtimeId = "__webpack_require__.j";
+
 /**
  * the filename of the script part of the chunk
  */

package/lib/RuntimePlugin.js

@@ -21,6 +21,7 @@ const HasOwnPropertyRuntimeModule = require("./runtime/HasOwnPropertyRuntimeModu
 const LoadScriptRuntimeModule = require("./runtime/LoadScriptRuntimeModule");
 const MakeNamespaceObjectRuntimeModule = require("./runtime/MakeNamespaceObjectRuntimeModule");
 const PublicPathRuntimeModule = require("./runtime/PublicPathRuntimeModule");
+const RuntimeIdRuntimeModule = require("./runtime/RuntimeIdRuntimeModule");
 const SystemContextRuntimeModule = require("./runtime/SystemContextRuntimeModule");
 const ShareRuntimeModule = require("./sharing/ShareRuntimeModule");
 const StringXor = require("./util/StringXor");
@@ -31,6 +32,7 @@ const StringXor = require("./util/StringXor");
 
 const GLOBALS_ON_REQUIRE = [
 	RuntimeGlobals.chunkName,
+	RuntimeGlobals.runtimeId,
 	RuntimeGlobals.compatGetDefaultExport,
 	RuntimeGlobals.createFakeNamespaceObject,
 	RuntimeGlobals.definePropertyGetters,
@@ -156,6 +158,12 @@ class RuntimePlugin {
 					);
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.runtimeId)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(chunk, new RuntimeIdRuntimeModule());
+					return true;
+				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.publicPath)
 				.tap("RuntimePlugin", (chunk, set) => {

package/lib/RuntimeTemplate.js

@@ -9,7 +9,9 @@ const InitFragment = require("./InitFragment");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
 const { equals } = require("./util/ArrayHelpers");
+const compileBooleanMatcher = require("./util/compileBooleanMatcher");
 const propertyAccess = require("./util/propertyAccess");
+const { forEachRuntime, subtractRuntime } = require("./util/runtime");
 
 /** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
@@ -562,6 +564,39 @@ class RuntimeTemplate {
 		return `${promise || "Promise.resolve()"}${appending}`;
 	}
 
+	/**
+	 * @param {Object} options options object
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {RuntimeSpec=} options.runtime runtime for which this code will be generated
+	 * @param {RuntimeSpec | boolean=} options.runtimeCondition only execute the statement in some runtimes
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} expression
+	 */
+	runtimeConditionExpression({
+		chunkGraph,
+		runtimeCondition,
+		runtime,
+		runtimeRequirements
+	}) {
+		if (runtimeCondition === undefined) return "true";
+		if (typeof runtimeCondition === "boolean") return `${runtimeCondition}`;
+		/** @type {Set<string>} */
+		const positiveRuntimeIds = new Set();
+		forEachRuntime(runtimeCondition, runtime =>
+			positiveRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
+		);
+		/** @type {Set<string>} */
+		const negativeRuntimeIds = new Set();
+		forEachRuntime(subtractRuntime(runtime, runtimeCondition), runtime =>
+			negativeRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
+		);
+		runtimeRequirements.add(RuntimeGlobals.runtimeId);
+		return compileBooleanMatcher.fromLists(
+			Array.from(positiveRuntimeIds),
+			Array.from(negativeRuntimeIds)
+		)(RuntimeGlobals.runtimeId);
+	}
+
 	/**
 	 *
 	 * @param {Object} options options object
@@ -572,6 +607,8 @@ class RuntimeTemplate {
 	 * @param {string} options.importVar name of the import variable
 	 * @param {Module} options.originModule module in which the statement is emitted
 	 * @param {boolean=} options.weak true, if this is a weak dependency
+	 * @param {RuntimeSpec=} options.runtime runtime for which this code will be generated
+	 * @param {RuntimeSpec | boolean=} options.runtimeCondition only execute the statement in some runtimes
 	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
 	 * @returns {[string, string]} the import statement and the compat statement
 	 */

package/lib/WebpackOptionsApply.js

@@ -308,7 +308,9 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 		if (options.optimization.sideEffects) {
 			const SideEffectsFlagPlugin = require("./optimize/SideEffectsFlagPlugin");
-			new SideEffectsFlagPlugin().apply(compiler);
+			new SideEffectsFlagPlugin(
+				options.optimization.sideEffects === true
+			).apply(compiler);
 		}
 		if (options.optimization.providedExports) {
 			const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin");

package/lib/config/defaults.js

@@ -848,7 +848,7 @@ const applyOptimizationDefaults = (
 		if (development) return "named";
 		return "natural";
 	});
-	D(optimization, "sideEffects", true);
+	F(optimization, "sideEffects", () => (production ? true : "flag"));
 	D(optimization, "providedExports", true);
 	D(optimization, "usedExports", production);
 	D(optimization, "innerGraph", production);

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const Template = require("../Template");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 const NullDependency = require("./NullDependency");
@@ -62,14 +63,41 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 	 */
 	apply(dependency, source, templateContext) {
 		const dep = /** @type {HarmonyAcceptDependency} */ (dependency);
-		const { module, runtimeTemplate } = templateContext;
+		const {
+			module,
+			runtime,
+			runtimeRequirements,
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph
+		} = templateContext;
 		const content = dep.dependencies
-			.filter(dependency =>
-				HarmonyImportDependency.Template.isImportEmitted(dependency, module)
-			)
 			.map(dependency => {
+				const referencedModule = moduleGraph.getModule(dependency);
+				return {
+					dependency,
+					runtimeCondition: referencedModule
+						? HarmonyImportDependency.Template.getImportEmittedRuntime(
+								module,
+								referencedModule
+						  )
+						: false
+				};
+			})
+			.filter(({ runtimeCondition }) => runtimeCondition !== false)
+			.map(({ dependency, runtimeCondition }) => {
+				const condition = runtimeTemplate.runtimeConditionExpression({
+					chunkGraph,
+					runtime,
+					runtimeCondition,
+					runtimeRequirements
+				});
 				const s = dependency.getImportStatement(true, templateContext);
-				return s[0] + s[1];
+				const code = s[0] + s[1];
+				if (condition !== "true") {
+					return `if (${condition}) {\n${Template.indent(code)}\n}\n`;
+				}
+				return code;
 			})
 			.join("");
 

package/lib/dependencies/HarmonyImportDependency.js

@@ -5,11 +5,13 @@
 
 "use strict";
 
+const ConditionalInitFragment = require("../ConditionalInitFragment");
 const Dependency = require("../Dependency");
 const HarmonyLinkingError = require("../HarmonyLinkingError");
 const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
+const { filterRuntime, mergeRuntime } = require("../util/runtime");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -199,21 +201,38 @@ class HarmonyImportDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		const { chunkGraph } = context;
+		const { chunkGraph, runtime, runtimeTemplate } = context;
 		const { moduleGraph } = chunkGraph;
 		super.updateHash(hash, context);
-		const importedModule = moduleGraph.getModule(this);
-		if (importedModule) {
-			const parentModule = moduleGraph.getParentModule(this);
-			hash.update(
-				importedModule.getExportsType(
-					moduleGraph,
-					parentModule.buildMeta && parentModule.buildMeta.strictHarmonyModule
-				)
-			);
-			if (moduleGraph.isAsync(importedModule)) hash.update("async");
-		}
 		hash.update(`${this.sourceOrder}`);
+		const connection = moduleGraph.getConnection(this);
+		if (connection) {
+			const importedModule = connection.module;
+			if (importedModule) {
+				const parentModule = moduleGraph.getParentModule(this);
+				hash.update(
+					importedModule.getExportsType(
+						moduleGraph,
+						parentModule.buildMeta && parentModule.buildMeta.strictHarmonyModule
+					)
+				);
+				if (moduleGraph.isAsync(importedModule)) hash.update("async");
+			}
+			if (runtimeTemplate) {
+				const runtimeRequirements = new Set();
+				hash.update(
+					runtimeTemplate.runtimeConditionExpression({
+						chunkGraph,
+						runtimeCondition: filterRuntime(runtime, runtime => {
+							return connection.isTargetActive(runtime);
+						}),
+						runtime,
+						runtimeRequirements
+					})
+				);
+				for (const rr of runtimeRequirements) hash.update(rr);
+			}
+		}
 	}
 
 	serialize(context) {
@@ -231,6 +250,7 @@ class HarmonyImportDependency extends ModuleDependency {
 
 module.exports = HarmonyImportDependency;
 
+/** @type {WeakMap<Module, WeakMap<Module, RuntimeSpec | boolean>>} */
 const importEmittedMap = new WeakMap();
 
 HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends ModuleDependency.Template {
@@ -265,23 +285,42 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 			: dep.request;
 		const key = `harmony import ${moduleKey}`;
 
-		if (module) {
-			let emittedModules = importEmittedMap.get(dep);
+		const runtimeCondition = dep.weak
+			? false
+			: connection
+			? filterRuntime(runtime, r => connection.isTargetActive(r))
+			: true;
+
+		if (module && referencedModule) {
+			let emittedModules = importEmittedMap.get(module);
 			if (emittedModules === undefined) {
-				emittedModules = new WeakSet();
-				importEmittedMap.set(dep, emittedModules);
+				emittedModules = new WeakMap();
+				importEmittedMap.set(module, emittedModules);
+			}
+			let mergedRuntimeCondition = runtimeCondition;
+			const oldRuntimeCondition = emittedModules.get(referencedModule) || false;
+			if (oldRuntimeCondition !== false && mergedRuntimeCondition !== true) {
+				if (mergedRuntimeCondition === false || oldRuntimeCondition === true) {
+					mergedRuntimeCondition = oldRuntimeCondition;
+				} else {
+					mergedRuntimeCondition = mergeRuntime(
+						oldRuntimeCondition,
+						mergedRuntimeCondition
+					);
+				}
 			}
-			emittedModules.add(module);
+			emittedModules.set(referencedModule, mergedRuntimeCondition);
 		}
 
 		const importStatement = dep.getImportStatement(false, templateContext);
 		if (templateContext.moduleGraph.isAsync(referencedModule)) {
 			templateContext.initFragments.push(
-				new InitFragment(
+				new ConditionalInitFragment(
 					importStatement[0],
 					InitFragment.STAGE_HARMONY_IMPORTS,
 					dep.sourceOrder,
-					key
+					key,
+					runtimeCondition
 				)
 			);
 			templateContext.initFragments.push(
@@ -290,20 +329,22 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 				)
 			);
 			templateContext.initFragments.push(
-				new InitFragment(
+				new ConditionalInitFragment(
 					importStatement[1],
 					InitFragment.STAGE_ASYNC_HARMONY_IMPORTS,
 					dep.sourceOrder,
-					key + " compat"
+					key + " compat",
+					runtimeCondition
 				)
 			);
 		} else {
 			templateContext.initFragments.push(
-				new InitFragment(
+				new ConditionalInitFragment(
 					importStatement[0] + importStatement[1],
 					InitFragment.STAGE_HARMONY_IMPORTS,
 					dep.sourceOrder,
-					key
+					key,
+					runtimeCondition
 				)
 			);
 		}
@@ -311,12 +352,13 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 
 	/**
 	 *
-	 * @param {Dependency} dep the dependency
 	 * @param {Module} module the module
-	 * @returns {boolean} true, when for this dependency and module a import init fragment was created
+	 * @param {Module} referencedModule the referenced module
+	 * @returns {RuntimeSpec | boolean} runtimeCondition in which this import has been emitted
 	 */
-	static isImportEmitted(dep, module) {
-		const emittedModules = importEmittedMap.get(dep);
-		return emittedModules !== undefined && emittedModules.has(module);
+	static getImportEmittedRuntime(module, referencedModule) {
+		const emittedModules = importEmittedMap.get(module);
+		if (emittedModules === undefined) return false;
+		return emittedModules.get(referencedModule) || false;
 	}
 };

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -196,7 +196,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		const { chunkGraph } = context;
+		const { chunkGraph, runtime } = context;
 		super.updateHash(hash, context);
 		const moduleGraph = chunkGraph.moduleGraph;
 		const importedModule = moduleGraph.getModule(this);
@@ -204,7 +204,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		hash.update(ids.join());
 		if (importedModule) {
 			const exportsInfo = moduleGraph.getExportsInfo(importedModule);
-			hash.update(`${exportsInfo.getUsedName(ids, context.runtime)}`);
+			hash.update(`${exportsInfo.getUsedName(ids, runtime)}`);
 		}
 	}
 

package/lib/dependencies/PureExpressionDependency.js

@@ -7,6 +7,7 @@
 
 const { UsageState } = require("../ExportsInfo");
 const makeSerializable = require("../util/makeSerializable");
+const { filterRuntime } = require("../util/runtime");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -74,22 +75,45 @@ PureExpressionDependency.Template = class PureExpressionDependencyTemplate exten
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { moduleGraph, runtime }) {
+	apply(
+		dependency,
+		source,
+		{ chunkGraph, moduleGraph, runtime, runtimeTemplate, runtimeRequirements }
+	) {
 		const dep = /** @type {PureExpressionDependency} */ (dependency);
 
-		if (dep.usedByExports !== false) {
+		const usedByExports = dep.usedByExports;
+		if (usedByExports !== false) {
 			const selfModule = moduleGraph.getParentModule(dep);
 			const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-			for (const exportName of dep.usedByExports) {
-				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
-					return;
+			const runtimeCondition = filterRuntime(runtime, runtime => {
+				for (const exportName of usedByExports) {
+					if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
+						return true;
+					}
 				}
+				return false;
+			});
+			if (runtimeCondition === true) return;
+			if (runtimeCondition !== false) {
+				const condition = runtimeTemplate.runtimeConditionExpression({
+					chunkGraph,
+					runtime,
+					runtimeCondition,
+					runtimeRequirements
+				});
+				source.insert(
+					dep.range[0],
+					`(/* runtime-dependent pure expression or super */ ${condition} ? (`
+				);
+				source.insert(dep.range[1], ") : null)");
+				return;
 			}
 		}
 
 		source.insert(
 			dep.range[0],
-			"(/* unused pure expression or super */ null && ("
+			`(/* unused pure expression or super */ null && (`
 		);
 		source.insert(dep.range[1], "))");
 	}

package/lib/dependencies/WorkerPlugin.js

@@ -12,6 +12,7 @@ const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const formatLocation = require("../formatLocation");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 const { equals } = require("../util/ArrayHelpers");
+const { contextify } = require("../util/identifier");
 const {
 	harmonySpecifierTag
 } = require("./HarmonyImportDependencyParserPlugin");
@@ -48,6 +49,10 @@ class WorkerPlugin {
 		if (this._chunkLoading) {
 			new EnableChunkLoadingPlugin(this._chunkLoading).apply(compiler);
 		}
+		const cachedContextify = contextify.bindContextCache(
+			compiler.context,
+			compiler.root
+		);
 		compiler.hooks.thisCompilation.tap(
 			"WorkerPlugin",
 			(compilation, { normalModuleFactory }) => {
@@ -213,9 +218,9 @@ class WorkerPlugin {
 							}
 
 							if (!entryOptions.runtime) {
-								entryOptions.runtime = `${parser.state.module.identifier()}|${formatLocation(
-									expr.loc
-								)}`;
+								entryOptions.runtime = `${cachedContextify(
+									parser.state.module.identifier()
+								)}|${formatLocation(expr.loc)}`;
 							}
 
 							const block = new AsyncDependenciesBlock({