@codefast/cli 0.3.13-canary.3 → 0.3.13

package/dist/lib/arrange/domain/grouping.domain.mjs

@@ -0,0 +1,306 @@
+import { BUCKET_ORDER } from "./constants.domain.mjs";
+import { bucketsCompatible, bucketsMergeCompatible, classifyToken, compositeSecondaryOrder, selectorKey, stateKey, stripVariants, tokenizeClassString } from "./tokenizer.util.mjs";
+//#region src/lib/arrange/domain/grouping.domain.ts
+/**
+* `cn()` grouping: bucket sequence is {@link BUCKET_ORDER} only; tokens are classified with
+* {@link classifyToken}. Comparators here (`compareClassifiedTailwindTokensForCnGrouping`, …)
+* are the single place for variant-aware sort — do not reintroduce parallel bucket ordering.
+*/ /** Separates bucket id from variant key in {@link buildFirstVariantKeySourceIndex} map keys. */ const VARIANT_BUCKET_KEY_SEP = "\0";
+function isVariantKeyedBucket(bucket) {
+	return bucket === "selector" || bucket === "state" || bucket === "starting";
+}
+function variantGroupKey(bucket, classToken) {
+	return bucket === "selector" ? selectorKey(classToken) : stateKey(classToken);
+}
+function variantKeyedBlockMapKey(bucket, classToken) {
+	return `${bucket}${VARIANT_BUCKET_KEY_SEP}${variantGroupKey(bucket, classToken)}`;
+}
+/**
+* Deterministic lexicographic order for Tailwind class tokens (and token-space signatures).
+* Used wherever we need stable, locale-agnostic ASCII ordering of utility strings.
+*/ function compareClassTokensCanonically(left, right) {
+	return left.localeCompare(right);
+}
+/**
+* First source index where each `(bucket, variantGroupKey)` appears — drives stable clustering
+* in {@link suggestCnGroups} without reordering unrelated variant blocks by alphabet alone.
+*/ function buildFirstVariantKeySourceIndex(classified) {
+	const firstVariantKeySourceIndex = /* @__PURE__ */ new Map();
+	for (const item of classified) {
+		if (!isVariantKeyedBucket(item.bucket)) continue;
+		const mapKey = variantKeyedBlockMapKey(item.bucket, item.classToken);
+		const prior = firstVariantKeySourceIndex.get(mapKey);
+		if (prior === void 0 || item.index < prior) firstVariantKeySourceIndex.set(mapKey, item.index);
+	}
+	return firstVariantKeySourceIndex;
+}
+function compareClassifiedTailwindTokensForCnGrouping(left, right, firstVariantKeySourceIndex) {
+	const bucketOrderDiff = BUCKET_ORDER[left.bucket] - BUCKET_ORDER[right.bucket];
+	if (bucketOrderDiff !== 0) return bucketOrderDiff;
+	if (left.bucket === "composite" && right.bucket === "composite") {
+		const compositeOrderDiff = compositeSecondaryOrder(stripVariants(left.classToken)) - compositeSecondaryOrder(stripVariants(right.classToken));
+		if (compositeOrderDiff !== 0) return compositeOrderDiff;
+		return left.index - right.index;
+	}
+	if (isVariantKeyedBucket(left.bucket) && isVariantKeyedBucket(right.bucket)) {
+		const leftMapKey = variantKeyedBlockMapKey(left.bucket, left.classToken);
+		const rightMapKey = variantKeyedBlockMapKey(right.bucket, right.classToken);
+		const leftBlockStart = firstVariantKeySourceIndex.get(leftMapKey);
+		const rightBlockStart = firstVariantKeySourceIndex.get(rightMapKey);
+		if (leftBlockStart === void 0 || rightBlockStart === void 0) throw new Error("invariant: variant-keyed token missing block start index");
+		if (leftBlockStart !== rightBlockStart) return leftBlockStart - rightBlockStart;
+		const variantKeyCompare = compareClassTokensCanonically(variantGroupKey(left.bucket, left.classToken), variantGroupKey(right.bucket, right.classToken));
+		if (variantKeyCompare !== 0) return variantKeyCompare;
+		return compareClassTokensCanonically(left.classToken, right.classToken);
+	}
+	return left.index - right.index;
+}
+/**
+* True when `staticLiteralTexts` carries the **same partition** of Tailwind tokens as
+* `suggestedGroups` from {@link suggestCnGroups}, ignoring order of arguments and
+* order of tokens within each chunk.
+*/ function areCnTailwindPartitionsEquivalent(staticLiteralTexts, suggestedGroups) {
+	const partitionSignatures = (chunks) => chunks.map((chunk) => {
+		const classTokens = tokenizeClassString(chunk);
+		return classTokens.length === 0 ? "" : [...classTokens].sort(compareClassTokensCanonically).join(" ");
+	}).filter((s) => s.length > 0).sort(compareClassTokensCanonically);
+	const staticPartitionSigs = partitionSignatures(staticLiteralTexts);
+	const suggestedPartitionSigs = partitionSignatures(suggestedGroups);
+	if (staticPartitionSigs.length !== suggestedPartitionSigs.length) return false;
+	for (let i = 0; i < staticPartitionSigs.length; i++) if (staticPartitionSigs[i] !== suggestedPartitionSigs[i]) return false;
+	return true;
+}
+/** Dominant bucket of a whitespace-delimited class group (for merge heuristics). */ function dominantBucketOfGroup(groupStr) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const classToken of tokenizeClassString(groupStr)) {
+		const tokenBucket = classifyToken(classToken);
+		counts.set(tokenBucket, (counts.get(tokenBucket) ?? 0) + 1);
+	}
+	let best = "other";
+	let bestN = 0;
+	for (const [bucket, count] of counts) {
+		if (count > bestN) {
+			best = bucket;
+			bestN = count;
+			continue;
+		}
+		if (count === bestN && BUCKET_ORDER[bucket] < BUCKET_ORDER[best]) best = bucket;
+	}
+	return best;
+}
+/** Dynamic cap: more tokens → allow more groups, within [BASE, CAP]. */ function dynamicMaxGroups(tokenCount) {
+	const byTokens = Math.ceil(tokenCount / 2) + 2;
+	return Math.max(4, Math.min(24, byTokens));
+}
+/**
+* Merge singleton groups (< MIN_GROUP_TOKENS tokens) into their nearest
+* neighbour. Prefers merging toward a bucket-compatible neighbor.
+*
+* Loop termination: each iteration either splices one element (shrinking the
+* array, guaranteeing progress) or finds no singleton that can merge and exits
+* via `changed = false`. Two mutually-incompatible singletons both hit
+* `continue` and `changed` stays false, so the loop exits without spinning.
+*/ function mergeSingletons(groups) {
+	if (groups.length <= 1) return groups;
+	const result = [...groups];
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (let i = 0; i < result.length; i++) {
+			const groupAtI = result[i];
+			if (groupAtI === void 0) throw new Error("invariant: mergeSingletons group missing");
+			if (tokenizeClassString(groupAtI).length < 2) {
+				if (result.length === 1) break;
+				const myBucket = dominantBucketOfGroup(groupAtI);
+				const prevGroup = i > 0 ? result[i - 1] : void 0;
+				const nextGroup = i < result.length - 1 ? result[i + 1] : void 0;
+				const prevCompat = prevGroup !== void 0 && bucketsMergeCompatible(myBucket, dominantBucketOfGroup(prevGroup));
+				const nextCompat = nextGroup !== void 0 && bucketsMergeCompatible(myBucket, dominantBucketOfGroup(nextGroup));
+				let mergeDir;
+				if (nextCompat && !prevCompat) mergeDir = "forward";
+				else if (prevCompat && !nextCompat) mergeDir = "backward";
+				else if (prevCompat && nextCompat) mergeDir = i < result.length - 1 ? "forward" : "backward";
+				else continue;
+				if (mergeDir === "forward") {
+					if (nextGroup === void 0) throw new Error("invariant: forward merge missing right group");
+					result[i + 1] = `${groupAtI} ${nextGroup}`;
+				} else {
+					if (prevGroup === void 0) throw new Error("invariant: backward merge missing left group");
+					result[i - 1] = `${prevGroup} ${groupAtI}`;
+				}
+				result.splice(i, 1);
+				changed = true;
+				break;
+			}
+		}
+	}
+	return result;
+}
+/** Tie-break when two merge candidates are both {@link bucketsMergeCompatible} (same bucket or COMPATIBLE_BUCKET_SETS). */ function capMergePenalty(leftBucket, rightBucket) {
+	if (leftBucket === rightBucket) return 0;
+	if (bucketsCompatible(leftBucket, rightBucket)) return 0;
+	return 500;
+}
+/**
+* Merge adjacent groups until total count ≤ maxGroups.
+* Only merges pairs allowed by {@link bucketsMergeCompatible} — never glues incompatible
+* buckets (which previously defaulted to penalty 0 and merged layout+state when over cap).
+*
+* Complexity: O(n²) in the number of groups — each merge pass scans all remaining adjacent
+* pairs. In practice `n` is bounded by {@link MAX_GROUPS_CAP} (24) and typical class strings
+* are well below that, so this is not a concern for the current usage pattern. If this ever
+* runs in a high-throughput batch mode, consider a priority-queue approach.
+*/ function capGroups(groups, maxGroups) {
+	const result = [...groups];
+	const lengths = result.map((groupStr) => tokenizeClassString(groupStr).length);
+	while (result.length > maxGroups) {
+		const mergePairCandidates = [];
+		for (let i = 0; i < result.length - 1; i++) {
+			const leftGroup = result[i];
+			const rightGroup = result[i + 1];
+			const leftLen = lengths[i];
+			const rightLen = lengths[i + 1];
+			if (leftGroup === void 0 || rightGroup === void 0 || leftLen === void 0 || rightLen === void 0) throw new Error("invariant: capGroups adjacent pair missing");
+			const dominantLeft = dominantBucketOfGroup(leftGroup);
+			const dominantRight = dominantBucketOfGroup(rightGroup);
+			if (!bucketsMergeCompatible(dominantLeft, dominantRight)) continue;
+			mergePairCandidates.push({
+				i,
+				size: leftLen + rightLen,
+				penalty: capMergePenalty(dominantLeft, dominantRight)
+			});
+		}
+		if (mergePairCandidates.length === 0) break;
+		const firstCandidate = mergePairCandidates[0];
+		if (firstCandidate === void 0) throw new Error("invariant: merge candidates empty");
+		let best = firstCandidate;
+		for (const candidate of mergePairCandidates) if (candidate.penalty < best.penalty || candidate.penalty === best.penalty && candidate.size < best.size) best = candidate;
+		const bestIdx = best.i;
+		const leftMerge = result[bestIdx];
+		const rightMerge = result[bestIdx + 1];
+		const leftMergeLen = lengths[bestIdx];
+		const rightMergeLen = lengths[bestIdx + 1];
+		if (leftMerge === void 0 || rightMerge === void 0 || leftMergeLen === void 0 || rightMergeLen === void 0) throw new Error("invariant: capGroups best merge pair missing");
+		result[bestIdx] = `${leftMerge} ${rightMerge}`;
+		lengths[bestIdx] = leftMergeLen + rightMergeLen;
+		result.splice(bestIdx + 1, 1);
+		lengths.splice(bestIdx + 1, 1);
+	}
+	return result;
+}
+/**
+* If a chunk is **only** bare `ease-*` timing (Motion), buffer it and prepend to the **first**
+* **later** chunk that is predominantly `state` **and** contains some `animate-*` utility —
+* skipping intermediate `state` chunks (`sm:…`, `group-data-[…]:…`, etc.) that sit between
+* `ease-ui` and `data-open:animate-*`. If no such chunk exists, the ease chunk is left as-is.
+*/ function mergeEaseTimingIntoFollowingAnimatedState(groups) {
+	const result = [...groups];
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (let i = 0; i < result.length; i++) {
+			const chunkI = result[i];
+			if (chunkI === void 0) throw new Error("invariant: mergeEase chunk missing");
+			if (!chunkIsOnlyEaseTimingMotion(chunkI)) continue;
+			const easeStr = chunkI;
+			let target = -1;
+			for (let j = i + 1; j < result.length; j++) {
+				const chunkJ = result[j];
+				if (chunkJ === void 0) throw new Error("invariant: mergeEase following chunk missing");
+				if (dominantBucketOfGroup(chunkJ) !== "state") continue;
+				if (!tokenizeClassString(chunkJ).some((classToken) => /^animate/.test(stripVariants(classToken)))) continue;
+				target = j;
+				break;
+			}
+			if (target === -1) continue;
+			const targetChunk = result[target];
+			if (targetChunk === void 0) throw new Error("invariant: mergeEase target chunk missing");
+			result[target] = `${easeStr} ${targetChunk}`.trim();
+			result.splice(i, 1);
+			changed = true;
+			break;
+		}
+	}
+	return result;
+}
+function chunkIsOnlyEaseTimingMotion(groupStr) {
+	const classTokens = tokenizeClassString(groupStr);
+	if (classTokens.length === 0) return false;
+	return classTokens.every((classToken) => classifyToken(classToken) === "motion" && /^ease-/.test(stripVariants(classToken)));
+}
+function suggestCnGroups(classString) {
+	const tokens = tokenizeClassString(classString);
+	if (tokens.length === 0) return [];
+	/**
+	* Variant-keyed buckets (`state`, `starting`, `selector`): after global bucket ordering,
+	* cluster tokens that share the same {@link variantGroupKey} so the same modifier stack
+	* (e.g. `focus-visible:`) merges one `cn()` arg regardless of interleaved unrelated
+	* variants. Block order follows the **first source index** of each key so unrelated
+	* states keep document order; within a key, `classToken` order is lexicographic for
+	* idempotency.
+	*/ const classified = tokens.map((classToken, index) => ({
+		classToken,
+		bucket: classifyToken(classToken),
+		index
+	}));
+	const firstVariantKeySourceIndex = buildFirstVariantKeySourceIndex(classified);
+	classified.sort((left, right) => compareClassifiedTailwindTokensForCnGrouping(left, right, firstVariantKeySourceIndex));
+	const rawGroups = [];
+	/** Bucket of the last token already placed in the current run (pairwise compat with `COMPATIBLE_BUCKET_SETS`). */ let lastBucketInRun = null;
+	let currentStateKey = null;
+	let currentTokens = [];
+	const flush = () => {
+		if (currentTokens.length > 0) {
+			rawGroups.push(currentTokens.join(" "));
+			currentTokens = [];
+		}
+		lastBucketInRun = null;
+		currentStateKey = null;
+	};
+	for (const { classToken, bucket: tokenBucket } of classified) {
+		if (lastBucketInRun === null) {
+			lastBucketInRun = tokenBucket;
+			currentStateKey = isVariantKeyedBucket(tokenBucket) ? variantGroupKey(tokenBucket, classToken) : null;
+			currentTokens.push(classToken);
+			continue;
+		}
+		if (isVariantKeyedBucket(tokenBucket)) {
+			const key = variantGroupKey(tokenBucket, classToken);
+			if (currentStateKey !== null && key !== currentStateKey) {
+				flush();
+				lastBucketInRun = tokenBucket;
+				currentStateKey = key;
+				currentTokens.push(classToken);
+				continue;
+			}
+		}
+		if (!bucketsCompatible(tokenBucket, lastBucketInRun)) {
+			flush();
+			lastBucketInRun = tokenBucket;
+			currentStateKey = isVariantKeyedBucket(tokenBucket) ? variantGroupKey(tokenBucket, classToken) : null;
+			currentTokens.push(classToken);
+			continue;
+		}
+		if (isVariantKeyedBucket(tokenBucket)) currentStateKey = variantGroupKey(tokenBucket, classToken);
+		else if (currentStateKey !== null) currentStateKey = null;
+		lastBucketInRun = tokenBucket;
+		currentTokens.push(classToken);
+	}
+	flush();
+	const withEaseMerged = mergeEaseTimingIntoFollowingAnimatedState(mergeSingletons(rawGroups));
+	return capGroups(withEaseMerged, Math.max(dynamicMaxGroups(tokens.length), withEaseMerged.length));
+}
+/**
+* One label per suggested group: a single bucket name, or `mixed:a+b` when that chunk
+* spans multiple Tailwind buckets (matches `codefast arrange group` stdout).
+*/ function summarizeGroupBucketLabels(groups) {
+	return groups.map((g) => {
+		const uniq = new Set(tokenizeClassString(g).map(classifyToken));
+		if (uniq.size !== 1) return `mixed:${[...uniq].sort(compareClassTokensCanonically).join("+")}`;
+		const onlyBucket = [...uniq][0];
+		if (onlyBucket === void 0) return `mixed:${[...uniq].sort(compareClassTokensCanonically).join("+")}`;
+		return onlyBucket;
+	});
+}
+//#endregion
+export { areCnTailwindPartitionsEquivalent, capGroups, mergeEaseTimingIntoFollowingAnimatedState, mergeSingletons, suggestCnGroups, summarizeGroupBucketLabels };

