@codefast/cli 1.0.0-canary.6 → 1.0.0-canary.7

package/dist/arrange/domain/grouping.mjs

@@ -1,338 +0,0 @@
-import { BUCKET_ORDER } from "./constants.mjs";
-import { stripVariants, tokenizeClassString } from "./tailwind-token.mjs";
-import { bucketsCompatible, bucketsMergeCompatible, classifyToken, compositeSecondaryOrder, selectorKey, stateKey } from "./token-classifier.mjs";
-//#region src/arrange/domain/grouping.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.
-*
-* @since 0.3.16-canary.0
-*/
-function areCnTailwindPartitionsEquivalent(staticLiteralTexts, suggestedGroups) {
-	const partitionSignatures = (chunks) => chunks.map((chunk) => {
-		const classTokens = tokenizeClassString(chunk);
-		return classTokens.length === 0 ? "" : [...classTokens].toSorted(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) => stripVariants(classToken).startsWith("animate"))) 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" && stripVariants(classToken).startsWith("ease-"));
-}
-/**
-* @since 0.3.16-canary.0
-*/
-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).
-*
-* @since 0.3.16-canary.0
-*/
-function summarizeGroupBucketLabels(groups) {
-	return groups.map((g) => {
-		const uniq = new Set(tokenizeClassString(g).map(classifyToken));
-		if (uniq.size !== 1) return `mixed:${[...uniq].toSorted(compareClassTokensCanonically).join("+")}`;
-		const onlyBucket = [...uniq][0];
-		if (onlyBucket === void 0) return `mixed:${[...uniq].toSorted(compareClassTokensCanonically).join("+")}`;
-		return onlyBucket;
-	});
-}
-//#endregion
-export { areCnTailwindPartitionsEquivalent, suggestCnGroups, summarizeGroupBucketLabels };

package/dist/arrange/domain/imports.mjs

@@ -1,107 +0,0 @@
-import { forEachDomainChild, isDomainIdentifier, isDomainImportDeclaration, isDomainNamedImports, isDomainStringLiteral } from "./ast/ast-node.mjs";
-import { endAfterOptionalCommaFollowingInSource } from "../../core/source-text-edit.mjs";
-//#region src/arrange/domain/imports.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 cnIsUsedInBody(node) {
-	if (isDomainIdentifier(node) && node.text === "cn") return true;
-	let found = false;
-	forEachDomainChild(node, (child) => {
-		if (!found) found = cnIsUsedInBody(child);
-	});
-	return found;
-}
-function removeCnSpecifier(sourceText, specifier, allSpecifiers) {
-	const idx = allSpecifiers.indexOf(specifier);
-	if (idx === 0) {
-		const next = allSpecifiers[1];
-		if (!next) return sourceText;
-		return sourceText.slice(0, specifier.pos) + sourceText.slice(next.pos);
-	}
-	const prev = allSpecifiers[idx - 1];
-	if (!prev) return sourceText;
-	const endWithTrailingComma = endAfterOptionalCommaFollowingInSource(sourceText, specifier.end);
-	return sourceText.slice(0, prev.end) + sourceText.slice(endWithTrailingComma);
-}
-/**
-* After simplify rewrites, drop the `cn` import specifier when `cn` is no
-* longer referenced anywhere outside the import declarations.
-*
-* @since 0.3.16-canary.0
-*/
-function dropCnImportIfUnused(sourceFile) {
-	const sourceText = sourceFile.text;
-	for (const stmt of sourceFile.statements) {
-		if (isDomainImportDeclaration(stmt)) continue;
-		if (cnIsUsedInBody(stmt)) return sourceText;
-	}
-	for (const stmt of sourceFile.statements) {
-		if (!isDomainImportDeclaration(stmt) || !stmt.importClause) continue;
-		const clause = stmt.importClause;
-		if (!clause.namedBindings || !isDomainNamedImports(clause.namedBindings)) continue;
-		const elements = clause.namedBindings.elements;
-		const cnSpecifier = elements.find((el) => el.name.text === "cn");
-		if (!cnSpecifier) continue;
-		if (elements.length === 1) {
-			const lineEnd = sourceText.indexOf("\n", stmt.end);
-			return sourceText.slice(0, stmt.pos) + (lineEnd !== -1 ? sourceText.slice(lineEnd + 1) : sourceText.slice(stmt.end));
-		}
-		return removeCnSpecifier(sourceText, cnSpecifier, elements);
-	}
-	return sourceText;
-}
-/**
-* @since 0.3.16-canary.0
-*/
-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 { dropCnImportIfUnused, ensureCnImport };

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

@@ -1,88 +0,0 @@
-import { indentOfLineContaining } from "../../core/source-text-edit.mjs";
-//#region src/arrange/domain/source-text-formatters.ts
-/**
-* @since 0.3.16-canary.0
-*/
-function escapeTsStringLiteralContent(group) {
-	return group.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
-}
-/** Trailing comma on multiline Tailwind group lists (matches prior `cn` / `tv` array style). */
-function commaAfterTailwindGroupLine(groupIndex, groupCount) {
-	return groupIndex < groupCount - 1 || groupCount > 1 ? "," : "";
-}
-/**
-* 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");
-}
-/**
-* @since 0.3.16-canary.0
-*/
-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");
-}
-/**
-* @since 0.3.16-canary.0
-*/
-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 = commaAfterTailwindGroupLine(i, groups.length);
-		lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
-	}
-	lines.push("]");
-	return lines.join("\n");
-}
-/**
-* Multiple string literals as sequential lines for insertion **inside** an existing array
-* (e.g. `tv({ base: [ … ] })` — avoids `[[ "a", "b" ]]` when replacing one long string).
-*
-* @since 0.3.16-canary.0
-*/
-function formatArrayElementsAsSiblingLines(groups, continuationPrefix) {
-	const segments = [];
-	for (let i = 0; i < groups.length; i++) {
-		const group = groups[i];
-		if (group === void 0) throw new Error("invariant: formatArrayElementsAsSiblingLines group missing");
-		const comma = commaAfterTailwindGroupLine(i, groups.length);
-		const segment = `"${escapeTsStringLiteralContent(group)}"${comma}`;
-		segments.push(i === 0 ? segment : `\n${continuationPrefix}${segment}`);
-	}
-	return segments.join("");
-}
-/**
-* @since 0.3.16-canary.0
-*/
-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, formatArrayElementsAsSiblingLines, formatCnCall, formatJsxCnAttributeValue };

package/dist/arrange/domain/tailwind-token.mjs

@@ -1,40 +0,0 @@
-import "./constants.mjs";
-//#region src/arrange/domain/tailwind-token.ts
-/**
-* @since 0.3.16-canary.0
-*/
-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`.
-*
-* @since 0.3.16-canary.0
-*/
-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;
-}
-/**
-* @since 0.3.16-canary.0
-*/
-function stripVariants(token) {
-	let withoutVariants = token;
-	const maxStripVariantPasses = 12;
-	for (let i = 0; i < maxStripVariantPasses; i++) {
-		const colonIdx = indexOfFirstVariantColon(withoutVariants);
-		if (colonIdx === -1) break;
-		withoutVariants = withoutVariants.slice(colonIdx + 1);
-	}
-	return withoutVariants;
-}
-//#endregion
-export { indexOfFirstVariantColon, stripVariants, tokenizeClassString };