@codefast/cli 0.3.7-canary.0 → 0.3.13-canary.0

package/dist/engine-DRTdkc5u.mjs

@@ -0,0 +1,236 @@
+import { a as VALID_JS_EXTENSIONS, i as PACKAGE_JSON_EXPORT, n as DTS_EXTENSION } from "./constants-Bq5wdyLC.mjs";
+import { t as isDirentList } from "./dirent-list-BSDeRG5i.mjs";
+import { t as normalizePath } from "./path-normalizer-D4ceBO3l.mjs";
+import path from "node:path";
+//#region src/lib/mirror/application/engine.ts
+function resolvePackageScopedConfig(configMap, pkgMeta) {
+	if (!configMap) return void 0;
+	return configMap[pkgMeta.packageName];
+}
+async function scanDirectoryFiles(fs, dir, baseDir = dir) {
+	try {
+		const raw = await fs.readdir(dir, {
+			recursive: true,
+			withFileTypes: true
+		});
+		if (!isDirentList(raw)) return [];
+		return raw.filter((dirent) => dirent.isFile()).map((dirent) => {
+			const fullPath = path.join(dirent.parentPath, dirent.name);
+			return normalizePath(path.relative(baseDir, fullPath));
+		});
+	} catch (caughtError) {
+		if (caughtError && typeof caughtError === "object" && "code" in caughtError) {
+			if (caughtError.code === "ENOENT" || caughtError.code === "EACCES") return [];
+		}
+		throw caughtError;
+	}
+}
+async function isDirectoryCssOnly(fs, distDir, dirPath) {
+	try {
+		const raw = await fs.readdir(path.join(distDir, dirPath), { withFileTypes: true });
+		if (!isDirentList(raw)) return false;
+		if (raw.length === 0) return true;
+		return raw.every((dirent) => dirent.isFile() && dirent.name.endsWith(".css"));
+	} catch {
+		return false;
+	}
+}
+function groupFilesByModule(files) {
+	const modules = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		let ext;
+		let modulePath;
+		if (file.endsWith(".d.ts")) {
+			ext = DTS_EXTENSION;
+			modulePath = file.slice(0, -DTS_EXTENSION.length);
+		} else {
+			ext = path.extname(file);
+			if (!VALID_JS_EXTENSIONS.has(ext)) continue;
+			modulePath = file.slice(0, -ext.length);
+		}
+		if (!path.basename(modulePath)) continue;
+		let distModule = modules.get(modulePath);
+		if (!distModule) {
+			distModule = {
+				path: modulePath,
+				files: {
+					js: null,
+					cjs: null,
+					dts: null
+				}
+			};
+			modules.set(modulePath, distModule);
+		}
+		if (ext === ".js") distModule.files.js = file;
+		else if (ext === ".cjs") distModule.files.cjs = file;
+		else if (ext === ".d.ts") distModule.files.dts = file;
+	}
+	return modules;
+}
+function toExportPath(distPath) {
+	if (distPath === "index") return ".";
+	if (distPath.endsWith("/index")) return `./${distPath.slice(0, -6)}`;
+	return `./${distPath}`;
+}
+const GROUP_ORDER = {
+	components: 100,
+	hooks: 200,
+	primitives: 300,
+	core: 400,
+	loaders: 500,
+	utils: 600,
+	adapters: 700,
+	script: 750,
+	css: 900
+};
+function getExportGroup(exportPath, pathTransform) {
+	if (exportPath === ".") return [
+		".",
+		"",
+		0,
+		0
+	];
+	const cleanPath = exportPath.startsWith("./") ? exportPath.slice(2) : exportPath;
+	if (cleanPath.endsWith("/*")) {
+		const dirName = cleanPath.slice(0, -2);
+		return [
+			dirName,
+			"",
+			dirName === "css" ? 900 : 100,
+			0
+		];
+	}
+	const parts = cleanPath.split("/");
+	if (parts.length === 1) {
+		const name = parts[0];
+		if (name in GROUP_ORDER) return [
+			name,
+			"",
+			GROUP_ORDER[name] ?? 0,
+			0
+		];
+		if (pathTransform) return [
+			"components",
+			name,
+			100,
+			1
+		];
+		return [
+			"",
+			name,
+			800,
+			1
+		];
+	}
+	const group = parts[0] ?? "";
+	return [
+		group,
+		parts.slice(1).join("/"),
+		GROUP_ORDER[group] ?? 700,
+		1
+	];
+}
+function createPathTransform(config, pkgMeta) {
+	const pathConfig = resolvePackageScopedConfig(config?.pathTransformations, pkgMeta);
+	if (!pathConfig) return null;
+	const { removePrefix } = pathConfig;
+	if (!removePrefix) return null;
+	return (exportPath) => {
+		if (!exportPath.startsWith(removePrefix)) return exportPath;
+		const result = exportPath.slice(removePrefix.length);
+		if (result && result !== "." && !result.startsWith("./")) return `./${result}`;
+		return result;
+	};
+}
+function getSortTuple(exportPath, pathTransform) {
+	const [group, subpath, order, isIndex] = getExportGroup(exportPath, pathTransform);
+	return [
+		order,
+		group,
+		isIndex,
+		subpath
+	];
+}
+function compareTuples(left, right) {
+	if (left[0] !== right[0]) return left[0] - right[0];
+	if (left[1] !== right[1]) return left[1] < right[1] ? -1 : 1;
+	if (left[2] !== right[2]) return left[2] - right[2];
+	if (left[3] !== right[3]) return left[3] < right[3] ? -1 : 1;
+	return 0;
+}
+async function generateCssExports(fs, distDir, cssConfig) {
+	if (cssConfig === false) return {};
+	if (cssConfig === true) cssConfig = { enabled: true };
+	if (!cssConfig || cssConfig.enabled === false) return {};
+	const cssFiles = (await scanDirectoryFiles(fs, distDir)).filter((relativeDistPath) => relativeDistPath.endsWith(".css"));
+	if (!cssFiles.length) return {};
+	const cssExports = { ...cssConfig.customExports };
+	const cssByDir = /* @__PURE__ */ new Map();
+	const rootCss = [];
+	for (const file of cssFiles) {
+		const dirName = normalizePath(path.dirname(file));
+		if (dirName === ".") rootCss.push(file);
+		else {
+			const arr = cssByDir.get(dirName) || [];
+			arr.push(file);
+			cssByDir.set(dirName, arr);
+		}
+	}
+	for (const file of rootCss) {
+		const exportPath = `./${file}`;
+		if (!(exportPath in cssExports)) cssExports[exportPath] = `./dist/${file}`;
+	}
+	for (const [dirName, dirFiles] of cssByDir.entries()) if (await isDirectoryCssOnly(fs, distDir, dirName) && !cssConfig.forceExportFiles) {
+		const wildcardExport = `./${dirName}/*`;
+		if (!(wildcardExport in cssExports)) cssExports[wildcardExport] = `./dist/${dirName}/*`;
+	} else for (const file of dirFiles) {
+		const exportPath = `./${file}`;
+		if (!(exportPath in cssExports)) cssExports[exportPath] = `./dist/${file}`;
+	}
+	return cssExports;
+}
+/**
+* Compute `package.json#exports` from a built `dist/` tree. No logging; no writes.
+*/
+async function generateExports(fs, distDir, pathTransform, cssConfig, customExports) {
+	const files = await scanDirectoryFiles(fs, distDir);
+	if (!files.length) return {
+		exports: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		jsCount: 0,
+		cssCount: 0
+	};
+	const modules = groupFilesByModule(files);
+	const validModules = Array.from(modules.values()).filter((mod) => mod.files.js && mod.files.dts);
+	if (!validModules.length) return {
+		exports: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		jsCount: 0,
+		cssCount: 0
+	};
+	const exportsObj = {};
+	for (const distModuleEntry of validModules) {
+		let exportPath = toExportPath(distModuleEntry.path);
+		if (pathTransform) exportPath = pathTransform(exportPath);
+		const distPath = `./dist/${distModuleEntry.path}`;
+		const entry = { types: `${distPath}.d.ts` };
+		if (distModuleEntry.files.js) entry.import = `${distPath}.js`;
+		if (distModuleEntry.files.cjs) entry.require = `${distPath}.cjs`;
+		exportsObj[exportPath] = entry;
+	}
+	let sortedKeys = Object.keys(exportsObj).sort((pathA, pathB) => compareTuples(getSortTuple(pathA, pathTransform), getSortTuple(pathB, pathTransform)));
+	const sortedExports = {};
+	for (const exportKey of sortedKeys) sortedExports[exportKey] = exportsObj[exportKey];
+	const cssExports = await generateCssExports(fs, distDir, cssConfig ?? { enabled: true });
+	Object.assign(sortedExports, cssExports);
+	for (const [specifier, mappedPath] of Object.entries(customExports || {})) if (specifier !== "./package.json") sortedExports[specifier] = mappedPath;
+	sortedKeys = Object.keys(sortedExports).filter((exportKey) => exportKey !== PACKAGE_JSON_EXPORT).sort((pathA, pathB) => compareTuples(getSortTuple(pathA, pathTransform), getSortTuple(pathB, pathTransform)));
+	const finalExports = {};
+	for (const exportKey of sortedKeys) finalExports[exportKey] = sortedExports[exportKey];
+	finalExports[PACKAGE_JSON_EXPORT] = PACKAGE_JSON_EXPORT;
+	return {
+		exports: finalExports,
+		jsCount: Object.keys(exportsObj).length,
+		cssCount: Object.keys(cssExports).length
+	};
+}
+//#endregion
+export { generateExports as n, createPathTransform as t };