package/dist/lib/arrange/domain/imports.domain.mjs

@@ -0,0 +1,55 @@
+import { isDomainImportDeclaration, isDomainNamedImports, isDomainStringLiteral } from "./ast/ast-node.model.mjs";
+//#region src/lib/arrange/domain/imports.domain.ts
+function sourceFileImportsCn(sourceFile) {
+	for (const statement of sourceFile.statements) {
+		if (!isDomainImportDeclaration(statement) || !statement.importClause) continue;
+		const clause = statement.importClause;
+		if (clause.name?.text === "cn") return true;
+		if (clause.namedBindings && isDomainNamedImports(clause.namedBindings)) {
+			for (const importedBinding of clause.namedBindings.elements) if (importedBinding.name.text === "cn") return true;
+		}
+	}
+	return false;
+}
+/**
+* Resolve the module specifier used when injecting a `cn` import into a file.
+*/ function cnModuleSpecifierForFile(filePath, override) {
+	if (override) return override;
+	return "@codefast/tailwind-variants";
+}
+function findImportDeclarationFromModule(sourceFile, moduleSpecifier) {
+	for (const statement of sourceFile.statements) {
+		if (!isDomainImportDeclaration(statement)) continue;
+		const spec = statement.moduleSpecifier;
+		if (isDomainStringLiteral(spec) && spec.text === moduleSpecifier) return statement;
+	}
+}
+function ensureCnImport(sourceFile, cnImportOverride) {
+	const sourceText = sourceFile.text;
+	if (sourceFileImportsCn(sourceFile)) return sourceText;
+	const moduleSpecifier = cnModuleSpecifierForFile(sourceFile.fileName, cnImportOverride);
+	const decl = findImportDeclarationFromModule(sourceFile, moduleSpecifier);
+	if (decl?.importClause && !decl.importClause.isTypeOnly && decl.importClause.namedBindings && isDomainNamedImports(decl.importClause.namedBindings)) {
+		const elements = decl.importClause.namedBindings.elements;
+		if (elements.length > 0) {
+			const firstElement = elements[0];
+			if (firstElement === void 0) return sourceText;
+			const pos = firstElement.pos;
+			return `${sourceText.slice(0, pos)}cn, ${sourceText.slice(pos)}`;
+		}
+	}
+	const importLine = `import { cn } from "${moduleSpecifier}";`;
+	let firstImport = -1;
+	for (const statement of sourceFile.statements) if (isDomainImportDeclaration(statement)) {
+		firstImport = statement.pos;
+		break;
+	}
+	const useClient = /^["']use client["'];?\s*\r?\n/.exec(sourceText);
+	let insertAt;
+	if (useClient) insertAt = useClient[0].length;
+	else if (firstImport !== -1) insertAt = firstImport;
+	else insertAt = 0;
+	return `${sourceText.slice(0, insertAt)}${importLine}\n${sourceText.slice(insertAt)}`;
+}
+//#endregion
+export { cnModuleSpecifierForFile, ensureCnImport };

package/dist/lib/arrange/domain/source-text-formatters.formatter.mjs

@@ -0,0 +1,54 @@
+import { indentOfLineContaining } from "../../shared/source-code/domain/text-edit.model.mjs";
+//#region src/lib/arrange/domain/source-text-formatters.formatter.ts
+function escapeTsStringLiteralContent(group) {
+	return group.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
+}
+/**
+* Multiline fragment for use *inside* an existing `cn(...)` — replaces one
+* string argument with several, without producing `cn(cn(...))`.
+*/ function formatCnArguments(groups, options) {
+	const indent = options?.indent ?? "  ";
+	const commaAfterLast = options?.commaAfterLastGroup ?? options?.trailingClassName ?? false;
+	const lines = [];
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i];
+		if (group === void 0) throw new Error("invariant: formatCnArguments group missing");
+		const comma = i < groups.length - 1 || commaAfterLast ? "," : "";
+		lines.push(`${indent}"${escapeTsStringLiteralContent(group)}"${comma}`);
+	}
+	if (options?.trailingClassName) lines.push(`${indent}className,`);
+	return lines.join("\n");
+}
+function formatCnCall(groups, options) {
+	const lines = ["cn("];
+	const commaOnEachStringLine = groups.length > 1 || Boolean(options?.trailingClassName);
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i];
+		if (group === void 0) throw new Error("invariant: formatCnCall group missing");
+		const comma = commaOnEachStringLine ? "," : "";
+		lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
+	}
+	if (options?.trailingClassName) lines.push("  className,");
+	lines.push(")");
+	return lines.join("\n");
+}
+function formatArray(groups) {
+	const lines = ["["];
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i];
+		if (group === void 0) throw new Error("invariant: formatArray group missing");
+		const comma = i < groups.length - 1 || groups.length > 1 ? "," : "";
+		lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
+	}
+	lines.push("]");
+	return lines.join("\n");
+}
+function formatJsxCnAttributeValue(groups, source, valueNodeStart) {
+	const baseIndent = indentOfLineContaining(source, valueNodeStart);
+	return `{cn(\n${formatCnArguments(groups, {
+		indent: `${baseIndent}  `,
+		commaAfterLastGroup: groups.length > 1
+	})}\n${baseIndent})}`;
+}
+//#endregion
+export { escapeTsStringLiteralContent, formatArray, formatCnArguments, formatCnCall, formatJsxCnAttributeValue };

