webpack 5.107.2 → 5.108.0

package/lib/dependencies/CssIcssExportDependency.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { CSS_TYPE, JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
+const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const { interpolate } = require("../TemplatedPathPlugin");
 const WebpackError = require("../errors/WebpackError");
 const { cssExportConvention } = require("../util/conventions");
@@ -13,36 +13,82 @@ const createHash = require("../util/createHash");
 const { makePathsRelative } = require("../util/identifier");
 const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
-const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
+const { digestNonNumericOnly } = require("../util/nonNumericOnlyHash");
 const { updateHashFromSource } = require("../util/source");
 const CssIcssImportDependency = require("./CssIcssImportDependency");
 const NullDependency = require("./NullDependency");
 
-const getCssParser = memoize(() => require("../css/CssParser"));
+const getCssTokens = memoize(() => require("../css/syntax"));
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorLocalIdentName} CssGeneratorLocalIdentName */
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
+/** @typedef {import("../css/CssGenerator")} CssGenerator */
 /** @typedef {import("../css/CssModule")} CssModule */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../css/CssGenerator")} CssGenerator */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation").ModulePathData} ModulePathData */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../css/CssParser").Range} Range */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<(number | string | Value | Range | boolean | ExportMode | ExportType | DependencyLocation | undefined)[]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<(number | string | Value | Range | boolean | ExportMode | ExportType | DependencyLocation | undefined)[]>} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../errors/WebpackError")} WebpackErrorType */
 
+/** @typedef {string | [string, string] | [string, string, string]} Value */
 /** @typedef {(name: string) => string | string[]} ExportsConventionFn */
+// 0 - none, 1 - replace, 2 - append, 3 - once, 4 - self-reference
+/** @typedef {0 | 1 | 2 | 3 | 4} ExportMode */
+// 0 - normal, 1 - custom css variable, 2 - grid custom ident, 3 - composes
+/** @typedef {0 | 1 | 2 | 3} ExportType */
+
+/** @type {Record<"NONE" | "REPLACE" | "APPEND" | "ONCE" | "SELF_REFERENCE", ExportMode>} */
+const EXPORT_MODE = {
+	NONE: 0,
+	REPLACE: 1,
+	APPEND: 2,
+	ONCE: 3,
+	SELF_REFERENCE: 4
+};
+
+/** @type {Record<"NORMAL" | "CUSTOM_VARIABLE" | "GRID_CUSTOM_IDENTIFIER" | "COMPOSES", ExportType>} */
+const EXPORT_TYPE = {
+	NORMAL: 0,
+	CUSTOM_VARIABLE: 1,
+	GRID_CUSTOM_IDENTIFIER: 2,
+	COMPOSES: 3
+};
+
+// Hoisted out of `getLocalIdent`'s `prepareId` so the patterns + the replacer
+// aren't recompiled/reallocated per interpolated id.
+const IDENT_LEADING_INVALID_REGEXP = /^([.-]|[^a-z0-9_-])+/i;
+const IDENT_INVALID_CHARS_REGEXP = /[^a-z0-9@_-]+/gi;
+const IDENT_LOCAL_PLACEHOLDER_REGEXP = /\[local\]/g;
+const IDENT_LEADING_PROTECT_REGEXP = /^((-?\d)|--)/;
+
+/**
+ * `interpolate` `prepareId` hook — sanitize an id segment into a valid CSS ident.
+ * Pure (captures nothing), so it's shared rather than allocated per call.
+ * @param {string | number} id id segment
+ * @returns {string | number} sanitized id segment
+ */
+const prepareLocalIdentId = (id) => {
+	if (typeof id !== "string") return id;
+	return (
+		id
+			.replace(IDENT_LEADING_INVALID_REGEXP, "")
+			// We keep the `@` symbol because it can be used in the package name (e.g. `@company/package`), and if we replace it with `_`, a class conflict may occur.
+			// For example - `@import "@foo/package/style.module.css"` and `@import "foo/package/style.module.css"` (`foo` is a package, `package` is just a directory) will create a class conflict.
+			.replace(IDENT_INVALID_CHARS_REGEXP, "_")
+	);
+};
 
 /**
  * Returns local ident.
@@ -67,11 +113,9 @@ const getLocalIdent = (local, module, chunkGraph, runtimeTemplate) => {
 	const { uniqueName } = runtimeTemplate.outputOptions;
 
 	let localIdentHash = "";
+	let localIdentHashFull = "";
 
-	if (
-		typeof localIdentName === "function" ||
-		/\[(?:fullhash|hash)\]/.test(localIdentName)
-	) {
+	if (generator._localIdentNeedsHash) {
 		const hashSalt = generator.options.localIdentHashSalt;
 		const hashDigest =
 			/** @type {string} */
@@ -94,15 +138,15 @@ const getLocalIdent = (local, module, chunkGraph, runtimeTemplate) => {
 		hash.update(relativeResourcePath);
 		hash.update(local);
 
-		localIdentHash = hash.digest(hashDigest).slice(0, hashDigestLength);
+		// Keep the untruncated digest so an inline `[fullhash:<digest>]` re-encodes
+		// with full entropy (see the `fullHash`/`fullHashDigest` passed below).
+		localIdentHashFull = hash.digest(hashDigest);
+		localIdentHash = localIdentHashFull.slice(0, hashDigestLength);
 	}
 
 	let contentHash = "";
 