package/dist/errors-CFH4w6ic.mjs

@@ -0,0 +1,15 @@
+//#region src/lib/mirror/domain/errors.ts
+const MirrorErrorCode = {
+	FATAL: "FATAL",
+	PACKAGE_WRITE: "PACKAGE_WRITE"
+};
+var MirrorError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "MirrorError";
+		this.code = code;
+	}
+};
+//#endregion
+export { MirrorErrorCode as n, MirrorError as t };

package/dist/errors-CpU1ogfA.mjs

@@ -0,0 +1,19 @@
+//#region src/lib/arrange/domain/errors.ts
+/**
+* Structured errors for the arrange CLI library (throw from lib; handle exit in commands).
+*/
+const ArrangeErrorCode = {
+	TARGET_NOT_FOUND: "TARGET_NOT_FOUND",
+	INVALID_INPUT: "INVALID_INPUT",
+	INTERNAL: "INTERNAL"
+};
+var ArrangeError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "ArrangeError";
+		this.code = code;
+	}
+};
+//#endregion
+export { ArrangeErrorCode as n, ArrangeError as t };

package/dist/formatters-DGE8jJ53.mjs

@@ -0,0 +1,52 @@
+import { i as indentOfLineContaining } from "./ast-helpers-MDRYuIAk.mjs";
+//#region src/lib/arrange/presentation/formatters.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];
+		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];
+		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];
+		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 { formatJsxCnAttributeValue as a, formatCnCall as i, formatArray as n, formatCnArguments as r, escapeTsStringLiteralContent as t };