package/dist/lib/arrange/domain/tokenizer.util.mjs

@@ -0,0 +1,209 @@
+import { COMPATIBLE_BUCKET_SETS, RESPONSIVE_PREFIX, STATE_PREFIXES } from "./constants.domain.mjs";
+//#region src/lib/arrange/domain/tokenizer.util.ts
+/**
+* Bare-token classification is **total** (always returns a {@link Bucket}). The `Result` pattern
+* (`isOk` / `isErr`) belongs at arrange use-case / I/O boundaries, not on this hot path.
+*
+* Variant stems not covered by a single entry in STATE_PREFIXES (compound `has-*`,
+* numbered `nth-*`, media features, v4 `in-[…]`, child selectors `*` / `**`, …).
+* When these are missed, `isStateToken` is false and the variant is stripped — the
+* utility is then bucketed as if it were unconditional, which breaks preview grouping.
+*/ function isCompoundOrMediaVariantPrefix(prefix) {
+	if (prefix === "*" || prefix === "**") return true;
+	if (prefix === "inert") return true;
+	if (prefix.startsWith("has-")) return true;
+	if (prefix.startsWith("in-[")) return true;
+	if (/^nth(?:-last)?(?:-of-type)?(?:-\d+|-\[)/.test(prefix) || /^nth-of-type-\d+$/.test(prefix) || /^nth-last-of-type-\d+$/.test(prefix)) return true;
+	if (/^(?:user-valid|user-invalid|contrast-more|contrast-less|forced-colors|inverted-colors)$/.test(prefix)) return true;
+	if (/^(?:any-)?pointer-(?:fine|coarse|none)$/.test(prefix)) return true;
+	if (/^(?:portrait|landscape|noscript)$/.test(prefix)) return true;
+	return false;
+}
+function tokenizeClassString(classString) {
+	return classString.trim().split(/\s+/).filter(Boolean);
+}
+/**
+* Index of the first `:` that separates a Tailwind variant segment from the rest.
+* Colons inside `[...]` (at positive bracket depth) are ignored so selectors like
+* `[&_a:hover]:text-red-500` split as `[&_a:hover]:` + `text-red-500`.
+*/ function indexOfFirstVariantColon(text) {
+	let depth = 0;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		if (ch === "[") depth++;
+		else if (ch === "]") depth = Math.max(0, depth - 1);
+		else if (ch === ":" && depth === 0) return i;
+	}
+	return -1;
+}
+function stripVariants(token) {
+	let withoutVariants = token;
+	const MAX_PASSES = 12;
+	for (let i = 0; i < MAX_PASSES; i++) {
+		const colonIdx = indexOfFirstVariantColon(withoutVariants);
+		if (colonIdx === -1) break;
+		withoutVariants = withoutVariants.slice(colonIdx + 1);
+	}
+	return withoutVariants;
+}
+/** Outermost variant segment: first `:` at bracket depth 0 → text before it. */ function firstLeadingVariantPrefix(token) {
+	const colonIdx = indexOfFirstVariantColon(token);
+	if (colonIdx === -1) return;
+	return token.slice(0, colonIdx);
+}
+function isSelectorVariantToken(token) {
+	const prefix = firstLeadingVariantPrefix(token);
+	if (prefix === void 0) return false;
+	if (prefix === "*" || prefix === "**") return true;
+	if (prefix.startsWith("has-")) return true;
+	if (prefix.startsWith("in-[")) return true;
+	if (prefix.startsWith("group-[")) return true;
+	if (prefix.startsWith("peer-[")) return true;
+	if (prefix.startsWith("not-[")) return true;
+	return false;
+}
+function isStateToken(token) {
+	const prefix = firstLeadingVariantPrefix(token);
+	if (prefix === void 0) return false;
+	if (RESPONSIVE_PREFIX.test(token)) return true;
+	if (STATE_PREFIXES.has(prefix)) return true;
+	if (prefix.startsWith("data-[")) return true;
+	if (prefix.startsWith("aria-[")) return true;
+	if (prefix.startsWith("supports-[")) return true;
+	if (prefix.startsWith("in-data-")) return true;
+	if (/^data-(?!\[)/.test(prefix)) return true;
+	if (/^aria-/.test(prefix)) return true;
+	if (/^(group|peer)-/.test(prefix)) return true;
+	if (/^not-/.test(prefix)) return true;
+	if (isCompoundOrMediaVariantPrefix(prefix)) return true;
+	if (prefix.startsWith("[") && prefix.endsWith("]")) return true;
+	return false;
+}
+/**
+* Secondary sort inside the **composite** bucket: opacity / blend / isolation →
+* 3D context → 3D transforms → 2D transforms → filters → will-change.
+*/ function compositeSecondaryOrder(bareUtility) {
+	const b = bareUtility;
+	if (/^opacity(?:-|$)/.test(b) || /^mix-blend-/.test(b) || /^isolation(?:-|$)/.test(b) || b === "isolate") return 0;
+	if (b === "transform-3d" || /^perspective(?:-|$)/.test(b)) return 10;
+	if (/^rotate-[xyz](?:-|$)/.test(b) || /^translate-z(?:-|$)/.test(b) || /^scale-z(?:-|$)/.test(b)) return 20;
+	if (/^translate(?:-|$)/.test(b) || /^scale(?:-|$)/.test(b) || /^rotate(?:-|$)/.test(b) || /^skew(?:-|$)/.test(b)) return 30;
+	if (/^transform(?:-(?:gpu|cpu|none))?$/.test(b)) return 35;
+	if (/^blur(?:-|$)/.test(b) || /^backdrop-/.test(b) || /^filter(?:-|$)/.test(b) || /^brightness-/.test(b) || /^contrast-/.test(b) || /^grayscale(?:-|$)/.test(b) || /^hue-rotate-/.test(b) || /^invert(?:-|$)/.test(b) || /^saturate-/.test(b) || /^sepia(?:-|$)/.test(b)) return 40;
+	if (/^will-change/.test(b)) return 50;
+	return 99;
+}
+/** Classify a **bare** utility (no `hover:` / `md:` / … prefixes). */ function classifyBareUtility(bareUtility) {
+	const b = bareUtility;
+	if (/^@container(?:\/[a-z][a-z0-9-]*)?$/i.test(b)) return "existence";
+	if (/^(?:hidden|contents|sr-only|not-sr-only|list-item|flow-root)$/.test(b) || /^(?:block|inline-block|inline)$/.test(b)) return "existence";
+	if (/^table(?:$|-)/.test(b)) return "existence";
+	if (/^contain-/.test(b)) return "existence";
+	if (/^(?:group|peer)(?:\/[a-z][a-z0-9-]*)?$/.test(b)) return "existence";
+	if (/^(?:static|relative|absolute|fixed|sticky)$/.test(b)) return "position";
+	if (/^-?(?:inset|top|right|bottom|left|start|end)(?:-|\/|$)/.test(b) || /^-?(?:inset-x|inset-y|inset-s|inset-e)-/.test(b)) return "position";
+	if (/^-?z-/.test(b) || b === "z-auto") return "position";
+	if (/^(?:flex|inline-flex|grid|inline-grid|subgrid|masonry)(?:$|-)/.test(b) || /^(?:items|justify|justify-items|justify-self|content|self|place|place-content|place-items|place-self)-/.test(b) || /^-?(?:gap|space-[xy]|col-|row-|grid-|auto-cols|auto-rows|order-|order$)/.test(b) || /^-?(?:auto-flow|grid-flow)-/.test(b) || /^(?:columns-|break-after|break-before|break-inside)-/.test(b) || /^(?:float|clear)-/.test(b) || /^(?:wrap-|flex-wrap|flex-nowrap|flex-row|flex-col|flex-auto|flex-initial|flex-none|flex-1|flex-\[)/.test(b) || /^container$/.test(b)) return "layout";
+	if (/^-?(?:w|h|min-w|max-w|min-h|max-h|size|aspect|shrink|grow|basis)-/.test(b) || /^(?:shrink|grow)(?:$|-)/.test(b) || /^-?overflow-/.test(b) || /^-?object-/.test(b)) return "sizing";
+	if (/^-?(?:p|px|py|pt|pb|pl|pr|ps|pe|m|mx|my|mt|mb|ml|mr|ms|me)-/.test(b)) return "spacing";
+	if (/^-?(?:rounded|border|ring|divide|inset-ring)(?:-|\/|$)/.test(b) || /^(?:rounded|border|ring|divide|inset-ring)$/.test(b) || /^ring-offset-/.test(b)) return "shape";
+	if (/^-?bg-/.test(b) || /^(?:from|via|to)(?:-|\/|$)/.test(b) || /^bg-(?:linear|radial|conic)-/.test(b) || /^-?mask-/.test(b) || /^-?(?:fill|stroke)-/.test(b)) return "background";
+	if (/^-?(?:shadow|inset-shadow|drop-shadow|text-shadow)(?:-|\/|$)/.test(b) || /^(?:shadow|inset-shadow)$/.test(b) || /^-?outline(?:-|\/|$)/.test(b) || /^outline$/.test(b)) return "shadow";
+	if (/^-?(?:font|leading|tracking|list|indent|align|decoration|underline-offset|text-wrap|text-balance|text-pretty)-/.test(b) || /^-?(?:text-(?!shadow))/.test(b) || /^-?(?:whitespace|break|line-clamp|hyphens)-/.test(b) || /^(?:antialiased|subpixel-antialiased|italic|not-italic|overline|line-through|underline|no-underline|uppercase|lowercase|capitalize|normal-case|truncate|text-wrap|text-balance|text-pretty)$/.test(b) || /^text-wrap-/.test(b) || /^tabular-nums$|^slashed-zero$|^lining-nums$|^oldstyle-nums$|^proportional-nums$/.test(b)) return "typography";
+	if (/^opacity(?:-|$)/.test(b) || /^mix-blend-/.test(b) || /^isolation(?:-|$)/.test(b) || b === "isolate" || /^transform(?:-(?:gpu|cpu|none))?$/.test(b) || /^-?(?:translate|scale|rotate|skew)-/.test(b) || /^perspective(?:-|$)/.test(b) || b === "transform-3d" || /^blur(?:-|$)/.test(b) || /^backdrop-/.test(b) || /^filter(?:-|$)/.test(b) || /^brightness-/.test(b) || /^contrast-/.test(b) || /^grayscale(?:-|$)/.test(b) || /^hue-rotate-/.test(b) || /^invert(?:-|$)/.test(b) || /^saturate-/.test(b) || /^sepia(?:-|$)/.test(b) || /^will-change/.test(b)) return "composite";
+	if (/^(?:transition|duration|ease|delay|animate)(?:-|$)/.test(b) || /^ease-/.test(b)) return "motion";
+	if (/^(?:cursor|pointer-events|select|touch|scroll|scroll-m|scroll-p|overscroll|snap|resize|field-sizing|appearance|scheme|color-scheme|accent|caret)(?:-|$)/.test(b) || /^(?:cursor|select|resize)$/.test(b) || /^scroll-behavior/.test(b) || /^scroll-snap/.test(b) || /^touch-action/.test(b) || b === "inert") return "behavior";
+	return "other";
+}
+/**
+* Arbitrary **parent** selectors (`[&…]`, `[&>a]:…`, slot forms with `&` inside the bracket)
+* scope utilities to descendants — bucket as `selector` so they chunk apart from base layout/typography
+* and are labeled distinctly from interactive `state` variants (`hover:`, `data-[…]:`, …).
+* Pure arbitrary **properties** (`[--x]:`, `[color:red]`) have no `&` in the leading `[…]` segment.
+*/ function isArbitraryParentSelectorStateToken(token) {
+	if (/^\[&/.test(token)) return true;
+	if (!token.startsWith("[")) return false;
+	const colonIdx = indexOfFirstVariantColon(token);
+	if (colonIdx === -1 || colonIdx === 0 || token[colonIdx - 1] !== "]") return false;
+	return token.slice(0, colonIdx).includes("&");
+}
+function classifyToken(token) {
+	if (isArbitraryParentSelectorStateToken(token)) return "selector";
+	if (isSelectorVariantToken(token)) return "selector";
+	if (/^@container(?:\/[a-z][a-z0-9-]*)?$/i.test(token)) return "existence";
+	if (token.startsWith("[")) {
+		const splitIdx = indexOfFirstVariantColon(token);
+		if (splitIdx === -1) return "arbitrary";
+		if (splitIdx === 0 || token[splitIdx - 1] !== "]") return "arbitrary";
+	}
+	if (firstLeadingVariantPrefix(token) === "starting") return "starting";
+	if (isStateToken(token)) return "state";
+	return classifyBareUtility(stripVariants(token));
+}
+/**
+* Stable key for `data-[…]` variants so unrelated selectors stay split, while
+* **branching on the full bracket** (e.g. `data-[vaul-drawer-direction=bottom]`
+* vs `=left`) keeps direction-specific utilities in separate state groups.
+*/ function dataAttributeStem(token) {
+	const match = token.match(/^data-\[([^\]]*)\]/);
+	return match ? `data-[${match[1]}]` : "data";
+}
+/** Same idea as {@link dataAttributeStem} for `aria-[…]:` variants. */ function ariaAttributeStem(token) {
+	const match = token.match(/^aria-\[([^\]]*)\]/);
+	return match ? `aria-[${match[1]}]` : "aria";
+}
+/** `in-data-[…]:` — normalize on the full bracket expression like {@link dataAttributeStem}. */ function inDataAttributeStem(token) {
+	const match = token.match(/^in-data-\[([^\]]*)\]/);
+	return match ? `in-data-[${match[1]}]` : "in-data";
+}
+/**
+* Stable key for splitting adjacent `state` / `starting` tokens in {@link suggestCnGroups}
+* (`selector` uses {@link selectorKey}).
+* Uses the **full variant stack** (every `:` segment outside `[…]`), not only the
+* outermost prefix, so `@md/foo:[&>*]:w-auto` and `@md/foo:has-[…]:mt-px` stay in
+* separate groups while `hover:opacity` still keys as `hover` + `opacity`…
+*
+* `data-[…]` / `aria-[…]` normalize the first segment via {@link dataAttributeStem} /
+* {@link ariaAttributeStem} (full token required for bracket capture).
+*/ function stateKey(token) {
+	const layers = [];
+	let rest = token;
+	while (rest.length > 0) {
+		const colonIdx = indexOfFirstVariantColon(rest);
+		if (colonIdx === -1) break;
+		layers.push(rest.slice(0, colonIdx));
+		rest = rest.slice(colonIdx + 1);
+	}
+	if (layers.length === 0) return token;
+	const firstLayer = layers[0];
+	if (firstLayer === void 0) return token;
+	if (firstLayer.startsWith("data-[")) layers[0] = dataAttributeStem(token);
+	else if (firstLayer.startsWith("aria-[")) layers[0] = ariaAttributeStem(token);
+	else if (firstLayer.startsWith("in-data-[")) layers[0] = inDataAttributeStem(token);
+	return layers.join("");
+}
+const SELECTOR_KEY_SEP = "";
+/**
+* Variant key for {@link Bucket} `"selector"` tokens in {@link suggestCnGroups}.
+* Reuses {@link stateKey} layer splitting, then normalizes common shadcn/Radix SVG patterns so
+* `[&_svg]:…` and `[&_svg:not([class*='size-'])]:…` stay in one chunk.
+*/ function selectorKey(token) {
+	return stateKey(token).split(SELECTOR_KEY_SEP).map(normalizeSelectorVariantLayer).join(SELECTOR_KEY_SEP);
+}
+function normalizeSelectorVariantLayer(layer) {
+	if (layer === "[&_svg:not([class*='size-'])]") return "[&_svg]";
+	return layer;
+}
+function bucketsCompatible(a, b) {
+	if (a === b) return true;
+	return COMPATIBLE_BUCKET_SETS.some((bucketSet) => bucketSet.has(a) && bucketSet.has(b));
+}
+/** Like {@link bucketsCompatible}, but never merge two distinct state / starting / selector variant blobs. */ function bucketsMergeCompatible(a, b) {
+	if (a === "state" && b === "state") return false;
+	if (a === "starting" && b === "starting") return false;
+	if (a === "selector" && b === "selector") return false;
+	if (a === "arbitrary" || b === "arbitrary") return false;
+	return bucketsCompatible(a, b);
+}
+//#endregion
+export { bucketsCompatible, bucketsMergeCompatible, classifyBareUtility, classifyToken, compositeSecondaryOrder, indexOfFirstVariantColon, isArbitraryParentSelectorStateToken, selectorKey, stateKey, stripVariants, tokenizeClassString };