webpack 5.110.2 → 5.111.0

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -14,9 +14,11 @@ const Template = require("../Template");
 const {
 	InlinedUsedName,
 	isExportInlined,
-	isInlineEnabled
+	isInlineEnabled,
+	isInlineExportsEnabled
 } = require("../optimize/InlineExports");
 const {
+	getKnownExportNames,
 	getMakeDeferredNamespaceModeFromExportsType
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
 const { countIterable } = require("../util/IterableHelpers");
@@ -29,6 +31,9 @@ const {
 	keyToRuntime
 } = require("../util/runtime");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
+
+const { ExportBindingType } = HarmonyExportInitFragment;
+
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 const HarmonyLinkingError = require("./HarmonyLinkingError");
 const { ImportPhaseUtils } = require("./ImportPhase");
@@ -44,7 +49,8 @@ const processExportInfo = require("./processExportInfo");
  * 	RawReferencedExports,
  * 	ReferencedExports,
  * 	TRANSITIVE,
- * 	ExportInfoName
+ * 	ExportInfoName,
+ * 	UpdateHashContext
  * } from "../Dependency"
  */
 /** @import { DependencyTemplateContext } from "../DependencyTemplate" */
@@ -58,6 +64,7 @@ const processExportInfo = require("./processExportInfo");
  * } from "../Module"
  */
 /** @import ModuleGraph from "../ModuleGraph" */