-	if (
-		typeof localIdentName === "function" ||
-		/\[contenthash\]/.test(localIdentName)
-	) {
+	if (generator._localIdentNeedsContentHash) {
 		const hash = createHash(runtimeTemplate.outputOptions.hashFunction);
 		const source = module.originalSource();
 
@@ -114,65 +158,49 @@ const getLocalIdent = (local, module, chunkGraph, runtimeTemplate) => {
 			hash.update(module.error.toString());
 		}
 
-		const fullContentHash = hash.digest(
-			runtimeTemplate.outputOptions.hashDigest
-		);
-
-		contentHash = nonNumericOnlyHash(
-			fullContentHash,
-			runtimeTemplate.outputOptions.hashDigestLength
+		contentHash = digestNonNumericOnly(
+			hash,
+			/** @type {string} */ (runtimeTemplate.outputOptions.hashDigest),
+			/** @type {number} */ (runtimeTemplate.outputOptions.hashDigestLength)
 		);
 	}
 
 	let localIdent = interpolate(localIdentName, {
-		prepareId: (id) => {
-			if (typeof id !== "string") return id;
-
-			return (
-				id
-					.replace(/^([.-]|[^a-z0-9_-])+/i, "")
-					// We keep the `@` symbol because it can be used in the package name (e.g. `@company/package`), and if we replace it with `_`, a class conflict may occur.
-					// For example - `@import "@foo/package/style.module.css"` and `@import "foo/package/style.module.css"` (`foo` is a package, `package` is just a directory) will create a class conflict.
-					.replace(/[^a-z0-9@_-]+/gi, "_")
-			);
-		},
+		prepareId: prepareLocalIdentId,
 		filename: relativeResourcePath,
 		hash: localIdentHash,
+		// css-loader semantics: `[hash]` is the local ident hash, not the module
+		// hash (use `[modulehash]` for that).
+		hashAsFullHash: true,
+		// `[hash]`/`[contenthash]` are encoded with the output digest, but the
+		// `[fullhash]` local ident hash uses `localIdentHashDigest`, so re-encode it
+		// from its own (full) digest.
+		hashDigest: runtimeTemplate.outputOptions.hashDigest,
+		fullHash: localIdentHashFull,
+		fullHashDigest:
+			/** @type {string} */
+			(generator.options.localIdentHashDigest),
 		local,
+		uniqueName,
 		contentHash,
 		chunkGraph,
 		module
 	});
 
-	// TODO move these things into interpolate
-	if (/\[local\]/.test(localIdent)) {
-		localIdent = localIdent.replace(/\[local\]/g, local);
-	}
-
-	if (/\[uniqueName\]/.test(localIdent)) {
-		localIdent = localIdent.replace(
-			/\[uniqueName\]/g,
-			/** @type {string} */ (uniqueName)
-		);
-	}
+	// TODO move this into interpolate
+	// `replace` on a non-matching global regexp returns the string unchanged, so
+	// the `.test` guard is redundant — one scan instead of two.
+	localIdent = localIdent.replace(IDENT_LOCAL_PLACEHOLDER_REGEXP, local);
 
 	// Protect the first character from unsupported values
-	return localIdent.replace(/^((-?\d)|--)/, "_$1");
+	return localIdent.replace(IDENT_LEADING_PROTECT_REGEXP, "_$1");
 };
 
-/** @typedef {string | [string, string] | [string, string, string]} Value */
-
-// 0 - replace, 1 - replace, 2 - append,  2 - once
-/** @typedef {0 | 1 | 2 | 3 | 4} ExportMode */
-// 0 - normal, 1 - custom css variable, 2 - grid custom ident, 3 - composes
-/** @typedef {0 | 1 | 2 | 3} ExportType */
-
 /**
  * Computes the interpolated identifier for `(module, value, exportType)`.
  * Module-level reference so `moduleGraph.cached` can use it as a stable
- * computer key — repeated lookups during a build skip
- * `cssExportConvention`, `getLocalIdent` (with its content / path hashing)
- * and `escapeIdentifier`.
+ * computer key — repeated lookups during a build skip `cssExportConvention`,
+ * `getLocalIdent` (with its content / path hashing) and `escapeIdentifier`.
  * @param {ModuleGraph} _moduleGraph module graph (unused, kept for `cached` signature)
  * @param {CssModule} module css module the value resolves in
  * @param {string} value raw value to interpolate
@@ -195,13 +223,10 @@ const computeInterpolatedIdentifier = (
 		/** @type {CssGeneratorExportsConvention} */
 		(generator.options.exportsConvention)
 	)[0];
