webpack 5.107.2 → 5.108.0

package/lib/ExportsInfo.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
+const { InlinedUsedName } = require("./optimize/InlineExports");
 const { equals } = require("./util/ArrayHelpers");
 const SortableSet = require("./util/SortableSet");
 const makeSerializable = require("./util/makeSerializable");
@@ -19,8 +20,10 @@ const { forEachRuntime } = require("./util/runtime");
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./optimize/InlineExports").InlinedValue} InlinedValue */
+/** @typedef {[RestoreProvidedDataExports[], ExportInfo["provided"], ExportInfo["canMangleProvide"], ExportInfo["terminalBinding"]]} RestoreProvidedDataTuple */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<RestoreProvidedDataTuple>} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<RestoreProvidedDataTuple>} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 
 /** @typedef {typeof UsageState.OnlyPropertiesUsed | typeof UsageState.NoInfo | typeof UsageState.Unknown | typeof UsageState.Used} RuntimeUsageStateType */
@@ -34,11 +37,11 @@ const { forEachRuntime } = require("./util/runtime");
 /** @typedef {{ connection: ModuleGraphConnection, export: ExportInfoName[], priority: number }} TargetItem */
 /** @typedef {Map<Dependency | undefined, TargetItem>} Target */
 
-/** @typedef {string | null} ExportInfoUsedName */
+/** @typedef {string | InlinedUsedName | null} ExportInfoUsedName */
 /** @typedef {boolean | null} ExportInfoProvided */
 
 /** @typedef {Map<ExportInfoName, ExportInfo>} Exports */
-/** @typedef {string | string[] | false} UsedName */
+/** @typedef {string | string[] | InlinedUsedName | false} UsedName */
 /** @typedef {Set<ExportInfo>} AlreadyVisitedExportInfo */
 
 /**
@@ -47,7 +50,9 @@ const { forEachRuntime } = require("./util/runtime");
  * @property {ExportInfoName} name
  * @property {ExportInfo["provided"]} provided
  * @property {ExportInfo["canMangleProvide"]} canMangleProvide
+ * @property {ExportInfo["canInlineProvide"]=} canInlineProvide
  * @property {ExportInfo["terminalBinding"]} terminalBinding
+ * @property {ExportInfo["pureProvide"]=} pureProvide
  * @property {RestoreProvidedData | undefined} exportsInfo
  */
 
@@ -63,6 +68,12 @@ const RETURNS_TRUE = () => true;
 
 const CIRCULAR = Symbol("circular target");
 
+// bit layout of ExportInfo._inlineFlags
+const INLINE_USE_TRUE = 1;
+const INLINE_USE_FALSE = 2;
+const INLINE_USE_MASK = 3;
+const PURE_PROVIDE_FLAG = 4;
+
 class RestoreProvidedData {
 	/**
 	 * Creates an instance of RestoreProvidedData.
@@ -77,9 +88,13 @@ class RestoreProvidedData {
 		otherCanMangleProvide,
 		otherTerminalBinding
 	) {
+		/** @type {RestoreProvidedDataExports[]} */
 		this.exports = exports;
+		/** @type {ExportInfoProvided | undefined} */
 		this.otherProvided = otherProvided;
+		/** @type {boolean | undefined} */
 		this.otherCanMangleProvide = otherCanMangleProvide;
+		/** @type {boolean} */
 		this.otherTerminalBinding = otherTerminalBinding;
 	}
 