package/dist/group-file-ClW7XdD6.mjs

@@ -0,0 +1,113 @@
+import { l as unwrapCnInsideTvCallReplacement, n as applyEditsDescending, o as lineOf, r as buildKnownCnTvBindings } from "./ast-helpers-MDRYuIAk.mjs";
+import { a as listAllCnCallsInsideTvInSourceFile } from "./collectors-tv-D2PXZaRt.mjs";
+import { a as targetReplaceStart, i as planGroupEditForTarget, t as collectGroupTargets } from "./targets-pCTslnFh.mjs";
+import { n as ensureCnImport } from "./imports-DSVq1xhB.mjs";
+import ts from "typescript";
+//#region src/lib/arrange/application/group-file.ts
+function printGroupFilePreview(logger, args) {
+	const { out } = logger;
+	const { filePath, reportTotal, cnInTvNoReplacement, cnInTvCalls, unwrapReplacementByCall, sourceText, sf, unwrapEdits, plannedGroupEdits } = args;
+	let header = `\n── ${filePath} (${reportTotal} site(s)`;
+	if (cnInTvNoReplacement > 0) header += `; plus ${cnInTvNoReplacement} cn() inside tv left unchanged (0 args)`;
+	header += `) ──`;
+	out(header);
+	for (const call of cnInTvCalls) {
+		const replacement = unwrapReplacementByCall.get(call);
+		if (replacement === void 0) {
+			out(`  Line ${lineOf(sf, call)} [tv ⊃ cn]: cn(...) has no arguments — skipped`);
+			continue;
+		}
+		const start = call.getStart(sf);
+		const end = call.getEnd();
+		if (sourceText.slice(start, end) === replacement) continue;
+		out(`  Line ${lineOf(sf, call)} [tv ⊃ cn → string/array]:`);
+		out(`  ${replacement.split("\n").join("\n  ")}`);
+	}
+	if (unwrapEdits.length > 0 && plannedGroupEdits.length > 0) out("  ([cn] / [tv] / [JSX className] lines below reflect content after unwrap of cn inside tv.)");
+	for (const plan of plannedGroupEdits) {
+		out(`  Line ${lineOf(plan.lineSf, plan.reportNode)} [${plan.label}]:`);
+		out(`  ${plan.replacement.split("\n").join("\n  ")}`);
+		out(`  // Buckets: ${JSON.stringify(plan.bucketSummary)}`);
+	}
+}
+function applyGroupFileWrites(filePath, options, fs, logger, unwrapEdits, textAfterUnwrap, plannedGroupEdits, cnInTvNoReplacement) {
+	const groupEdits = plannedGroupEdits.map((plannedEdit) => ({
+		start: plannedEdit.start,
+		end: plannedEdit.end,
+		replacement: plannedEdit.replacement,
+		jsxCn: plannedEdit.jsxCn
+	}));
+	const touchedJsxCn = groupEdits.some((groupEdit) => groupEdit.jsxCn);
+	let newText = groupEdits.length > 0 ? applyEditsDescending(textAfterUnwrap, groupEdits) : textAfterUnwrap;
+	const changed = unwrapEdits.length + groupEdits.length;
+	if (changed > 0) {
+		if (touchedJsxCn) newText = ensureCnImport(newText, filePath, options.cnImport);
+		fs.writeFileSync(filePath, newText, "utf8");
+	}
+	return {
+		filePath,
+		totalFound: changed + cnInTvNoReplacement,
+		changed
+	};
+}
+function groupFile(filePath, options, fs, logger) {
+	const sourceText = fs.readFileSync(filePath, "utf8");
+	const sf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+	const cnInTvCalls = listAllCnCallsInsideTvInSourceFile(sf, buildKnownCnTvBindings(sf));
+	const unwrapPlans = cnInTvCalls.map((call) => {
+		const replacement = unwrapCnInsideTvCallReplacement(call, sourceText, sf);
+		if (replacement === void 0) return void 0;
+		return {
+			start: call.getStart(sf),
+			end: call.getEnd(),
+			replacement,
+			call
+		};
+	}).filter((planOrUndefined) => planOrUndefined !== void 0);
+	const unwrapReplacementByCall = new Map(unwrapPlans.map((unwrapPlan) => [unwrapPlan.call, unwrapPlan.replacement]));
+	const unwrapEdits = unwrapPlans.filter((unwrapPlan) => sourceText.slice(unwrapPlan.start, unwrapPlan.end) !== unwrapPlan.replacement);
+	const textAfterUnwrap = unwrapEdits.length > 0 ? applyEditsDescending(sourceText, unwrapEdits) : sourceText;
+	const groupTargets = collectGroupTargets(ts.createSourceFile(filePath, textAfterUnwrap, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS), filePath);
+	const cnInTvNoReplacement = cnInTvCalls.length - unwrapPlans.length;
+	const sortedTargets = [...groupTargets].sort((leftTarget, rightTarget) => targetReplaceStart(rightTarget) - targetReplaceStart(leftTarget));
+	const plannedGroupEdits = [];
+	for (const groupTarget of sortedTargets) {
+		const plan = planGroupEditForTarget(groupTarget, textAfterUnwrap, options.withClassName);
+		if (plan === void 0) continue;
+		if (textAfterUnwrap.slice(plan.start, plan.end) === plan.replacement) continue;
+		plannedGroupEdits.push(plan);
+	}
+	const editSitesCount = unwrapEdits.length + plannedGroupEdits.length;
+	const reportTotal = editSitesCount + cnInTvNoReplacement;
+	if (cnInTvCalls.length === 0 && groupTargets.length === 0) return {
+		filePath,
+		totalFound: 0,
+		changed: 0
+	};
+	if (!options.write) {
+		if (editSitesCount === 0 && cnInTvNoReplacement === 0) return {
+			filePath,
+			totalFound: 0,
+			changed: 0
+		};
+		printGroupFilePreview(logger, {
+			filePath,
+			reportTotal,
+			cnInTvNoReplacement,
+			cnInTvCalls,
+			unwrapReplacementByCall,
+			sourceText,
+			sf,
+			unwrapEdits,
+			plannedGroupEdits
+		});
+		return {
+			filePath,
+			totalFound: reportTotal,
+			changed: 0
+		};
+	}
+	return applyGroupFileWrites(filePath, options, fs, logger, unwrapEdits, textAfterUnwrap, plannedGroupEdits, cnInTvNoReplacement);
+}
+//#endregion
+export { groupFile as t };