-	const prefix =
-		exportType === CssIcssExportDependency.EXPORT_TYPE.CUSTOM_VARIABLE
-			? "--"
-			: "";
+	const prefix = exportType === EXPORT_TYPE.CUSTOM_VARIABLE ? "--" : "";
 	return (
 		prefix +
-		getCssParser().escapeIdentifier(
+		getCssTokens().escapeIdentifier(
 			getLocalIdent(local, module, chunkGraph, runtimeTemplate),
 			runtimeTemplate.compilation.compiler.root
 		)
@@ -209,97 +234,61 @@ const computeInterpolatedIdentifier = (
 };
 
 /**
- * Top-level computer for `resolve`. Allocates a fresh `seen` set; recursive
- * calls go through the un-cached inner path so cycle detection still works.
- * @param {ModuleGraph} moduleGraph module graph
- * @param {CssModule} module module to search
- * @param {string} localName local name
- * @param {string} importName imported export name
- * @param {string | undefined} request request of the active `@value` import
- * @param {ChunkGraph} chunkGraph chunk graph
- * @param {RuntimeTemplate} runtimeTemplate runtime template
- * @returns {string | undefined} resolved value or undefined
+ * One `:export { name: value }` style entry — a plain object so a module holds
+ * a single `Dependency` plus a flat array instead of thousands of `Dependency`
+ * instances. `_conventionNames`/`_valueConventionNames` memoize the convention
+ * expansion per entry.
+ * @typedef {object} CssExportEntry
+ * @property {string} name export name
+ * @property {Value} value value or [localName, importName, request?]
+ * @property {Range=} range source range to replace, when present
+ * @property {boolean} interpolate whether the value needs interpolation
+ * @property {ExportMode} exportMode export mode
+ * @property {ExportType} exportType export type
+ * @property {DependencyLocation=} loc per-export source location (for export source maps)
+ * @property {string[]=} _conventionNames memoized convention names for `name`
+ * @property {string[]=} _valueConventionNames memoized convention names for `value`
  */
-const computeResolve = (
-	moduleGraph,
-	module,
-	localName,
-	importName,
-	request,
-	chunkGraph,
-	runtimeTemplate
-) =>
-	CssIcssExportDependency.Template._doResolve(
-		localName,
-		importName,
-		/** @type {DependencyTemplateContext} */
-		(
-			/** @type {unknown} */
-			({ moduleGraph, module, chunkGraph, runtimeTemplate })
-		),
-		request,
-		new Set()
-	);
 
 /**
- * Top-level computer for `resolveReferences`. See `computeResolve`.
- * @param {ModuleGraph} moduleGraph module graph
- * @param {CssIcssExportDependency} dep export dependency
- * @param {CssModule} module module that hosts `dep`
- * @param {ChunkGraph} chunkGraph chunk graph
- * @param {RuntimeTemplate} runtimeTemplate runtime template
- * @returns {string[]} final references, deduplicated
+ * Memoized `cssExportConvention(entry.name, convention)`.
+ * @param {CssExportEntry} entry entry
+ * @param {CssGeneratorExportsConvention} convention convention
+ * @returns {string[]} convention names
  */
-const computeResolveReferences = (
-	moduleGraph,
-	dep,
-	module,
-	chunkGraph,
-	runtimeTemplate
-) =>
-	CssIcssExportDependency.Template._doResolveReferences(
-		dep,
-		/** @type {DependencyTemplateContext} */
-		(
-			/** @type {unknown} */
-			({ moduleGraph, module, chunkGraph, runtimeTemplate })
-		),
-		new Set()
+const entryConventionNames = (entry, convention) => {
+	if (entry._conventionNames) return entry._conventionNames;
+	entry._conventionNames = cssExportConvention(entry.name, convention);
+	return entry._conventionNames;
+};
+
+/**
+ * Memoized `cssExportConvention(entry.value, convention)`. Caller guarantees
+ * `typeof entry.value === "string"`.
+ * @param {CssExportEntry} entry entry
+ * @param {CssGeneratorExportsConvention} convention convention
+ * @returns {string[]} convention names
+ */
+const entryValueConventionNames = (entry, convention) => {
+	if (entry._valueConventionNames) return entry._valueConventionNames;
+	entry._valueConventionNames = cssExportConvention(
+		/** @type {string} */ (entry.value),
+		convention
 	);
+	return entry._valueConventionNames;
+};
 
 class CssIcssExportDependency extends NullDependency {
 	/**
-	 * Example of dependency:
-	 *
-	 * :export { LOCAL_NAME: EXPORT_NAME }
-	 * @param {string} name export name
-	 * @param {Value} value value or local name and import name
-	 * @param {Range=} range range
-	 * @param {boolean=} interpolate true when value need to be interpolated, otherwise false
-	 * @param {ExportMode=} exportMode export mode
-	 * @param {ExportType=} exportType export type
+	 * One consolidated `:export` dependency for a whole CSS module.
+	 * @param {CssExportEntry[]} entries export entries in source order
 	 */
-	constructor(
-		name,
-		value,
-		range,
-		interpolate = false,
-		exportMode = CssIcssExportDependency.EXPORT_MODE.REPLACE,
-		exportType = CssIcssExportDependency.EXPORT_TYPE.NORMAL
-	) {
+	constructor(entries) {
 		super();
-		this.name = name;
-		this.value = value;
-		this.range = range;
-		this.interpolate = interpolate;
-		this.exportMode = exportMode;
-		this.exportType = exportType;
+		/** @type {CssExportEntry[]} */
+		this.entries = entries;
 		/** @type {undefined | string} */
 		this._hashUpdate = undefined;
-		/** @type {undefined | string[]} */
-		this._conventionNames = undefined;
-		/** @type {undefined | string[]} */
-		this._valueConventionNames = undefined;
 	}
 
 	get type() {
@@ -307,37 +296,33 @@ class CssIcssExportDependency extends NullDependency {
 	}
 
 	/**
-	 * Gets exports convention names.
-	 * @param {string} name export name
-	 * @param {CssGeneratorExportsConvention} convention convention of the export name
-	 * @returns {string[]} convention results
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
 	 */
-	getExportsConventionNames(name, convention) {
-		if (this._conventionNames) {
-			return this._conventionNames;
+	getExports(moduleGraph) {
+		const module = /** @type {CssModule} */ (moduleGraph.getParentModule(this));
+		const generator = /** @type {CssGenerator} */ (module.generator);
+		const convention =
+			/** @type {CssGeneratorExportsConvention} */
+			(generator.options.exportsConvention);
+
+		/** @type {{ name: string, canMangle: boolean }[]} */
+		const exports = [];
+		for (const entry of this.entries) {
+			if (
+				entry.exportMode === EXPORT_MODE.NONE ||
+				entry.exportMode === EXPORT_MODE.SELF_REFERENCE
+			) {
+				continue;
+			}
+			for (const name of entryConventionNames(entry, convention)) {
+				exports.push({ name, canMangle: true });
+			}
 		}
-		this._conventionNames = cssExportConvention(name, convention);
-		return this._conventionNames;
-	}
 
-	/**
-	 * Memoized `cssExportConvention(this.value, convention)`. Used by every
-	 * code path that needs the convention-derived aliases of the composed /
-	 * referenced class: `getReferencedExports`, `getWarnings`, and the template's
-	 * `getIdentifier`. Caller guarantees `typeof this.value === "string"` —
-	 * the array form (cross-module references) is resolved separately.
-	 * @param {CssGeneratorExportsConvention} convention convention of the export name
-	 * @returns {string[]} convention results
-	 */
-	getValueConventionNames(convention) {
-		if (this._valueConventionNames) {
-			return this._valueConventionNames;
-		}
-		this._valueConventionNames = cssExportConvention(
-			/** @type {string} */ (this.value),
-			convention
-		);
-		return this._valueConventionNames;
+		if (exports.length === 0) return undefined;
+		return { exports, dependencies: undefined };
 	}
 
 	/**
@@ -347,60 +332,43 @@ class CssIcssExportDependency extends NullDependency {
 	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		if (
-			this.exportMode === CssIcssExportDependency.EXPORT_MODE.SELF_REFERENCE &&
-			typeof this.value === "string"
-		) {
-			// `composes: foo;` — the composed class (`this.value`) is the one
-			// referenced, not the class doing the composing (`this.name`). Apply
-			// the generator's `exportsConvention` so the export names produced
-			// by the convention are what the optimizer sees.
-			const module =
-				/** @type {CssModule | undefined} */
-				(moduleGraph.getParentModule(this));
-			if (!module) return super.getReferencedExports(moduleGraph, runtime);
-			const generator = /** @type {CssGenerator} */ (module.generator);
-			const names = this.getValueConventionNames(
-				/** @type {CssGeneratorExportsConvention} */
-				(generator.options.exportsConvention)
-			);
-			return names.map((name) => ({
-				name: [name],
-				canMangle: true
-			}));
+		// `composes: foo;` (SELF_REFERENCE) references the composed class
+		// (`entry.value`), not the composing class. Every other entry mode
+		// keeps the whole exports object referenced (legacy behaviour), so the
+		// presence of any such entry subsumes the self-reference names.
+		let hasNonSelfReference = false;
+		/** @type {ReferencedExports} */
+		const referenced = [];
+		let generator;
+		for (const entry of this.entries) {
+			if (
+				entry.exportMode === EXPORT_MODE.SELF_REFERENCE &&
+				typeof entry.value === "string"
+			) {
+				const module =
+					/** @type {CssModule} */
+					(moduleGraph.getParentModule(this));
+				generator = generator || /** @type {CssGenerator} */ (module.generator);
+				const names = entryValueConventionNames(
+					entry,
+					/** @type {CssGeneratorExportsConvention} */
+					(generator.options.exportsConvention)
+				);
+				for (const name of names) {
+					referenced.push({ name: [name], canMangle: true });
+				}
+			} else {
+				hasNonSelfReference = true;
+			}
 		}
 
-		return super.getReferencedExports(moduleGraph, runtime);
-	}
-
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		if (
-			this.exportMode === CssIcssExportDependency.EXPORT_MODE.NONE ||
-			this.exportMode === CssIcssExportDependency.EXPORT_MODE.SELF_REFERENCE
-		) {
-			return;
+		if (hasNonSelfReference) {
+			return super.getReferencedExports(moduleGraph, runtime);
 		}
-
-		const module = /** @type {CssModule} */ (moduleGraph.getParentModule(this));
-		const generator = /** @type {CssGenerator} */ (module.generator);
-		const names = this.getExportsConventionNames(
-			this.name,
-			/** @type {CssGeneratorExportsConvention} */
-			(generator.options.exportsConvention)
-		);
-
-		return {
-			exports: [...names].map((name) => ({
-				name,
-				canMangle: true
-			})),
-			dependencies: undefined
-		};
+		if (referenced.length === 0) {
+			return super.getReferencedExports(moduleGraph, runtime);
+		}
+		return referenced;
 	}
 
 	/**
@@ -409,42 +377,48 @@ class CssIcssExportDependency extends NullDependency {
 	 * @returns {WebpackError[] | null | undefined} warnings
 	 */
 	getWarnings(moduleGraph) {
-		if (
-			this.exportMode === CssIcssExportDependency.EXPORT_MODE.SELF_REFERENCE &&
-			typeof this.value === "string"
-		) {
-			const module =
-				/** @type {CssModule | undefined} */
-				(moduleGraph.getParentModule(this));
-
-			if (!module) return null;
-
-			// `ExportsInfo` only stores names produced by `exportsConvention`,
-			// so a raw `isExportProvided(this.value)` check is a false-positive
-			// for `camel-case-only` / `dashes-only` (and any custom function
-			// that drops the original spelling). Treat the composed class as
-			// provided if *any* of its convention-produced aliases is provided.
-			const generator = /** @type {CssGenerator} */ (module.generator);
-			const exportsInfo = moduleGraph.getExportsInfo(module);
-			const names = this.getValueConventionNames(
-				/** @type {CssGeneratorExportsConvention} */
-				(generator.options.exportsConvention)
-			);
-			const isProvided = names.some((name) =>
-				exportsInfo.isExportProvided(name)
+		/** @type {WebpackErrorType[] | null} */
+		let warnings = null;
+		let module;
+		let exportsInfo;
+		let convention;
+		for (const entry of this.entries) {
+			if (
+				entry.exportMode !== EXPORT_MODE.SELF_REFERENCE ||
+				typeof entry.value !== "string"
+			) {
+				continue;
+			}
+			if (module === undefined) {
+				module =
+					/** @type {CssModule | undefined} */
+					(moduleGraph.getParentModule(this));
+				if (!module) return warnings;
+				const generator = /** @type {CssGenerator} */ (module.generator);
+				convention =
+					/** @type {CssGeneratorExportsConvention} */
+					(generator.options.exportsConvention);
+				exportsInfo = moduleGraph.getExportsInfo(module);
+			}
+			const names = entryValueConventionNames(
+				entry,
+				/** @type {CssGeneratorExportsConvention} */ (convention)
 			);
-
+			const ei = /** @type {NonNullable<typeof exportsInfo>} */ (exportsInfo);
+			const isProvided = names.some((name) => ei.isExportProvided(name));
 			if (!isProvided) {
 				const error = new WebpackError(
-					`Self-referencing name "${this.value}" not found`
+					`Self-referencing name "${entry.value}" not found`
 				);
 				error.module = module;
-
-				return [error];
+				// Per-entry loc so Compilation attributes the warning precisely
+				// (it can't use the consolidated dependency's single loc).
+				if (entry.loc) error.loc = entry.loc;
+				if (warnings === null) warnings = [];
+				warnings.push(error);
 			}
 		}
-
-		return null;
+		return warnings;
 	}
 
 	/**
@@ -459,16 +433,19 @@ class CssIcssExportDependency extends NullDependency {
 				/** @type {CssModule} */
 				(chunkGraph.moduleGraph.getParentModule(this));
 			const generator = /** @type {CssGenerator} */ (module.generator);
-			const names = this.getExportsConventionNames(
-				this.name,
+			const convention =
 				/** @type {CssGeneratorExportsConvention} */
-				(generator.options.exportsConvention)
-			);
-			// Include all instance state that affects the emitted output —
-			// `name`, `value`, `range`, `interpolate`, `exportMode`,
-			// `exportType` — so changes like switching `composes: foo` →
-			// `composes: bar` or `ONCE` → `APPEND` invalidate caches.
-			this._hashUpdate = `exportsConvention|${JSON.stringify(names)}|localIdentName|${JSON.stringify(generator.options.localIdentName)}|value|${JSON.stringify(this.value)}|range|${JSON.stringify(this.range)}|interpolate|${this.interpolate}|exportMode|${this.exportMode}|exportType|${this.exportType}`;
+				(generator.options.exportsConvention);
+			const localIdentName = JSON.stringify(generator.options.localIdentName);
+			// Concatenate each entry's contribution with no separator so the byte
+			// stream matches the legacy per-export `updateHash` sequence exactly
+			// (keeps module hashes stable for import-free modules).
+			let update = "";
+			for (const entry of this.entries) {
+				const names = entryConventionNames(entry, convention);
+				update += `exportsConvention|${JSON.stringify(names)}|localIdentName|${localIdentName}|value|${JSON.stringify(entry.value)}|range|${JSON.stringify(entry.range)}|interpolate|${entry.interpolate}|exportMode|${entry.exportMode}|exportType|${entry.exportType}`;
+			}
+			this._hashUpdate = update;
 		}
 		hash.update(this._hashUpdate);
 	}
@@ -479,12 +456,16 @@ class CssIcssExportDependency extends NullDependency {
 	 */
 	serialize(context) {
 		const { write } = context;
-		write(this.name);
-		write(this.value);
-		write(this.range);
-		write(this.interpolate);
-		write(this.exportMode);
-		write(this.exportType);
+		write(this.entries.length);
+		for (const entry of this.entries) {
+			write(entry.name);
+			write(entry.value);
+			write(entry.range);
+			write(entry.interpolate);
+			write(entry.exportMode);
+			write(entry.exportType);
+			write(entry.loc);
+		}
 		super.serialize(context);
 	}
 
@@ -494,110 +475,134 @@ class CssIcssExportDependency extends NullDependency {
 	 */
 	deserialize(context) {
 		const { read } = context;
-		this.name = read();
-		this.value = read();
-		this.range = read();
-		this.interpolate = read();
-		this.exportMode = read();
-		this.exportType = read();
+		const length = /** @type {number} */ (read());
+		/** @type {CssExportEntry[]} */
+		const entries = [];
+		for (let i = 0; i < length; i++) {
+			entries.push({
+				name: /** @type {string} */ (read()),
+				value: /** @type {Value} */ (read()),
+				range: /** @type {Range=} */ (read()),
+				interpolate: /** @type {boolean} */ (read()),
+				exportMode: /** @type {ExportMode} */ (read()),
+				exportType: /** @type {ExportType} */ (read()),
+				loc: /** @type {DependencyLocation=} */ (read())
+			});
+		}
+		this.entries = entries;
+		this._hashUpdate = undefined;
 		super.deserialize(context);
 	}
 }
 
+/**
+ * Get (or lazily build into `indexCache`) a name -> entries index for `dep`,
+ * so composes resolution does a Map lookup instead of scanning all entries per
+ * reference. The cache is owned by one `apply` call and GC'd with it.
+ * @param {Map<CssIcssExportDependency, Map<string, CssExportEntry[]>>} indexCache transient cache
+ * @param {CssIcssExportDependency} dep export dependency
+ * @returns {Map<string, CssExportEntry[]>} entries grouped by name
+ */
+const indexEntries = (indexCache, dep) => {
+	let map = indexCache.get(dep);
+	if (map === undefined) {
+		map = new Map();
+		for (const e of dep.entries) {
+			const list = map.get(e.name);
+			if (list) list.push(e);
+			else map.set(e.name, [e]);
+		}
+		indexCache.set(dep, map);
+	}
+	return map;
+};
+
+/**
+ * Finds the active `CssIcssImportDependency` for a given local name. When a
+ * `request` is provided the lookup also requires the import dependency's
+ * `request` to match, so references between two `@value foo from "..."`
+ * declarations resolve through the import in scope at the reference site.
+ * @param {Iterable<Dependency>} dependencies module dependencies to search
+ * @param {string} localName local name
+ * @param {string=} request user request of the `@value` import to match
+ * @returns {CssIcssImportDependency | undefined} matching import dep, if any
+ */
+const findImportDep = (dependencies, localName, request) => {
+	/** @type {CssIcssImportDependency | undefined} */
+	let firstMatch;
+	for (const d of dependencies) {
+		if (d instanceof CssIcssImportDependency && d.localName === localName) {
+			if (request === undefined) return d;
+			if (d.request === request) return d;
+			if (firstMatch === undefined) firstMatch = d;
+		}
+	}
+	return firstMatch;
+};
+
 CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
-	 * Returns found reference. The top-level call (no `seen` argument) is
-	 * memoized via `moduleGraph.cached` keyed by `(module, localName,
-	 * importName, request, chunkGraph, runtimeTemplate)`. Recursive callers
-	 * pass `seen` and skip the cache so the cycle guard is preserved — only
-	 * completed top-level resolutions land in the cache.
+	 * Resolves a `[localName, importName, request]` reference to its final
+	 * value by following `@value` imports into other modules' consolidated
+	 * export dependencies.
 	 * @param {string} localName local name
 	 * @param {string} importName import name
 	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @param {string | undefined} request user request of the `@value` import that was active when the reference was parsed — used to disambiguate when the same local name is imported from multiple modules
-	 * @param {Set<CssIcssExportDependency>=} seen seen to prevent cyclical problems
+	 * @param {string | undefined} request user request of the `@value` import
+	 * @param {Set<CssExportEntry>=} seen cycle guard
+	 * @param {Map<CssIcssExportDependency, Map<string, CssExportEntry[]>>=} indexCache transient per-codegen name index (shared with `resolveReferences` within one `apply`)
 	 * @returns {string | undefined} found reference
 	 */
-	static resolve(localName, importName, templateContext, request, seen) {
-		if (seen !== undefined) {
-			return CssIcssExportDependencyTemplate._doResolve(
-				localName,
-				importName,
-				templateContext,
-				request,
-				seen
-			);
-		}
-		const { moduleGraph, module, chunkGraph, runtimeTemplate } =
-			templateContext;
-		return moduleGraph.cached(
-			computeResolve,
-			/** @type {CssModule} */ (module),
+	static resolve(
+		localName,
+		importName,
+		templateContext,
+		request,
+		seen = new Set(),
+		indexCache = new Map()
+	) {
+		const { moduleGraph } = templateContext;
+		const importDep = findImportDep(
+			templateContext.module.dependencies,
 			localName,
-			importName,
-			request,
-			chunkGraph,
-			runtimeTemplate
+			request
 		);
-	}
-
-	/**
-	 * Inner recursive worker for `resolve`. Not memoized — see `resolve`.
-	 * @param {string} localName local name
-	 * @param {string} importName import name
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @param {string | undefined} request user request
-	 * @param {Set<CssIcssExportDependency>} seen seen to prevent cyclical problems
-	 * @returns {string | undefined} found reference
-	 */
-	static _doResolve(localName, importName, templateContext, request, seen) {
-		const { moduleGraph } = templateContext;
-		const importDep =
-			/** @type {CssIcssImportDependency | undefined} */
-			(
-				CssIcssExportDependencyTemplate.findImportDep(
-					templateContext.module.dependencies,
-					localName,
-					request
-				)
-			);
 		if (!importDep) return undefined;
 
 		const module = /** @type {CssModule} */ (moduleGraph.getModule(importDep));
 		if (!module) return undefined;
 
-		const exportDep =
-			/** @type {CssIcssExportDependency} */
-			(
-				module.dependencies.find(
-					(d) => d instanceof CssIcssExportDependency && d.name === importName
-				)
-			);
-
-		if (!exportDep) return undefined;
-
-		if (seen.has(exportDep)) return undefined;
-		seen.add(exportDep);
+		/** @type {CssExportEntry | undefined} */
+		let exportEntry;
+		for (const dep of module.dependencies) {
+			if (!(dep instanceof CssIcssExportDependency)) continue;
+			const matches = indexEntries(indexCache, dep).get(importName);
+			if (matches) {
+				exportEntry = matches[0];
+				break;
+			}
+		}
+		if (!exportEntry) return undefined;
+		if (seen.has(exportEntry)) return undefined;
+		seen.add(exportEntry);
 
-		const { value, interpolate } = exportDep;
+		const { value, interpolate } = exportEntry;
 
 		if (Array.isArray(value)) {
-			return CssIcssExportDependencyTemplate._doResolve(
+			return CssIcssExportDependencyTemplate.resolve(
 				value[0],
 				value[1],
-				{
-					...templateContext,
-					module
-				},
+				{ ...templateContext, module },
 				value[2],
-				seen
+				seen,
+				indexCache
 			);
 		}
 
 		if (interpolate) {
-			return CssIcssExportDependency.Template.getIdentifier(value, exportDep, {
+			return CssIcssExportDependencyTemplate.getIdentifier(value, exportEntry, {
 				...templateContext,
 				module
 			});
@@ -607,81 +612,26 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 	}
 
 	/**
-	 * Finds the active `CssIcssImportDependency` for a given local name. When a
-	 * `request` is provided the lookup also requires the import dependency's
-	 * `request` to match — this lets references that appear between two
-	 * `@value foo from "..."` declarations resolve through the import that was
-	 * in scope at the reference site, rather than always picking the first.
-	 * @param {Iterable<Dependency>} dependencies module dependencies to search
-	 * @param {string} localName local name
-	 * @param {string=} request user request of the `@value` import to match
-	 * @returns {CssIcssImportDependency | undefined} matching import dep, if any
-	 */
-	static findImportDep(dependencies, localName, request) {
-		/** @type {CssIcssImportDependency | undefined} */
-		let firstMatch;
-		for (const d of dependencies) {
-			if (d instanceof CssIcssImportDependency && d.localName === localName) {
-				if (request === undefined) return d;
-				if (d.request === request) return d;
-				if (firstMatch === undefined) firstMatch = d;
-			}
-		}
-		return firstMatch;
-	}
-
-	/**
-	 * Resolves references. The top-level call (no `seen` argument) is
-	 * memoized via `moduleGraph.cached`; recursive callers pass `seen` and
-	 * bypass the cache to keep the cycle guard intact.
-	 * @param {CssIcssExportDependency} dep value
-	 * @param {DependencyTemplateContext} templateContext template context
-	 * @param {Set<CssIcssExportDependency>=} seen to prevent cyclical problems
-	 * @returns {string[]} final names
-	 */
-	static resolveReferences(dep, templateContext, seen) {
-		if (seen !== undefined) {
-			return CssIcssExportDependencyTemplate._doResolveReferences(
-				dep,
-				templateContext,
-				seen
-			);
-		}
-		const { moduleGraph, module, chunkGraph, runtimeTemplate } =
-			templateContext;
-		return moduleGraph.cached(
-			computeResolveReferences,
-			dep,
-			/** @type {CssModule} */ (module),
-			chunkGraph,
-			runtimeTemplate
-		);
-	}
-
-	/**
-	 * Inner recursive worker for `resolveReferences`. Not memoized.
-	 * @param {CssIcssExportDependency} dep value
+	 * Resolves all references of a `composes` entry, deduplicated.
+	 * @param {CssExportEntry} entry composes entry
 	 * @param {DependencyTemplateContext} templateContext template context
-	 * @param {Set<CssIcssExportDependency>} seen to prevent cyclical problems
+	 * @param {Set<CssExportEntry>} seen cycle guard
+	 * @param {Map<CssIcssExportDependency, Map<string, CssExportEntry[]>>} indexCache transient per-codegen name index, discarded after the module's `apply` (so it isn't retained on the dependency)
 	 * @returns {string[]} final names
 	 */
-	static _doResolveReferences(dep, templateContext, seen) {
+	static resolveReferences(entry, templateContext, seen, indexCache) {
 		/** @type {string[]} */
 		const references = [];
 
-		if (seen.has(dep)) return references;
-		seen.add(dep);
-
-		if (Array.isArray(dep.value)) {
-			const importDep =
-				/** @type {CssIcssImportDependency | undefined} */
-				(
-					CssIcssExportDependencyTemplate.findImportDep(
-						templateContext.module.dependencies,
-						dep.value[0],
-						dep.value[2]
-					)
-				);
+		if (seen.has(entry)) return references;
+		seen.add(entry);
+
+		if (Array.isArray(entry.value)) {
+			const importDep = findImportDep(
+				templateContext.module.dependencies,
+				entry.value[0],
+				entry.value[2]
+			);
 			if (!importDep) return references;
 
 			const module =
@@ -689,55 +639,60 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 				(templateContext.moduleGraph.getModule(importDep));
 			if (!module) return references;
 
-			for (const d of module.dependencies) {
-				if (d instanceof CssIcssExportDependency && d.name === dep.value[1]) {
+			// Same overridden context and target name for every matched entry — build once, not per entry.
+			const subContext = { ...templateContext, module };
+			const name = /** @type {string[]} */ (entry.value)[1];
+			for (const dep of module.dependencies) {
+				if (!(dep instanceof CssIcssExportDependency)) continue;
+				const matches = indexEntries(indexCache, dep).get(name);
+				if (!matches) continue;
+				for (const d of matches) {
 					if (Array.isArray(d.value)) {
-						const deepReferences =
-							CssIcssExportDependencyTemplate._doResolveReferences(
+						references.push(
+							...CssIcssExportDependencyTemplate.resolveReferences(
 								d,
-								{
-									...templateContext,
-									module
-								},
-								seen
-							);
-
-						references.push(...deepReferences);
+								subContext,
+								seen,
+								indexCache
+							)
+						);
 					} else {
 						references.push(
-							CssIcssExportDependencyTemplate.getIdentifier(d.value, d, {
-								...templateContext,
-								module
-							})
+							CssIcssExportDependencyTemplate.getIdentifier(
+								d.value,
+								d,
+								subContext
+							)
 						);
 					}
 				}
 			}
 		} else {
-			// Adding basic class
 			references.push(
 				CssIcssExportDependencyTemplate.getIdentifier(
-					dep.value,
-					dep,
+					/** @type {string} */ (entry.value),
+					entry,
 					templateContext
 				)
 			);
 
-			for (const d of templateContext.module.dependencies) {
-				if (
-					d instanceof CssIcssExportDependency &&
-					d.exportType === CssIcssExportDependency.EXPORT_TYPE.COMPOSES &&
-					d.name === dep.value
-				) {
+			for (const dep of templateContext.module.dependencies) {
+				if (!(dep instanceof CssIcssExportDependency)) continue;
+				const matches = indexEntries(indexCache, dep).get(
+					/** @type {string} */ (entry.value)
+				);
+				if (!matches) continue;
+				for (const d of matches) {
+					if (d.exportType !== EXPORT_TYPE.COMPOSES) continue;
 					if (Array.isArray(d.value)) {
-						const deepReferences =
-							CssIcssExportDependencyTemplate._doResolveReferences(
+						references.push(
+							...CssIcssExportDependencyTemplate.resolveReferences(
 								d,
 								templateContext,
-								seen
-							);
-
-						references.push(...deepReferences);
+								seen,
+								indexCache
+							)
+						);
 					} else {
 						references.push(
 							CssIcssExportDependencyTemplate.getIdentifier(
@@ -751,30 +706,25 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 			}
 		}
 
-		return [...new Set(references)];
+		return references.length > 1 ? [...new Set(references)] : references;
 	}
 
 	/**
-	 * Returns identifier. When the dep opts into interpolation the full
-	 * computation is memoized via `moduleGraph.cached` keyed by
-	 * `(module, value, exportType, chunkGraph, runtimeTemplate)` so
-	 * `cssExportConvention` / `getLocalIdent` / `escapeIdentifier` are not
-	 * re-run for the same identifier during code generation.
+	 * Returns the interpolated identifier for an entry value.
 	 * @param {string} value value to identifier
-	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {CssExportEntry} entry the entry
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {string} identifier
 	 */
-	static getIdentifier(value, dependency, templateContext) {
-		const dep = /** @type {CssIcssExportDependency} */ (dependency);
-		if (!dep.interpolate) return value;
+	static getIdentifier(value, entry, templateContext) {
+		if (!entry.interpolate) return value;
 		const { moduleGraph, module, chunkGraph, runtimeTemplate } =
 			templateContext;
 		return moduleGraph.cached(
 			computeInterpolatedIdentifier,
 			/** @type {CssModule} */ (module),
 			value,
-			dep.exportType,
+			entry.exportType,
 			chunkGraph,
 			runtimeTemplate
 		);
@@ -789,143 +739,131 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 	 */
 	apply(dependency, source, templateContext) {
 		const dep = /** @type {CssIcssExportDependency} */ (dependency);
-		if (!dep.range && templateContext.type !== JAVASCRIPT_TYPE) return;
 		const { module: m, moduleGraph, runtime, cssData } = templateContext;
 		const module = /** @type {CssModule} */ (m);
 		const generator = /** @type {CssGenerator} */ (module.generator);
-		const isReference = Array.isArray(dep.value);
-
-		/** @type {string} */
-		let value;
-
-		// The `composes` has more complex logic for collecting all the classes
-		if (
-			dep.exportType === CssIcssExportDependency.EXPORT_TYPE.COMPOSES &&
-			templateContext.type === JAVASCRIPT_TYPE
-		) {
-			value = CssIcssExportDependencyTemplate.resolveReferences(
-				dep,
-				templateContext
-			).join(" ");
-		} else if (isReference) {
-			const resolved = CssIcssExportDependencyTemplate.resolve(
-				dep.value[0],
-				dep.value[1],
-				templateContext,
-				dep.value[2]
-			);
+		const isJs = templateContext.type === JAVASCRIPT_TYPE;
+		// All entries belong to this one module, so resolve its ExportsInfo once
+		// instead of re-resolving `module -> exportsInfo` per export name.
+		const exportsInfo = isJs ? moduleGraph.getExportsInfo(module) : undefined;
+		// Transient name index for composes resolution within this module's codegen; GC'd when apply returns (never retained on the dependency).
+		/** @type {Map<CssIcssExportDependency, Map<string, CssExportEntry[]>>} */
+		const indexCache = new Map();
+
+		for (const entry of dep.entries) {
+			if (!entry.range && !isJs) continue;
+			const isReference = Array.isArray(entry.value);
 
-			// Fallback to the local name if not resolved
-			value = resolved || dep.value[0];
-		} else {
-			value = CssIcssExportDependencyTemplate.getIdentifier(
-				/** @type {string} */ (dep.value),
-				dep,
-				templateContext
-			);
-		}
+			/** @type {string} */
+			let value;
+			if (entry.exportType === EXPORT_TYPE.COMPOSES && isJs) {
+				value = CssIcssExportDependencyTemplate.resolveReferences(
+					entry,
+					templateContext,
+					new Set(),
+					indexCache
+				).join(" ");
+			} else if (isReference) {
+				const resolved = CssIcssExportDependencyTemplate.resolve(
+					/** @type {string[]} */ (entry.value)[0],
+					/** @type {string[]} */ (entry.value)[1],
+					templateContext,
+					/** @type {string[]} */ (entry.value)[2],
+					new Set(),
+					indexCache
+				);
+				value = resolved || /** @type {string[]} */ (entry.value)[0];
+			} else {
+				value = CssIcssExportDependencyTemplate.getIdentifier(
+					/** @type {string} */ (entry.value),
+					entry,
+					templateContext
+				);
+			}
 
-		if (
-			dep.exportType ===
-			CssIcssExportDependency.EXPORT_TYPE.GRID_CUSTOM_IDENTIFIER
-		) {
-			value += `-${dep.name}`;
-		}
+			if (entry.exportType === EXPORT_TYPE.GRID_CUSTOM_IDENTIFIER) {
+				value += `-${entry.name}`;
+			}
 
-		if (
-			templateContext.type === JAVASCRIPT_TYPE &&
-			dep.exportMode !== CssIcssExportDependency.EXPORT_MODE.NONE
-		) {
-			const names = dep.getExportsConventionNames(
-				dep.name,
-				/** @type {CssGeneratorExportsConvention} */
-				(generator.options.exportsConvention)
-			);
-			const usedNames =
-				/** @type {string[]} */
-				(
-					names
-						.map((name) =>
-							moduleGraph.getExportInfo(module, name).getUsedName(name, runtime)
-						)
-						.filter(Boolean)
+			if (isJs && entry.exportMode !== EXPORT_MODE.NONE) {
+				const names = entryConventionNames(
+					entry,
+					/** @type {CssGeneratorExportsConvention} */
+					(generator.options.exportsConvention)
+				);
+				/** @type {Set<string>} */
+				const allNames = new Set();
+				for (const name of names) {
+					const usedName = /** @type {NonNullable<typeof exportsInfo>} */ (
+						exportsInfo
+					)
+						.getExportInfo(name)
+						.getUsedName(name, runtime);
+					if (usedName) allNames.add(/** @type {string} */ (usedName));
+				}
+				for (const name of names) allNames.add(name);
+				const unescaped = getCssTokens().unescapeIdentifier(
+					value,
+					templateContext.runtimeTemplate.compilation.compiler.root
 				);
-			const allNames = new Set([...usedNames, ...names]);
-			const unescaped = getCssParser().unescapeIdentifier(
-				value,
-				templateContext.runtimeTemplate.compilation.compiler.root
-			);
 
-			const depLocStart =
-				dep.loc &&
-				/** @type {{ start?: { line: number, column: number } }} */ (dep.loc)
-					.start;
-			for (const used of allNames) {
-				if (dep.exportMode === CssIcssExportDependency.EXPORT_MODE.ONCE) {
-					if (cssData.exports.has(used)) return;
-					cssData.exports.set(used, unescaped);
-					if (
-						depLocStart &&
-						cssData.exportLocs &&
-						!cssData.exportLocs.has(used)
-					) {
-						cssData.exportLocs.set(used, {
-							line: depLocStart.line,
-							column: depLocStart.column
-						});
-					}
-				} else {
-					const originalValue =
-						dep.exportMode === CssIcssExportDependency.EXPORT_MODE.REPLACE
-							? undefined
-							: cssData.exports.get(used);
-
-					cssData.exports.set(
-						used,
-						`${originalValue ? `${originalValue}${unescaped ? " " : ""}` : ""}${unescaped}`
-					);
-					// Record the source location once per export (use the first
-					// occurrence — for APPEND/REPLACE this corresponds to the
-					// first selector seen, which is a reasonable anchor).
-					if (
-						depLocStart &&
-						cssData.exportLocs &&
-						!cssData.exportLocs.has(used)
-					) {
-						cssData.exportLocs.set(used, {
-							line: depLocStart.line,
-							column: depLocStart.column
-						});
+				const depLocStart =
+					entry.loc &&
+					/** @type {{ start?: { line: number, column: number } }} */ (
+						entry.loc
+					).start;
+				for (const used of allNames) {
+					if (entry.exportMode === EXPORT_MODE.ONCE) {
+						if (cssData.exports.has(used)) continue;
+						cssData.exports.set(used, unescaped);
+						if (
+							depLocStart &&
+							cssData.exportLocs &&
+							!cssData.exportLocs.has(used)
+						) {
+							cssData.exportLocs.set(used, {
+								line: depLocStart.line,
+								column: depLocStart.column
+							});
+						}
+					} else {
+						const originalValue =
+							entry.exportMode === EXPORT_MODE.REPLACE
+								? undefined
+								: cssData.exports.get(used);
+						cssData.exports.set(
+							used,
+							`${originalValue ? `${originalValue}${unescaped ? " " : ""}` : ""}${unescaped}`
+						);
+						if (
+							depLocStart &&
+							cssData.exportLocs &&
+							!cssData.exportLocs.has(used)
+						) {
+							cssData.exportLocs.set(used, {
+								line: depLocStart.line,
+								column: depLocStart.column
+							});
+						}
 					}
 				}
+			} else if (
+				entry.range &&
+				templateContext.type !== JAVASCRIPT_TYPE &&
+				entry.exportMode !== EXPORT_MODE.APPEND &&
+				entry.exportMode !== EXPORT_MODE.SELF_REFERENCE
+			) {
+				source.replace(entry.range[0], entry.range[1] - 1, value);
 			}
-		} else if (
-			dep.range &&
-			templateContext.type === CSS_TYPE &&
-			dep.exportMode !== CssIcssExportDependency.EXPORT_MODE.APPEND &&
-			dep.exportMode !== CssIcssExportDependency.EXPORT_MODE.SELF_REFERENCE
-		) {
-			source.replace(dep.range[0], dep.range[1] - 1, value);
 		}
 	}
 };
 
 /** @type {Record<"NONE" | "REPLACE" | "APPEND" | "ONCE" | "SELF_REFERENCE", ExportMode>} */
-CssIcssExportDependency.EXPORT_MODE = {
-	NONE: 0,
-	REPLACE: 1,
-	APPEND: 2,
-	ONCE: 3,
-	SELF_REFERENCE: 4
-};
+CssIcssExportDependency.EXPORT_MODE = EXPORT_MODE;
 
 /** @type {Record<"NORMAL" | "CUSTOM_VARIABLE" | "GRID_CUSTOM_IDENTIFIER" | "COMPOSES", ExportType>} */
-CssIcssExportDependency.EXPORT_TYPE = {
-	NORMAL: 0,
-	CUSTOM_VARIABLE: 1,
-	GRID_CUSTOM_IDENTIFIER: 2,
-	COMPOSES: 3
-};
+CssIcssExportDependency.EXPORT_TYPE = EXPORT_TYPE;
 
 makeSerializable(
 	CssIcssExportDependency,