Method emitComposesWithAnchor

lib/css/CssParser.js:2387–2532

(decl)

		 * @param {Declaration} decl the `composes` declaration
		 */
		const emitComposesWithAnchor = (decl) => {
			if (currentRule.localIdentifiers.length > 1) {
				this._emitWarning(
					state,
					`Composition is only allowed when selector is single local class name not in "${currentRule.localIdentifiers.join(
						'", "'
					)}"`,
					locConverter,
					A.start(decl),
					A.end(decl)
				);
				return;
			}
			const lastLocalIdentifier = currentRule.localIdentifiers[0];

			// Split the value at top-level commas — each segment is one `<name>+ [from <source>]` group.
			/** @type {AstNode[][]} */
			const groups = [];
			/** @type {AstNode[]} */
			let currentGroup = [];
			for (const cv of A.children(decl)) {
				if (A.type(cv) === NodeType.Comma) {
					groups.push(currentGroup);
					currentGroup = [];
				} else {
					currentGroup.push(cv);
				}
			}
			groups.push(currentGroup);

			// Inline scan + dispatch per group — warm path (composes-heavy modules), so no per-group result object is allocated.
			for (const group of groups) {
				/** @type {{ start: number, end: number, isGlobal: boolean }[]} */
				const classNames = [];
				/** @type {"names" | "expecting-source" | "done"} */
				let phase = "names";
				/** @type {{ kind: "string", path: string } | { kind: "global" } | undefined} */
				let fromSource;
				/** @type {AstNode | undefined} */
				let errorToken;
				let errorMessage = "";

				for (let i = 0; i < group.length; i++) {
					const cv = group[i];
					if (A.type(cv) === NodeType.Whitespace) continue;

					if (phase === "expecting-source") {
						if (A.type(cv) === NodeType.String) {
							fromSource = {
								kind: "string",
								path: source.slice(A.start(cv) + 1, A.end(cv) - 1)
							};
							phase = "done";
							continue;
						}
						if (
							A.type(cv) === NodeType.Ident &&
							equalsLowerCase(A.value(cv), "global")