@@ -87,11 +102,12 @@ class RestoreProvidedData {
 	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
-	serialize({ write }) {
-		write(this.exports);
-		write(this.otherProvided);
-		write(this.otherCanMangleProvide);
-		write(this.otherTerminalBinding);
+	serialize(context) {
+		context
+			.write(this.exports)
+			.write(this.otherProvided)
+			.write(this.otherCanMangleProvide)
+			.write(this.otherTerminalBinding);
 	}
 
 	/**
@@ -99,8 +115,20 @@ class RestoreProvidedData {
 	 * @param {ObjectDeserializerContext} context context
 	 * @returns {RestoreProvidedData} RestoreProvidedData
 	 */
-	static deserialize({ read }) {
-		return new RestoreProvidedData(read(), read(), read(), read());
+	static deserialize(context) {
+		const exports = context.read();
+		const c1 = context.rest;
+		const otherProvided = c1.read();
+		const c2 = c1.rest;
+		const otherCanMangleProvide = c2.read();
+		const c3 = c2.rest;
+		const otherTerminalBinding = c3.read();
+		return new RestoreProvidedData(
+			exports,
+			otherProvided,
+			otherCanMangleProvide,
+			otherTerminalBinding
+		);
 	}
 }
 
@@ -137,6 +165,17 @@ class ExportsInfo {
 		this._exportsAreOrdered = false;
 		/** @type {ExportsInfo=} */
 		this._redirectTo = undefined;
+		// fast-path flag for hasInlinedUsedName; set by InlineExportsPlugin
+		/** @type {boolean} */
+		this._hasInlinedExports = false;
+	}
+
+	/**
+	 * Records that an owned export got an inlined used name.
+	 * @returns {void}
+	 */
+	markInlinedExports() {
+		this._hasInlinedExports = true;
 	}
 
 	/**
@@ -326,10 +365,15 @@ class ExportsInfo {
 	 * @returns {ExportInfo | undefined} export info for this name
 	 */
 	getReadOnlyExportInfoRecursive(name) {
-		const exportInfo = this.getReadOnlyExportInfo(name[0]);
-		if (name.length === 1) return exportInfo;
-		if (!exportInfo.exportsInfo) return;
-		return exportInfo.exportsInfo.getReadOnlyExportInfoRecursive(name.slice(1));
+		/** @type {ExportsInfo} */
+		let exportsInfo = this;
+		const last = name.length - 1;
+		for (let i = 0; ; i++) {
+			const exportInfo = exportsInfo.getReadOnlyExportInfo(name[i]);
+			if (i === last) return exportInfo;
+			if (!exportInfo.exportsInfo) return;
+			exportsInfo = exportInfo.exportsInfo;
+		}
 	}
 
 	/**
@@ -339,9 +383,14 @@ class ExportsInfo {
 	 */
 	getNestedExportsInfo(name) {
 		if (Array.isArray(name) && name.length > 0) {
-			const info = this.getReadOnlyExportInfo(name[0]);
-			if (!info.exportsInfo) return;
-			return info.exportsInfo.getNestedExportsInfo(name.slice(1));
+			/** @type {ExportsInfo} */
+			let exportsInfo = this;
+			for (let i = 0; i < name.length; i++) {
+				const info = exportsInfo.getReadOnlyExportInfo(name[i]);
+				if (!info.exportsInfo) return;
+				exportsInfo = info.exportsInfo;
+			}
+			return exportsInfo;
 		}
 		return this;
 	}
@@ -657,11 +706,17 @@ class ExportsInfo {
 	 */
 	isExportProvided(name) {
 		if (Array.isArray(name)) {
-			const info = this.getReadOnlyExportInfo(name[0]);
-			if (info.exportsInfo && name.length > 1) {
-				return info.exportsInfo.isExportProvided(name.slice(1));
+			/** @type {ExportsInfo} */
+			let exportsInfo = this;
+			const last = name.length - 1;
+			for (let i = 0; ; i++) {
+				const info = exportsInfo.getReadOnlyExportInfo(name[i]);
+				if (info.exportsInfo && i < last) {
+					exportsInfo = info.exportsInfo;
+					continue;
+				}
+				return info.provided ? i === last || undefined : info.provided;
 			}
-			return info.provided ? name.length === 1 || undefined : info.provided;
 		}
 		const info = this.getReadOnlyExportInfo(name);
 		return info.provided;
@@ -725,11 +780,15 @@ class ExportsInfo {
 	getUsed(name, runtime) {
 		if (Array.isArray(name)) {
 			if (name.length === 0) return this.otherExportsInfo.getUsed(runtime);
-			const info = this.getReadOnlyExportInfo(name[0]);
-			if (info.exportsInfo && name.length > 1) {
-				return info.exportsInfo.getUsed(name.slice(1), runtime);
+			// Walk the nested path iteratively to avoid a `slice` per level
+			/** @type {ExportsInfo} */
+			let exportsInfo = this;
+			const last = name.length - 1;
+			for (let i = 0; ; i++) {
+				const info = exportsInfo.getReadOnlyExportInfo(name[i]);
+				if (i === last || !info.exportsInfo) return info.getUsed(runtime);
+				exportsInfo = info.exportsInfo;
 			}
-			return info.getUsed(runtime);
 		}
 		const info = this.getReadOnlyExportInfo(name);
 		return info.getUsed(runtime);
@@ -743,33 +802,95 @@ class ExportsInfo {
 	 */
 	getUsedName(name, runtime) {
 		if (Array.isArray(name)) {
-			// TODO improve this
 			if (name.length === 0) {
 				if (!this.isUsed(runtime)) return false;
 				return name;
 			}
-			const info = this.getReadOnlyExportInfo(name[0]);
-			const x = info.getUsedName(name[0], runtime);
-			if (x === false) return false;
-			const arr =
-				/** @type {ExportInfoName[]} */
-				(x === name[0] && name.length === 1 ? name : [x]);
-			if (name.length === 1) {
-				return arr;
+			// Walk the nested path once, collecting used names into a single array
+			// instead of slicing/spreading at every level.
+			/** @type {ExportsInfo} */
+			let exportsInfo = this;
+			/** @type {ExportInfoName[] | undefined} */
+			let result;
+			const last = name.length - 1;
+			for (let i = 0; ; i++) {
+				const info = exportsInfo.getReadOnlyExportInfo(name[i]);
+				const x = info.getUsedName(name[i], runtime);
+				if (x === false) return false;
+				if (x instanceof InlinedUsedName) {
+					// The inlined value replaces the prefix; trailing ids become its suffix
+					if (i === last) return x;
+					return new InlinedUsedName(x.value, [
+						...x.suffix,
+						...name.slice(i + 1)
+					]);
+				}
+				if (i === last) {
+					if (result === undefined) return x === name[i] ? name : [x];
+					result.push(x);
+					return result;
+				}
+				if (result === undefined) result = [];
+				result.push(x);
+				// Descend only while the parent is reached purely via property access
+				if (
+					info.exportsInfo &&
+					info.getUsed(runtime) === UsageState.OnlyPropertiesUsed
+				) {
+					exportsInfo = info.exportsInfo;
+					continue;
+				}
+				// Cannot descend further: keep the remaining ids unchanged
+				for (let j = i + 1; j <= last; j++) result.push(name[j]);
+				return result;
+			}
+		}
+		const info = this.getReadOnlyExportInfo(name);
+		return info.getUsedName(name, runtime);
+	}
+
+	/**
+	 * Checks whether `getUsedName(name, runtime)` would return an `InlinedUsedName`,
+	 * without allocating intermediate used-name arrays (hot path for connection conditions).
+	 * @param {ExportInfoName[]} name the export name path
+	 * @param {RuntimeSpec} runtime check usage for this runtime only
+	 * @returns {boolean} true when the used name resolves to an inlined value
+	 */
+	hasInlinedUsedName(name, runtime) {
+		if (name.length === 0) return false;
+		/** @type {ExportsInfo} */
+		let exportsInfo = this;
+		const last = name.length - 1;
+		for (let i = 0; ; i++) {
+			// follow redirects for the fast-path flag; InlinedUsedName can only
+			// exist on a level whose (redirected) exportsInfo is marked
+			let hasInlined = false;
+			/** @type {ExportsInfo | undefined} */
+			let e = exportsInfo;
+			while (e !== undefined) {
+				if (e._hasInlinedExports) {
+					hasInlined = true;
+					break;
+				}
+				e = e._redirectTo;
+			}
+			if (!hasInlined && i === last) return false;
+			const info = exportsInfo.getReadOnlyExportInfo(name[i]);
+			if (hasInlined) {
+				const x = info.getUsedName(name[i], runtime);
+				if (x === false) return false;
+				if (x instanceof InlinedUsedName) return true;
+				if (i === last) return false;
 			}
 			if (
 				info.exportsInfo &&
 				info.getUsed(runtime) === UsageState.OnlyPropertiesUsed
 			) {
-				const nested = info.exportsInfo.getUsedName(name.slice(1), runtime);
-				if (!nested) return false;
-				return [...arr, ...(Array.isArray(nested) ? nested : [nested])];
+				exportsInfo = info.exportsInfo;
+				continue;
 			}
-			return [...arr, ...name.slice(1)];
+			return false;
 		}
-		const info = this.getReadOnlyExportInfo(name);
-		const usedName = info.getUsedName(name, runtime);
-		return usedName;
 	}
 
 	/**
@@ -790,18 +911,27 @@ class ExportsInfo {
 	 * @returns {void}
 	 */
 	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
-		const set = new Set(alreadyVisitedExportsInfo);
-		set.add(this);
+		// add/delete keeps path semantics without copying the set per level
+		alreadyVisitedExportsInfo.add(this);
 		for (const exportInfo of this.orderedExports) {
 			if (exportInfo.hasInfo(this._otherExportsInfo, runtime)) {
-				exportInfo._updateHash(hash, runtime, set);
+				exportInfo._updateHash(hash, runtime, alreadyVisitedExportsInfo);
 			}
 		}
-		this._sideEffectsOnlyInfo._updateHash(hash, runtime, set);
-		this._otherExportsInfo._updateHash(hash, runtime, set);
+		this._sideEffectsOnlyInfo._updateHash(
+			hash,
+			runtime,
+			alreadyVisitedExportsInfo
+		);
+		this._otherExportsInfo._updateHash(
+			hash,
+			runtime,
+			alreadyVisitedExportsInfo
+		);
 		if (this._redirectTo !== undefined) {
-			this._redirectTo._updateHash(hash, runtime, set);
+			this._redirectTo._updateHash(hash, runtime, alreadyVisitedExportsInfo);
 		}
+		alreadyVisitedExportsInfo.delete(this);
 	}
 
 	/**
@@ -815,22 +945,42 @@ class ExportsInfo {
 		/** @type {RestoreProvidedDataExports[]} */
 		const exports = [];
 		for (const exportInfo of this.orderedExports) {
+			const canInlineProvide = exportInfo.canInlineProvide;
+			const pureProvide = exportInfo.pureProvide;
+			// inline-exports data is only stored when present, so builds without the
+			// feature don't pay for it in the persistent cache
+			const hasInlineInfo =
+				canInlineProvide !== undefined || pureProvide !== undefined;
 			if (
 				exportInfo.provided !== otherProvided ||
 				exportInfo.canMangleProvide !== otherCanMangleProvide ||
 				exportInfo.terminalBinding !== otherTerminalBinding ||
+				hasInlineInfo ||
 				exportInfo.exportsInfoOwned
 			) {
-				exports.push({
-					name: exportInfo.name,
-					provided: exportInfo.provided,
-					canMangleProvide: exportInfo.canMangleProvide,
-					terminalBinding: exportInfo.terminalBinding,
-					exportsInfo: exportInfo.exportsInfoOwned
-						? /** @type {NonNullable<ExportInfo["exportsInfo"]>} */
-							(exportInfo.exportsInfo).getRestoreProvidedData()
-						: undefined
-				});
+				const exportsInfo = exportInfo.exportsInfoOwned
+					? /** @type {NonNullable<ExportInfo["exportsInfo"]>} */
+						(exportInfo.exportsInfo).getRestoreProvidedData()
+					: undefined;
+				exports.push(
+					hasInlineInfo
+						? {
+								name: exportInfo.name,
+								provided: exportInfo.provided,
+								canMangleProvide: exportInfo.canMangleProvide,
+								canInlineProvide,
+								terminalBinding: exportInfo.terminalBinding,
+								pureProvide,
+								exportsInfo
+							}
+						: {
+								name: exportInfo.name,
+								provided: exportInfo.provided,
+								canMangleProvide: exportInfo.canMangleProvide,
+								terminalBinding: exportInfo.terminalBinding,
+								exportsInfo
+							}
+				);
 			}
 		}
 		return new RestoreProvidedData(
@@ -865,7 +1015,9 @@ class ExportsInfo {
 			const exportInfo = this.getExportInfo(exp.name);
 			exportInfo.provided = exp.provided;
 			exportInfo.canMangleProvide = exp.canMangleProvide;
+			exportInfo.canInlineProvide = exp.canInlineProvide;
 			exportInfo.terminalBinding = exp.terminalBinding;
+			exportInfo.pureProvide = exp.pureProvide;
 			if (exp.exportsInfo) {
 				const exportsInfo = exportInfo.createNestedExportsInfo();
 				exportsInfo.restoreProvided(exp.exportsInfo);
@@ -929,6 +1081,14 @@ class ExportInfo {
 		 * @type {boolean | undefined}
 		 */
 		this.canMangleProvide = initFrom ? initFrom.canMangleProvide : undefined;
+		// only specific export info can be inlined,
+		// so _otherExportsInfo.canInlineProvide is always undefined
+		/**
+		 * value slot for `canInlineProvide`
+		 * @private
+		 * @type {InlinedValue | undefined}
+		 */
+		this._inlinedValue = undefined;
 		/**
 		 * true: it can be mangled
 		 * false: is can not be mangled
@@ -936,6 +1096,12 @@ class ExportInfo {
 		 * @type {boolean | undefined}
 		 */
 		this.canMangleUse = initFrom ? initFrom.canMangleUse : undefined;
+		/**
+		 * bitfield backing `canInlineUse` and `pureProvide`
+		 * @private
+		 * @type {number}
+		 */
+		this._inlineFlags = 0;
 		/** @type {boolean} */
 		this.exportsInfoOwned = false;
 		/** @type {ExportsInfo | undefined} */
@@ -956,6 +1122,57 @@ class ExportInfo {
 		this._maxTarget = undefined;
 	}
 
+	/**
+	 * defined: the export binds to a small primitive constant and may be inlined
+	 * undefined: not an inlined constant export
+	 * @returns {InlinedValue | undefined} inlined value
+	 */
+	get canInlineProvide() {
+		return this._inlinedValue;
+	}
+
+	set canInlineProvide(value) {
+		this._inlinedValue = value;
+	}
+
+	/**
+	 * true: at least one consumer accepts inlining, none rejected
+	 * false: at least one consumer rejected inlining
+	 * undefined: collecting; no consumer has decided yet
+	 * @returns {boolean | undefined} can inline use
+	 */
+	get canInlineUse() {
+		switch (this._inlineFlags & INLINE_USE_MASK) {
+			case INLINE_USE_TRUE:
+				return true;
+			case INLINE_USE_FALSE:
+				return false;
+			default:
+				return undefined;
+		}
+	}
+
+	set canInlineUse(value) {
+		this._inlineFlags =
+			(this._inlineFlags & ~INLINE_USE_MASK) |
+			(value === undefined ? 0 : value ? INLINE_USE_TRUE : INLINE_USE_FALSE);
+	}
+
+	/**
+	 * Only specific export info can be pure, so other_export_info.pure is always undefined.
+	 * true: calling the export has no observable side effects
+	 * undefined: it was not determined whether the export is pure
+	 * @returns {boolean | undefined} pure provide
+	 */
+	get pureProvide() {
+		return (this._inlineFlags & PURE_PROVIDE_FLAG) !== 0 ? true : undefined;
+	}
+
+	set pureProvide(value) {
+		if (value) this._inlineFlags |= PURE_PROVIDE_FLAG;
+		else this._inlineFlags &= ~PURE_PROVIDE_FLAG;
+	}
+
 	get canMangle() {
 		switch (this.canMangleProvide) {
 			case undefined:
@@ -977,6 +1194,15 @@ class ExportInfo {
 		);
 	}
 
+	/**
+	 * @returns {InlinedValue | undefined} the inlined value when both provide and use sides agree, otherwise undefined
+	 */
+	canInline() {
+		return this.canInlineProvide !== undefined && this.canInlineUse === true
+			? this.canInlineProvide
+			: undefined;
+	}
+
 	/**
 	 * Sets used in unknown way.
 	 * @param {RuntimeSpec} runtime only apply to this runtime
@@ -997,6 +1223,10 @@ class ExportInfo {
 			this.canMangleUse = false;
 			changed = true;
 		}
+		if (this.canInlineUse !== false) {
+			this.canInlineUse = false;
+			changed = true;
+		}
 		return changed;
 	}
 
@@ -1014,6 +1244,10 @@ class ExportInfo {
 			this.canMangleUse = false;
 			changed = true;
 		}
+		if (this.canInlineUse !== false) {
+			this.canInlineUse = false;
+			changed = true;
+		}
 		return changed;
 	}
 
@@ -1242,10 +1476,10 @@ class ExportInfo {
 	}
 
 	/**
-	 * Returns used name.
+	 * Returns used name. May return InlinedUsedName when the export is inlined to a primitive.
 	 * @param {string | undefined} fallbackName fallback name for used exports with no name
 	 * @param {RuntimeSpec} runtime check usage for this runtime only
-	 * @returns {string | false} used name
+	 * @returns {string | InlinedUsedName | false} used name
 	 */
 	getUsedName(fallbackName, runtime) {
 		if (this._hasUseInRuntimeInfo) {
@@ -1257,14 +1491,17 @@ class ExportInfo {
 					if (!this._usedInRuntime.has(runtime)) {
 						return false;
 					}
-				} else if (
-					runtime !== undefined &&
-					[...runtime].every(
-						(runtime) =>
-							!(/** @type {UsedInRuntime} */ (this._usedInRuntime).has(runtime))
-					)
-				) {
-					return false;
+				} else if (runtime !== undefined) {
+					// Unused unless at least one runtime in the set is used; loop avoids
+					// allocating an array from the runtime set on this hot path.
+					let anyUsed = false;
+					for (const r of runtime) {
+						if (this._usedInRuntime.has(r)) {
+							anyUsed = true;
+							break;
+						}
+					}
+					if (!anyUsed) return false;
 				}
 			}
 		}
@@ -1282,7 +1519,7 @@ class ExportInfo {
 
 	/**
 	 * Updates used name using the provided name.
-	 * @param {string} name the new name
+	 * @param {string | InlinedUsedName} name the new name
 	 * @returns {void}
 	 */
 	setUsedName(name) {
@@ -1512,7 +1749,7 @@ class ExportInfo {
 	 * Move the target forward as long resolveTargetFilter is fulfilled
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
-	 * @param {(target: TargetItemWithConnection) => ModuleGraphConnection=} updateOriginalConnection updates the original connection instead of using the target connection
+	 * @param {((target: TargetItemWithConnection) => ModuleGraphConnection | undefined)=} updateOriginalConnection updates the original connection instead of using the target connection
 	 * @returns {TargetItemWithConnection | undefined} the resolved target when moved
 	 */
 	moveTarget(moduleGraph, resolveTargetFilter, updateOriginalConnection) {
@@ -1536,7 +1773,7 @@ class ExportInfo {
 		/** @type {Target} */
 		(this._target).set(undefined, {
 			connection: updateOriginalConnection
-				? updateOriginalConnection(target)
+				? updateOriginalConnection(target) || target.connection
 				: target.connection,
 			export: /** @type {NonNullable<TargetItemWithConnection["export"]>} */ (
 				target.export
@@ -1600,10 +1837,14 @@ class ExportInfo {
 	 * @param {Set<ExportsInfo>} alreadyVisitedExportsInfo for circular references
 	 */
 	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
+		const usedNameHash =
+			this._usedName instanceof InlinedUsedName
+				? `inlined:${this._usedName.render("")}`
+				: this._usedName || this.name;
 		hash.update(
-			`${this._usedName || this.name}${this.getUsed(runtime)}${this.provided}${
+			`${usedNameHash}${this.getUsed(runtime)}${this.provided}${
 				this.terminalBinding
-			}`
+			}${this.pureProvide ? "P" : ""}`
 		);
 		if (this.exportsInfo && !alreadyVisitedExportsInfo.has(this.exportsInfo)) {
 			this.exportsInfo._updateHash(hash, runtime, alreadyVisitedExportsInfo);