+/** @import Hash from "../util/Hash" */
 /**
  * @import ModuleGraphConnection, {
  * 	ConnectionState
@@ -237,12 +244,28 @@ const isStarReexportBackToParent = (moduleGraph, exportInfo, parentModule) => {
 	}
 };
 
+/**
+ * Two `export *` sources are ambiguous for a name when they resolve to
+ * different bindings; a diamond re-export of the same binding is not.
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {InstanceType<ExportInfo>} previous export info of the star source that first provided the name
+ * @param {InstanceType<ExportInfo>} exportInfo export info of a later star source providing the same name
+ * @returns {boolean} true when the two sources provide different bindings
+ */
+const isAmbiguousWith = (moduleGraph, previous, exportInfo) => {
+	const previousBinding = previous.getTerminalBinding(moduleGraph);
+	if (!previousBinding) return false;
+	const binding = exportInfo.getTerminalBinding(moduleGraph);
+	if (!binding) return false;
+	return previousBinding !== binding;
+};
+
 /**
  * Determine export assignments.
  * @param {ModuleGraph} moduleGraph module graph
  * @param {HarmonyExportImportedSpecifierDependency[]} dependencies dependencies
  * @param {HarmonyExportImportedSpecifierDependency=} additionalDependency additional dependency
- * @returns {{ names: ExportInfoName[], dependencyIndices: DependencyIndices }} result
+ * @returns {{ names: ExportInfoName[], dependencyIndices: DependencyIndices, conflicting: Set<ExportInfoName> | undefined }} result
  */
 const determineExportAssignments = (
 	moduleGraph,
@@ -253,6 +276,10 @@ const determineExportAssignments = (
 	const names = new Set();
 	/** @type {DependencyIndices} */
 	const dependencyIndices = [];
+	/** @type {Map<ExportInfoName, InstanceType<ExportInfo>>} */
+	const firstProvider = new Map();
+	/** @type {Set<ExportInfoName> | undefined} */
+	let conflicting;
 
 	if (additionalDependency) {
 		dependencies = [...dependencies, additionalDependency];
@@ -270,24 +297,42 @@ const determineExportAssignments = (
 		if (otherImportedModule) {
 			const exportsInfo = moduleGraph.getExportsInfo(otherImportedModule);
 			for (const exportInfo of exportsInfo.exports) {
+				if (exportInfo.provided !== true || exportInfo.name === "default") {
+					continue;
+				}
+				if (names.has(exportInfo.name)) {
+					const previous =
+						/** @type {InstanceType<ExportInfo>} */
+						(firstProvider.get(exportInfo.name));
+					if (
+						isAmbiguousWith(moduleGraph, previous, exportInfo) &&
+						// A cyclic contribution resolves to nothing, so it never competes
+						// with the binding a sibling `export *` provides.
+						!(
+							parentModule &&
+							isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
+						)
+					) {
+						if (conflicting === undefined) conflicting = new Set();
+						conflicting.add(exportInfo.name);
+					}
+					continue;
+				}
 				if (
-					exportInfo.provided === true &&
-					exportInfo.name !== "default" &&
-					!names.has(exportInfo.name) &&
-					!(
-						parentModule &&
-						isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
-					)
+					parentModule &&
+					isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
 				) {
-					names.add(exportInfo.name);
-					dependencyIndices[i] = names.size;
+					continue;
 				}
+				names.add(exportInfo.name);
+				firstProvider.set(exportInfo.name, exportInfo);
+				dependencyIndices[i] = names.size;
 			}
 		}
 	}
 	dependencyIndices.push(names.size);
 
-	return { names: [...names], dependencyIndices };
+	return { names: [...names], dependencyIndices, conflicting };
 };
 
 /**
@@ -666,6 +711,12 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		/** @type {IgnoredExports} */
 		const ignoredExports = new Set(this.activeExports);
 		ignoredExports.add("default");
+		// An ambiguous name resolves to no binding at all, so no `export *` in this
+		// module may contribute it — not even the first one.
+		const conflicting = this._getConflictingStarExportNames(moduleGraph);
+		if (conflicting !== undefined) {
+			for (const name of conflicting) ignoredExports.add(name);
+		}
 
 		/** @type {Hidden | undefined} */
 		let hiddenExports;
@@ -785,6 +836,31 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		};
 	}
 
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const { chunkGraph, runtime } = context;
+		const moduleGraph = chunkGraph.moduleGraph;
+		if (!isInlineExportsEnabled(moduleGraph)) return;
+		const module = moduleGraph.getModule(this);
+		if (!module || !isInlineEnabled(module)) return;
+		const mode = this.getMode(moduleGraph, runtime);
+		if (mode.type !== "normal-reexport") return;
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		for (const item of /** @type {NormalReexportItem[]} */ (mode.items)) {
+			if (item.hidden || item.checked) continue;
+			const usedName = exportsInfo.getUsedName(item.ids, runtime);
+			if (usedName instanceof InlinedUsedName) {
+				hash.update(`${item.name}:${item.ids.join(".")}:`);
+				usedName.updateHash(hash);
+			}
+		}
+	}
+
 	/**
 	 * Gets module evaluation side effects state.
 	 * @param {ModuleGraph} moduleGraph the module graph
@@ -871,6 +947,21 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		}
 	}
 
+	/**
+	 * Names this module's `export *` sources provide with conflicting bindings.
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {Set<ExportInfoName> | undefined} ambiguous names, or nothing when there are none
+	 */
+	_getConflictingStarExportNames(moduleGraph) {
+		// Every `export *` carries the module's full star list; a lone one has
+		// nothing to be ambiguous with, so skip the walk.
+		if (!this.allStarExports) return;
+		const { dependencies } = this.allStarExports;
+		if (dependencies.length < 2) return;
+		return moduleGraph.cached(determineExportAssignments, dependencies)
+			.conflicting;
+	}
+
 	/**
 	 * Discover active exports from other star exports.
 	 * @param {ModuleGraph} moduleGraph the module graph
@@ -1072,7 +1163,10 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 */
 	getWarnings(moduleGraph) {
 		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		const circular = this._getCircularReexportWarnings(moduleGraph);
+		const circular =
+			this._getCircularReexportPresenceLevel() === ExportPresenceModes.WARN
+				? this._getCircularReexportErrors(moduleGraph)
+				: undefined;
 		if (exportsPresence === ExportPresenceModes.WARN) {
 			const errors = this._getErrors(moduleGraph);
 			if (!circular) return errors;
@@ -1082,12 +1176,23 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	/**
-	 * Returns warnings for a name resolving through a circular reexport chain,
-	 * off the export-presence path so a strict harmony module warns, not fails.
+	 * Reporting level for a circular reexport chain. It skips the promotion to
+	 * an error that AUTO gives a strict harmony module — a cycle warns by
+	 * default — but an explicit setting still says whether and how to report.
+	 * @returns {ExportPresenceMode} effective mode
+	 */
+	_getCircularReexportPresenceLevel() {
+		return this.exportPresenceMode === ExportPresenceModes.AUTO
+			? ExportPresenceModes.WARN
+			: this.exportPresenceMode;
+	}
+
+	/**
+	 * Returns errors for a name resolving through a circular reexport chain.
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[] | undefined} warnings
+	 * @returns {WebpackError[] | undefined} errors
 	 */
-	_getCircularReexportWarnings(moduleGraph) {
+	_getCircularReexportErrors(moduleGraph) {
 		const ids = this.getIds(moduleGraph);
 		if (ids.length === 0 || !this.name) return;
 		const parentModule = /** @type {Module} */ (
@@ -1115,10 +1220,18 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 */
 	getErrors(moduleGraph) {
 		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.ERROR) {
-			return this._getErrors(moduleGraph);
+		const errors =
+			exportsPresence === ExportPresenceModes.ERROR
+				? this._getErrors(moduleGraph)
+				: null;
+		if (
+			this._getCircularReexportPresenceLevel() !== ExportPresenceModes.ERROR
+		) {
+			return errors;
 		}
-		return null;
+		const circular = this._getCircularReexportErrors(moduleGraph);
+		if (!circular) return errors;
+		return errors ? [...errors, ...circular] : circular;
 	}
 
 	/**
@@ -1500,7 +1613,19 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				);
 				break;
 
-			case "reexport-namespace-object":
+			case "reexport-namespace-object": {
+				let value = namespaceImportVar;
+
+				// The re-exported binding is the namespace itself, so it has to be
+				// the same object every importer of that module is handed.
+				if (
+					importedModule.buildInfo &&
+					importedModule.buildInfo.specNamespaceObject
+				) {
+					runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+					value = `${RuntimeGlobals.specNamespaceObject}(${value})`;
+				}
+
 				initFragments.push(
 					this.getReexportFragment(
 						module,
@@ -1508,12 +1633,13 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 						moduleGraph
 							.getExportsInfo(module)
 							.getUsedName(/** @type {string} */ (mode.name), runtime),
-						namespaceImportVar,
+						value,
 						"",
 						runtimeRequirements
 					)
 				);
 				break;
+			}
 
 			case "normal-reexport": {
 				// loop-invariants hoisted out of the per-item loop below (a barrel
@@ -1648,7 +1774,10 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 
 		/** @type {ExportMap} */
 		const map = new Map();
-		map.set(key, `/* ${comment} */ ${returnValue}`);
+		map.set(key, {
+			value: `/* ${comment} */ ${returnValue}`,
+			type: ExportBindingType.Getter
+		});
 
 		return new HarmonyExportInitFragment(module.exportsArgument, map);
 	}
@@ -1675,12 +1804,12 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 
 		/** @type {ExportMap} */
 		const map = new Map();
-		map.set(
-			key,
-			`/* reexport fake namespace object from non-harmony */ ${name}_namespace_cache || (${name}_namespace_cache = ${
+		map.set(key, {
+			value: `/* reexport fake namespace object from non-harmony */ ${name}_namespace_cache || (${name}_namespace_cache = ${
 				RuntimeGlobals.createFakeNamespaceObject
-			}(${name}${fakeType ? `, ${fakeType}` : ""}))`
-		);
+			}(${name}${fakeType ? `, ${fakeType}` : ""}))`,
+			type: ExportBindingType.Getter
+		});
 
 		return [
 			new InitFragment(
@@ -1719,10 +1848,20 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 		const map = new Map();
 		const moduleId = JSON.stringify(chunkGraph.getModuleId(module));
 		const mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);
-		map.set(
-			key,
-			`/* reexport deferred namespace object */ ${name}_deferred_namespace_cache || (${name}_deferred_namespace_cache = ${RuntimeGlobals.makeDeferredNamespaceObject}(${moduleId}, ${mode}))`
+		const names = getKnownExportNames(
+			chunkGraph.moduleGraph,
+			module,
+			exportsType
+		);
+		runtimeRequirements.add(
+			names
+				? RuntimeGlobals.hasSealedDeferredNamespace
+				: RuntimeGlobals.hasSynthesizedDeferredNamespace
 		);
+		map.set(key, {
+			value: `/* reexport deferred namespace object */ ${name}_deferred_namespace_cache || (${name}_deferred_namespace_cache = ${RuntimeGlobals.makeDeferredNamespaceObject}(${moduleId}, ${mode}${names ? `, ${JSON.stringify(names)}` : ""}))`,
+			type: ExportBindingType.Getter
+		});
 
 		return [
 			new InitFragment(

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -35,9 +35,19 @@ const joinIterableWithComma = (iterable) => {
 	return str;
 };
 
-/** @typedef {Map<UsedName, string>} ExportMap */
+const ExportBindingType = Object.freeze({
+	Getter: 0b00,
+	Value: 0b01
+});
+
+/** @typedef {Map<UsedName, { value: string, type: typeof ExportBindingType.Getter | typeof ExportBindingType.Value }>} ExportMap */
 /** @typedef {Set<string>} UnusedExports */
-/** @import { OnDemandGeneration } from "./ExportBindingInitFragment" */
+
+/**
+ * Lets a consumer take over the rendered `d()` call at its required position.
+ * End-position value bindings cannot move before the module body.
+ * @typedef {(source: string, placeAtEnd: boolean) => boolean} OnDemandGeneration
+ */
 
 /** @type {ExportMap} */
 const EMPTY_MAP = new Map();
@@ -71,6 +81,49 @@ class HarmonyExportInitFragment extends InitFragment {
 		this.unusedExports = unusedExports;
 		/** @type {OnDemandGeneration | undefined} */
 		this.onDemand = onDemand;
+
+		this._generated = false;
+		this._defsValue = undefined;
+		this._defsGetter = undefined;
+	}
+
+	/**
+	 * Returns the source code that will be included as initialization code.
+	 * @param {GenerateContext} context context
+	 * @returns {void}
+	 */
+	_generate({ runtimeTemplate }) {
+		if (this._generated) return;
+		this._generated = true;
+
+		if (this.exportMap.size > 0) {
+			/** @type {string[]} */
+			const _defsValue = [];
+			const _defsGetter = [];
+			const orderedExportMap =
+				this.exportMap.size > 1
+					? [...this.exportMap].sort(([a], [b]) => (a < b ? -1 : 1))
+					: this.exportMap;
+			for (const [key, { value, type }] of orderedExportMap) {
+				switch (type) {
+					case ExportBindingType.Getter:
+						_defsGetter.push(
+							`\n/* harmony export */   ${propertyName(
+								/** @type {string} */ (key)
+							)}: ${runtimeTemplate.returningFunction(value)}`
+						);
+						break;
+
+					case ExportBindingType.Value:
+						_defsValue.push(
+							`\n/* harmony export */   ${JSON.stringify(key)}, 0, ${value}`
+						);
+				}
+			}
+
+			this._defsGetter = _defsGetter;
+			this._defsValue = _defsValue;
+		}
 	}
 
 	/**
@@ -85,12 +138,15 @@ class HarmonyExportInitFragment extends InitFragment {
 		/** @type {undefined | UnusedExports} */
 		let unusedExports;
 		let unusedExportsOwned = false;
+		/** @type {OnDemandGeneration=} */
+		let onDemand;
 
 		for (const fragment of fragments) {
 			if (fragment.exportMap.size !== 0) {
 				if (exportMap === undefined) {
 					exportMap = fragment.exportMap;
 					exportMapOwned = false;
+					onDemand = fragment.onDemand;
 				} else {
 					if (!exportMapOwned) {
 						exportMap = new Map(exportMap);
@@ -98,6 +154,7 @@ class HarmonyExportInitFragment extends InitFragment {
 					}
 					for (const [key, value] of fragment.exportMap) {
 						if (!exportMap.has(key)) exportMap.set(key, value);
+						onDemand = onDemand || fragment.onDemand;
 					}
 				}
 			}
@@ -120,7 +177,7 @@ class HarmonyExportInitFragment extends InitFragment {
 			this.exportsArgument,
 			exportMap,
 			unusedExports,
-			this.onDemand
+			onDemand
 		);
 	}
 
@@ -167,7 +224,10 @@ class HarmonyExportInitFragment extends InitFragment {
 	 * @param {GenerateContext} context context
 	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
-	getContent({ runtimeTemplate, runtimeRequirements }) {
+	getContent(context) {
+		this._generate(context);
+
+		const { runtimeRequirements } = context;
 		const unusedPart =
 			this.unusedExports.size > 1
 				? `/* unused harmony exports ${joinIterableWithComma(
@@ -177,35 +237,55 @@ class HarmonyExportInitFragment extends InitFragment {
 					? `/* unused harmony export ${first(this.unusedExports)} */\n`
 					: "";
 		let definePart = "";
-		if (this.exportMap.size > 0) {
-			/** @type {string[]} */
-			const definitions = [];
-			const orderedExportMap =
-				this.exportMap.size > 1
-					? [...this.exportMap].sort(([a], [b]) => (a < b ? -1 : 1))
-					: this.exportMap;
-			for (const [key, value] of orderedExportMap) {
-				definitions.push(
-					`\n/* harmony export */   ${propertyName(
-						/** @type {string} */ (key)
-					)}: ${runtimeTemplate.returningFunction(value)}`
-				);
-			}
+
+		if (this._defsGetter && this._defsGetter.length) {
 			// Requested even when the call is taken over below: whoever took it may still
 			// emit it, and by then the requirement set is closed.
 			runtimeRequirements.add(RuntimeGlobals.exports);
 			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 			definePart = `/* harmony export */ ${
 				RuntimeGlobals.definePropertyGetters
-			}(${this.exportsArgument}, {${definitions.join(
+			}(${this.exportsArgument}, {${this._defsGetter.join(
 				","
 			)}\n/* harmony export */ });\n`;
 			if (this.onDemand !== undefined && this.onDemand(definePart, false)) {
 				definePart = "";
 			}
 		}
+
 		return `${definePart}${unusedPart}`;
 	}
+
+	/**
+	 * Returns the source code that will be included at the end of the module.
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included at the end of the module
+	 */
+	getEndContent({ runtimeRequirements }) {
+		let definePart = "";
+
+		if (this._defsValue && this._defsValue.length) {
+			// Requested even when the call is taken over below: whoever took it may still
+			// emit it, and by then the requirement set is closed.
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			// Only this fragment emits the array form, so the runtime helper drops the
+			// branch reading it unless this asks for it.
+			runtimeRequirements.add(RuntimeGlobals.definePropertyGettersFromArray);
+			const definition = `/* harmony export */ ${
+				RuntimeGlobals.definePropertyGetters
+			}(${this.exportsArgument}, [${this._defsValue.join(",")}\n/* harmony export */ ]);\n`;
+
+			definePart =
+				this.onDemand !== undefined && this.onDemand(definition, true)
+					? definePart
+					: `\n${definition}`;
+		}
+
+		return definePart;
+	}
 }
 
 module.exports = HarmonyExportInitFragment;
+
+HarmonyExportInitFragment.ExportBindingType = ExportBindingType;

package/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -9,8 +9,10 @@ const Dependency = require("../Dependency");
 const { InlinedUsedName } = require("../optimize/InlineExports");
 const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
-const ExportBindingInitFragment = require("./ExportBindingInitFragment");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
+
+const { ExportBindingType } = HarmonyExportInitFragment;
+
 const NullDependency = require("./NullDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
@@ -180,7 +182,7 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 			return;
 		}
 
-		const canUseValueBinding =
+		const valueFormat =
 			dep.constValue !== undefined &&
 			/** @type {import("../Module").BuildInfo} */ (module.buildInfo)
 				.isCircular === false;
@@ -200,34 +202,20 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 					) === true
 			: undefined;
 
-		if (canUseValueBinding) {
-			initFragments.push(
-				new ExportBindingInitFragment(
-					module.exportsArgument,
-					[
-						{
-							name: used,
-							value: `/* binding */ ${dep.id}`,
-							bindingType: "value"
-						}
-					],
-					true,
-					onDemand
-				)
-			);
-		} else {
-			/** @type {ExportMap} */
-			const map = new Map();
-			map.set(used, `/* binding */ ${dep.id}`);
-			initFragments.push(
-				new HarmonyExportInitFragment(
-					module.exportsArgument,
-					map,
-					undefined,
-					onDemand
-				)
-			);
-		}
+		/** @type {ExportMap} */
+		const map = new Map();
+		map.set(used, {
+			value: `/* binding */ ${dep.id}`,
+			type: valueFormat ? ExportBindingType.Value : ExportBindingType.Getter
+		});
+		initFragments.push(
+			new HarmonyExportInitFragment(
+				module.exportsArgument,
+				map,
+				undefined,
+				onDemand
+			)
+		);
 	}
 };
 

package/lib/dependencies/HarmonyImportBareSideEffectDependency.js

@@ -0,0 +1,59 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { ASSET_TYPE } = require("../ModuleSourceTypeConstants");
+const makeSerializable = require("../util/makeSerializable");
+const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
+
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { GetConditionFn } from "../Dependency" */
+
+/**
+ * Whether a module is emitted as a file of its own, asked of the module so a
+ * plugin emitting the same way is treated alike. `buildInfo.filename` cannot
+ * serve here: generation sets it long after a connection has to know whether
+ * it is active.
+ * @param {Module} module the module to look up
+ * @returns {boolean} true when it emits a file
+ */
+const emitsOwnFile = (module) => module.getSourceTypes().has(ASSET_TYPE);
+
+/**
+ * An `import "..."` that declares no binding. It is a separate class rather
+ * than a flag so it costs nothing per instance, and the bound form — much the
+ * more common one — keeps the base class and its inline caches untouched.
+ */
+class HarmonyImportBareSideEffectDependency extends HarmonyImportSideEffectDependency {
+	/**
+	 * Returns function to determine if the connection is active.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return (connection) => {
+			const refModule = connection.resolvedModule;
+
+			if (!refModule) return true;
+			// Nothing reads the module, so emitting its file is the only thing the
+			// import can have been written for.
+			if (emitsOwnFile(refModule)) return true;
+
+			return refModule.getSideEffectsConnectionState(moduleGraph);
+		};
+	}
+}
+
+makeSerializable(
+	HarmonyImportBareSideEffectDependency,
+	"webpack/lib/dependencies/HarmonyImportBareSideEffectDependency"
+);
+
+HarmonyImportBareSideEffectDependency.Template =
+	HarmonyImportSideEffectDependency.Template;
+
+module.exports = HarmonyImportBareSideEffectDependency;