package/dist/grouping-c1grpCQT.mjs

@@ -0,0 +1,235 @@
+import { n as BUCKET_ORDER } from "./constants-AtPhF-Ct.mjs";
+import { a as compositeSecondaryOrder, c as selectorKey, d as tokenizeClassString, i as classifyToken, l as stateKey, n as bucketsMergeCompatible, t as bucketsCompatible, u as stripVariants } from "./tokenizer-CeZx73Zu.mjs";
+//#region src/lib/arrange/domain/grouping.ts
+function isVariantKeyedBucket(bucket) {
+	return bucket === "selector" || bucket === "state" || bucket === "starting";
+}
+function variantGroupKey(bucket, classToken) {
+	return bucket === "selector" ? selectorKey(classToken) : stateKey(classToken);
+}
+/**
+* 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().join(" ");
+	}).filter((s) => s.length > 0).sort((a, b) => a.localeCompare(b));
+	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++) if (tokenizeClassString(result[i]).length < 2) {
+			if (result.length === 1) break;
+			const myBucket = dominantBucketOfGroup(result[i]);
+			const prevCompat = i > 0 && bucketsMergeCompatible(myBucket, dominantBucketOfGroup(result[i - 1]));
+			const nextCompat = i < result.length - 1 && bucketsMergeCompatible(myBucket, dominantBucketOfGroup(result[i + 1]));
+			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") result[i + 1] = result[i] + " " + result[i + 1];
+			else result[i - 1] = result[i - 1] + " " + result[i];
+			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 dominantLeft = dominantBucketOfGroup(result[i]);
+			const dominantRight = dominantBucketOfGroup(result[i + 1]);
+			if (!bucketsMergeCompatible(dominantLeft, dominantRight)) continue;
+			mergePairCandidates.push({
+				i,
+				size: lengths[i] + lengths[i + 1],
+				penalty: capMergePenalty(dominantLeft, dominantRight)
+			});
+		}
+		if (mergePairCandidates.length === 0) break;
+		let best = mergePairCandidates[0];
+		for (const candidate of mergePairCandidates) if (candidate.penalty < best.penalty || candidate.penalty === best.penalty && candidate.size < best.size) best = candidate;
+		const bestIdx = best.i;
+		result[bestIdx] = result[bestIdx] + " " + result[bestIdx + 1];
+		lengths[bestIdx] = lengths[bestIdx] + lengths[bestIdx + 1];
+		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++) {
+			if (!chunkIsOnlyEaseTimingMotion(result[i])) continue;
+			const easeStr = result[i];
+			let target = -1;
+			for (let j = i + 1; j < result.length; j++) {
+				if (dominantBucketOfGroup(result[j]) !== "state") continue;
+				if (!tokenizeClassString(result[j]).some((classToken) => /^animate/.test(stripVariants(classToken)))) continue;
+				target = j;
+				break;
+			}
+			if (target === -1) continue;
+			result[target] = `${easeStr} ${result[target]}`.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 [];
+	const classified = tokens.map((classToken, index) => ({
+		classToken,
+		bucket: classifyToken(classToken),
+		index
+	}));
+	classified.sort((left, right) => {
+		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;
+	});
+	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));
+		return uniq.size === 1 ? [...uniq][0] : `mixed:${[...uniq].sort().join("+")}`;
+	});
+}
+//#endregion
+export { suggestCnGroups as a, mergeSingletons as i, capGroups as n, summarizeGroupBucketLabels as o, mergeEaseTimingIntoFollowingAnimatedState as r, areCnTailwindPartitionsEquivalent as t };