@codefast/cli 0.9.0 → 0.11.0

package/dist/arrange/domain/ast/collectors-tv.d.ts

@@ -0,0 +1,34 @@
+import type { DomainCallExpression, DomainObjectLiteralExpression, DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+import type { StringNode, TailwindClassLiteral } from "#/arrange/domain/types";
+type StringNodeVisitor = (classLiteral: TailwindClassLiteral, sourceFile: DomainSourceFile, cnCall?: DomainCallExpression) => void;
+/**
+ * Visits every class literal reachable inside a `tv({ ... })` object, including `cn()` arguments.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function traverseTvObject(sourceFile: DomainSourceFile, obj: DomainObjectLiteralExpression, visitor: StringNodeVisitor, depth?: number, knownBindings?: Set<string>): void;
+/**
+ * Collects the `cn()` calls nested inside a `tv({ ... })` object.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function collectCnCallsInsideTv(sourceFile: DomainSourceFile, obj: DomainObjectLiteralExpression, knownBindings: Set<string>, depth?: number): Array<DomainCallExpression>;
+/**
+ * Collects every `cn()` call nested inside any `tv()` call in a source file.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function listAllCnCallsInsideTvInSourceFile(sourceFile: DomainSourceFile, knownBindings: Set<string>): Array<DomainCallExpression>;
+/**
+ * Joins a slot's literals into one space-separated class string.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function slotClassString(stringNode: StringNode): string;
+/**
+ * Collects every groupable `cn()` / `tv()` string slot in a source file.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function collectGroupableStringNodes(sourceFile: DomainSourceFile): Array<StringNode>;
+export {};

package/dist/arrange/domain/ast/helpers.d.ts

@@ -0,0 +1,36 @@
+import type { DomainAstNode, DomainCallExpression, DomainPropertyAssignment, DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+import { applyEditsDescending } from "#/core/source-text-edit";
+/**
+ * Builds a set of local binding names that are imported from a known cn/tv
+ * module in `sourceFile`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function buildKnownCnTvBindings(sourceFile: DomainSourceFile): Set<string>;
+/**
+ * Returns true when `expr` is an identifier whose name matches `name` AND
+ * that name is listed in `knownBindings` from a recognized import.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isCnOrTvIdentifier(expr: DomainAstNode, name: "cn" | "tv", knownBindings?: Set<string>): boolean;
+/**
+ * Resolves a property assignment's name text, or `undefined` for computed names.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function propertyAssignmentNameText(prop: DomainPropertyAssignment): string | undefined;
+/**
+ * Resolves the one-based line number a node starts on.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function lineOf(sourceFile: DomainSourceFile, node: DomainAstNode): number;
+export { applyEditsDescending };
+/**
+ * Replace `cn(...)` nested in `tv({...})` with a plain string (one arg) or a string
+ * array (multiple args). Returns undefined when there are zero arguments.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function unwrapCnInsideTvCallReplacement(call: DomainCallExpression, sourceText: string): string | undefined;

package/dist/arrange/domain/ast/helpers.js

@@ -12,6 +12,7 @@ const KNOWN_CN_TV_MODULES = new Set([
     // from "tailwind-variants"; new code should prefer "@codefast/tailwind-variants".
     "tailwind-variants",
     "#lib/utils",
+    "#/lib/utils",
     "~/lib/utils",
     "@/lib/utils",
 ]);

package/dist/arrange/domain/ast/simplify-targets.d.ts

@@ -0,0 +1,22 @@
+import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+/**
+ * A planned text replacement produced by the simplify pass.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type PlannedSimplifyEdit = {
+    start: number;
+    end: number;
+    replacement: string;
+    label: string;
+};
+/**
+ * Collects all simplify edits for a source file:
+ * - Arrays of pure string literals inside tv() slots → flat string
+ * - cn() calls whose every argument is a static string literal → flat string (unwrap cn)
+ * - cn() calls with mixed static + dynamic args → merge adjacent statics into one string
+ * - JSX `className={cn(...all-static...)}` → `className="flat string"`
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function collectSimplifyTargets(sourceFile: DomainSourceFile): Array<PlannedSimplifyEdit>;

package/dist/arrange/domain/ast/simplify-targets.js

@@ -15,47 +15,42 @@ function joinLiterals(args) {
 function isAllStaticLiterals(args) {
     return args.length > 0 && args.every(isDomainTailwindClassLiteral);
 }
-// ---------------------------------------------------------------------------
-// Mixed cn() merge: ALL static args → one string first, dynamic args follow
-// ---------------------------------------------------------------------------
 /**
- * For a cn() call that has both static and dynamic args:
- * - Merge ALL static string literals (regardless of position) into one string.
- * - Place the merged string first.
- * - Append all dynamic args in their original relative order.
+ * Builds a mixed cn() replacement that coalesces each run of adjacent static literals into one string.
  *
- * Returns `null` when nothing changes (0 statics, or already 1 static at arg[0]).
+ * @remarks Argument order is preserved so tailwind-merge precedence is unchanged — a later cn()
+ * argument still overrides an earlier one. Returns `null` when no run of two-or-more adjacent statics
+ * exists, since reordering a lone static across a dynamic argument would change what renders.
  */
 function buildMixedCnReplacement(call, sourceText) {
     const args = [...call.arguments];
     if (args.length === 0) {
         return null;
     }
-    const staticTexts = [];
-    const dynamicSrcs = [];
+    const pieces = [];
     for (const arg of args) {
         if (isDomainTailwindClassLiteral(arg)) {
-            staticTexts.push(arg.text);
+            const last = pieces.at(-1);
+            if (last?.kind === "static") {
+                last.texts.push(arg.text);
+            }
+            else {
+                pieces.push({ kind: "static", texts: [arg.text] });
+            }
         }
         else {
-            dynamicSrcs.push(sourceText.slice(arg.pos, arg.end));
+            pieces.push({ kind: "dynamic", src: sourceText.slice(arg.pos, arg.end) });
         }
     }
-    if (staticTexts.length === 0) {
-        return null;
-    }
-    // Already simplest form: 1 static arg already at the front.
-    const firstArg = args[0];
-    if (staticTexts.length === 1 && firstArg !== undefined && isDomainTailwindClassLiteral(firstArg)) {
+    const merged = pieces.some((piece) => piece.kind === "static" && piece.texts.length > 1);
+    if (!merged) {
         return null;
     }
-    const flatStatic = staticTexts.join(" ").trim();
     const baseIndent = indentOfLineContaining(sourceText, call.pos);
     const argIndent = `${baseIndent}  `;
-    const lines = [
-        `${argIndent}"${escapeTsStringLiteralContent(flatStatic)}",`,
-        ...dynamicSrcs.map((src) => `${argIndent}${src},`),
-    ];
+    const lines = pieces.map((piece) => piece.kind === "static"
+        ? `${argIndent}"${escapeTsStringLiteralContent(piece.texts.join(" ").trim())}",`
+        : `${argIndent}${piece.src},`);
     return `cn(\n${lines.join("\n")}\n${baseIndent})`;
 }
 // ── tv() array collector ─────────────────────────────────────────────────────────────────────────────────────────────

package/dist/arrange/domain/ast/targets.d.ts

@@ -0,0 +1,20 @@
+import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+import type { GroupTarget, PlannedGroupEdit } from "#/arrange/domain/types";
+/**
+ * Resolves the source position where a group target's replacement begins.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function targetReplaceStart(target: GroupTarget): number;
+/**
+ * Collects a file's group targets — `cn()` / `tv()` slots, plus long JSX `className` literals in `.tsx`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function collectGroupTargets(sourceFile: DomainSourceFile, filePath: string): Array<GroupTarget>;
+/**
+ * Plans the grouped replacement for one target, or `undefined` when regrouping would change nothing.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function planGroupEditForTarget(target: GroupTarget, textAfterUnwrap: string, withClassName: boolean): PlannedGroupEdit | undefined;

package/dist/arrange/domain/ast/translator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Anti-corruption layer: maps the oxc-parser ESTree AST to the arrange domain AST.
+ * This is the only place that parses TypeScript source for arrange AST translation.
+ */
+import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+/**
+ * The translator mapping the `oxc-parser` ESTree AST to the arrange domain AST.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare class TypeScriptAstTranslator {
+    translateSourceFile(filePath: string, sourceText: string): DomainSourceFile;
+    /**
+     * Translates any node the typed cases do not cover, recursing into own child nodes and arrays of
+     * nodes in source-declaration order and skipping primitives and records that carry no `type`.
+     *
+     * @remarks Children are walked inline rather than through a generator — the `yield` per child is
+     * several times slower than a plain loop on this hot path, and this fallback runs for most nodes.
+     */
+    private translateUnknown;
+    private stringLiteralText;
+    private noSubstitutionTemplateText;
+    private mapBinaryOperator;
+    private translateImportDeclaration;
+    private buildImportClause;
+    private buildNamespaceImport;
+    private buildNamedImports;
+    private buildImportSpecifier;
+    private translateIdentifier;
+    private translateNode;
+    private parseDomainSourceFile;
+}

package/dist/arrange/{typescript-ast-translator.js → domain/ast/translator.js}

@@ -20,11 +20,21 @@ export class TypeScriptAstTranslator {
         return this.parseDomainSourceFile(filePath, sourceText);
     }
     /**
-     * Own child nodes in source-declaration order, mirroring `ts.forEachChild`:
-     * recurses into nested node objects and arrays of nodes, skipping primitives
-     * and plain records (e.g. a template element's `value`) that carry no `type`.
+     * Translates any node the typed cases do not cover, recursing into own child nodes and arrays of
+     * nodes in source-declaration order and skipping primitives and records that carry no `type`.
+     *
+     * @remarks Children are walked inline rather than through a generator — the `yield` per child is
+     * several times slower than a plain loop on this hot path, and this fallback runs for most nodes.
      */
-    *childNodesOf(node) {
+    translateUnknown(node, parent) {
+        const self = {
+            kind: DomainSyntaxKind.Unknown,
+            pos: node.start,
+            end: node.end,
+            parent,
+            children: [],
+        };
+        const childList = [];
         for (const key in node) {
             if (key === "type" || key === "start" || key === "end" || key === "range") {
                 continue;
@@ -33,29 +43,16 @@ export class TypeScriptAstTranslator {
             if (Array.isArray(value)) {
                 for (const element of value) {
                     if (isOxcNode(element)) {
-                        yield element;
+                        childList.push(this.translateNode(element, self));
                     }
                 }
-                continue;
             }
-            if (isOxcNode(value)) {
-                yield value;
+            else if (isOxcNode(value)) {
+                childList.push(this.translateNode(value, self));
             }
         }
-    }
-    translateUnknown(node, parent) {
-        const self = {
-            kind: DomainSyntaxKind.Unknown,
-            pos: node.start,
-            end: node.end,
-            parent,
-            children: [],
-        };
-        const childList = [];
-        for (const child of this.childNodesOf(node)) {
-            childList.push(this.translateNode(child, self));
-        }
-        return { ...self, children: childList };
+        self.children = childList;
+        return self;
     }
     stringLiteralText(node) {
         if (node.type === "Literal" && typeof node.value === "string") {

package/dist/arrange/domain/constants.d.ts

@@ -0,0 +1,111 @@
+import type { Bucket } from "#/arrange/domain/types";
+/**
+ * Analyze report: long literal threshold (token count).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const LONG_STRING_TOKEN_THRESHOLD = 18;
+/**
+ * Minimum token count for a string to be considered a candidate for grouping
+ * in the apply/preview pipeline. Intentionally much lower than
+ * {@link LONG_STRING_TOKEN_THRESHOLD} (analyze only).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const APPLY_MIN_TOKENS = 2;
+/**
+ * Minimum tokens a group must have to stand alone before singleton-merging.
+ * Set to 2 so single-token groups are not collapsed into unrelated buckets by the merger.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MIN_GROUP_TOKENS = 2;
+/**
+ * Dynamic max groups clamp: base bound.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_GROUPS_BASE = 4;
+/**
+ * Dynamic max groups clamp: upper cap.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_GROUPS_CAP = 24;
+/**
+ * Extra slots so a few state / aria groups do not force `capGroups` to merge
+ * unrelated buckets (e.g. `bg-border` + `outline-hidden`).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_GROUPS_HEADROOM = 2;
+/**
+ * Maximum findings printed per category in the analyze report.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_REPORT_LINES = 40;
+/**
+ * Maximum recursion depth when traversing `tv()` object literals.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_OBJECT_DEPTH = 12;
+/**
+ * Maximum depth when peeling conditional / parens / arrays inside `cn(...)` args.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_CLASS_EXPR_DEPTH = 12;
+/**
+ * Maximum variant-stripping passes in {@link stripVariants}.
+ * Real-world Tailwind stacks rarely exceed 4–5 segments (e.g. `@md/sidebar:group-hover:dark:focus-visible:`);
+ * 12 is a conservative safety cap that prevents runaway loops on malformed input.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_STRIP_VARIANT_PASSES = 12;
+/**
+ * Passed when optional `knownBindings` is missing — size 0 disables matching
+ * for `cn` / `tv` identifier resolution.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const EMPTY_CN_TV_BINDINGS: Set<string>;
+/**
+ * Bucket sort order — **render pipeline** (lower → earlier in `cn()` output).
+ *
+ * Matches README: Existence → Position → Layout → Sizing → Spacing → Shape → Background
+ * → Shadow → Typography → Composite → Motion → Starting → Behavior → State → Selector,
+ * then `other` and `arbitrary` as sort tails for unknown utilities and arbitrary properties.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const BUCKET_ORDER: Record<Bucket, number>;
+/**
+ * Compatible bucket **pairs** — two adjacent tokens whose buckets appear in the same
+ * `Set` may stay in one `cn()` string chunk. Compatibility is **not transitive**: there is
+ * no `{position, sizing}` pair, so `fixed inset-0` and `overflow-auto` become **separate**
+ * literals unless **layout** tokens sit between them in sorted order; then
+ * `position↔layout` and `layout↔sizing` each justify one hop and the whole “box in flow”
+ * (place + tracks + scrollport) stays in one chunk — co-located because they jointly define
+ * stacking and scroll behavior for the same surface.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const COMPATIBLE_BUCKET_SETS: ReadonlyArray<ReadonlySet<Bucket>>;
+/**
+ * Responsive / variant prefix — Tailwind v4 aware.
+ *
+ * v3: sm: md: … — v4: `@sm:`, `@min-[600px]:`, `@[480px]:`, named `@md/sidebar:`,
+ * viewport md/sidebar:, min-[100px]: / max-[100px]:, …
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const RESPONSIVE_PREFIX: RegExp;
+/**
+ * State variant stems — hoisted to module scope (not recreated per call).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const STATE_PREFIXES: ReadonlySet<string>;

package/dist/arrange/domain/grouping-service.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Rich domain: plan Tailwind class grouping / cn-in-tv unwrap for a single file.
+ * Pure: only DomainSourceFile, source strings, and options — no I/O.
+ */
+import type { DomainCallExpression, DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+import type { GroupFileResult, PlannedGroupEdit } from "#/arrange/domain/types";
+/**
+ * A planned replacement unwrapping one `cn()` call nested in `tv({ ... })`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type GroupFileUnwrapPlan = {
+    readonly start: number;
+    readonly end: number;
+    readonly replacement: string;
+    readonly call: DomainCallExpression;
+};
+type GroupFileUnwrapState = {
+    readonly cnInTvCalls: ReadonlyArray<DomainCallExpression>;
+    readonly unwrapReplacementByCall: ReadonlyMap<DomainCallExpression, string>;
+    readonly unwrapEdits: ReadonlyArray<GroupFileUnwrapPlan>;
+    readonly textAfterUnwrap: string;
+    readonly cnInTvNoReplacement: number;
+};
+/**
+ * The complete per-file plan of unwrap and grouping edits, plus the totals reported for them.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type GroupFileWorkPlan = {
+    readonly filePath: string;
+    readonly sourceText: string;
+    readonly textAfterUnwrap: string;
+    readonly domainSfForLineNumbers: DomainSourceFile;
+    readonly domainSfGrouped: DomainSourceFile;
+    readonly cnInTvCalls: ReadonlyArray<DomainCallExpression>;
+    readonly unwrapReplacementByCall: ReadonlyMap<DomainCallExpression, string>;
+    readonly unwrapEdits: ReadonlyArray<GroupFileUnwrapPlan>;
+    readonly plannedGroupEdits: ReadonlyArray<PlannedGroupEdit>;
+    readonly cnInTvNoReplacement: number;
+    readonly reportTotal: number;
+    readonly editSitesCount: number;
+};
+/**
+ * Builds the unwrap phase's state — cn-in-tv calls, their replacements, and the text after unwrapping.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function buildGroupFileUnwrapState(domainSfInitial: DomainSourceFile, sourceText: string): GroupFileUnwrapState;
+/**
+ * `domainSfGrouped` must be a parse of `unwrap.textAfterUnwrap` (same `text` as source).
+ * Returns `null` when there is no cn-in-tv and no grouping targets.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function tryBuildGroupFileWorkPlan(input: {
+    readonly filePath: string;
+    readonly sourceText: string;
+    readonly domainSfInitial: DomainSourceFile;
+    readonly domainSfGrouped: DomainSourceFile;
+    readonly withClassName: boolean;
+    readonly unwrap: GroupFileUnwrapState;
+}): GroupFileWorkPlan | null;
+/**
+ * Creates the empty per-file result for a dry run with nothing to edit.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function groupFileDryRunNoEdits(filePath: string): GroupFileResult;
+/**
+ * Derives the preview-mode per-file result from a work plan's report total.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function groupFilePreviewTotals(work: GroupFileWorkPlan): GroupFileResult;
+/**
+ * Applies a work plan's grouping edits to the unwrapped text and returns the merged file body.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function mergeGroupFileBodyText(work: GroupFileWorkPlan): string;
+/**
+ * Checks whether any planned edit rewrites a JSX `className` into a `cn()` call.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function groupFileEditsTouchJsxCn(work: GroupFileWorkPlan): boolean;
+/**
+ * Counts the edits a work plan writes in apply mode — unwraps plus grouping replacements.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function countPersistedGroupFileEdits(work: GroupFileWorkPlan): number;
+/**
+ * Checks whether a work plan has no edit sites and no skipped cn-in-tv calls to report.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function groupFileWorkHasNothingToReport(work: GroupFileWorkPlan): boolean;
+export {};

package/dist/arrange/domain/grouping.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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
+ */
+export declare function areCnTailwindPartitionsEquivalent(staticLiteralTexts: Array<string>, suggestedGroups: Array<string>): boolean;
+/**
+ * Partitions a class string into render-pipeline-ordered groups, one per suggested `cn()` argument.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function suggestCnGroups(classString: string): Array<string>;
+/**
+ * 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
+ */
+export declare function summarizeGroupBucketLabels(groups: Array<string>): Array<string>;

package/dist/arrange/domain/imports.d.ts

@@ -0,0 +1,14 @@
+import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+/**
+ * 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
+ */
+export declare function dropCnImportIfUnused(sourceFile: DomainSourceFile): string;
+/**
+ * Returns the source text with a `cn` import present, adding one when the file lacks it.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function ensureCnImport(sourceFile: DomainSourceFile, cnImportOverride?: string): string;

package/dist/arrange/domain/source-text-formatters.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Escapes backslashes and double quotes for embedding in a double-quoted TypeScript string literal.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function escapeTsStringLiteralContent(group: string): string;
+/**
+ * Formats grouped class strings as a multiline `cn(...)` call.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function formatCnCall(groups: Array<string>, options?: {
+    trailingClassName?: boolean;
+}): string;
+/**
+ * Formats grouped class strings as a multiline array literal.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function formatArray(groups: Array<string>): string;
+/**
+ * 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
+ */
+export declare function formatArrayElementsAsSiblingLines(groups: Array<string>, continuationPrefix: string): string;
+/**
+ * Formats grouped class strings as a JSX attribute value wrapping a multiline `cn(...)` call.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function formatJsxCnAttributeValue(groups: Array<string>, source: string, valueNodeStart: number): string;

package/dist/arrange/domain/tailwind-token.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Splits a class string into its whitespace-separated tokens.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function tokenizeClassString(classString: string): Array<string>;
+/**
+ * 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
+ */
+export declare function indexOfFirstVariantColon(text: string): number;
+/**
+ * Strips every variant prefix off a token, leaving the bare utility name.
+ *
+ * @remarks
+ * `"hover:dark:md:text-sm"` → `"text-sm"`, `"@min-[600px]:flex"` → `"flex"`,
+ * `"[&_a:hover]:text-red-500"` → `"text-red-500"`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function stripVariants(token: string): string;

package/dist/arrange/domain/token-classifier.d.ts

@@ -0,0 +1,47 @@
+import type { Bucket } from "#/arrange/domain/types";
+/**
+ * Secondary sort inside the **composite** bucket: opacity / blend / isolation →
+ * 3D context → 3D transforms → 2D transforms → filters → will-change.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function compositeSecondaryOrder(bareUtility: string): number;
+/**
+ * Classifies a Tailwind token into its render-pipeline bucket.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function classifyToken(token: string): Bucket;
+/**
+ * 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).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function stateKey(token: string): string;
+/**
+ * Variant key for {@link Bucket} `"selector"` tokens in {@link suggestCnGroups}.
+ * Reuses {@link stateKey} layer splitting, then normalizes common Radix SVG patterns so
+ * `[&_svg]:…` and `[&_svg:not([class*='size-'])]:…` stay in one chunk.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function selectorKey(token: string): string;
+/**
+ * Checks whether two buckets may share one group in a suggested partition.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function bucketsCompatible(a: Bucket, b: Bucket): boolean;
+/**
+ * Like {@link bucketsCompatible}, but never merge two distinct state / starting / selector variant blobs.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function bucketsMergeCompatible(a: Bucket, b: Bucket): boolean;