@codefast/cli 0.3.13-canary.2 → 0.3.13-canary.4

package/dist/lib/arrange/domain/ast/ast-node.model.js

@@ -1,210 +0,0 @@
-/**
- * Pure-domain AST shapes for arrange analysis. No TypeScript compiler types.
- * Positions mirror `getStart(sourceFile)` / `getEnd()` semantics from translation.
- */
-export var DomainSyntaxKind;
-(function (DomainSyntaxKind) {
-    DomainSyntaxKind[DomainSyntaxKind["Unknown"] = 1] = "Unknown";
-    DomainSyntaxKind[DomainSyntaxKind["Identifier"] = 2] = "Identifier";
-    DomainSyntaxKind[DomainSyntaxKind["StringLiteral"] = 3] = "StringLiteral";
-    DomainSyntaxKind[DomainSyntaxKind["NoSubstitutionTemplateLiteral"] = 4] = "NoSubstitutionTemplateLiteral";
-    DomainSyntaxKind[DomainSyntaxKind["ImportDeclaration"] = 5] = "ImportDeclaration";
-    DomainSyntaxKind[DomainSyntaxKind["ImportClause"] = 6] = "ImportClause";
-    DomainSyntaxKind[DomainSyntaxKind["NamedImports"] = 7] = "NamedImports";
-    DomainSyntaxKind[DomainSyntaxKind["NamespaceImport"] = 8] = "NamespaceImport";
-    DomainSyntaxKind[DomainSyntaxKind["ImportSpecifier"] = 9] = "ImportSpecifier";
-    DomainSyntaxKind[DomainSyntaxKind["CallExpression"] = 10] = "CallExpression";
-    DomainSyntaxKind[DomainSyntaxKind["PropertyAccessExpression"] = 11] = "PropertyAccessExpression";
-    DomainSyntaxKind[DomainSyntaxKind["ObjectLiteralExpression"] = 12] = "ObjectLiteralExpression";
-    DomainSyntaxKind[DomainSyntaxKind["PropertyAssignment"] = 13] = "PropertyAssignment";
-    DomainSyntaxKind[DomainSyntaxKind["ArrayLiteralExpression"] = 14] = "ArrayLiteralExpression";
-    DomainSyntaxKind[DomainSyntaxKind["SpreadElement"] = 15] = "SpreadElement";
-    DomainSyntaxKind[DomainSyntaxKind["ParenthesizedExpression"] = 16] = "ParenthesizedExpression";
-    DomainSyntaxKind[DomainSyntaxKind["AsExpression"] = 17] = "AsExpression";
-    DomainSyntaxKind[DomainSyntaxKind["SatisfiesExpression"] = 18] = "SatisfiesExpression";
-    DomainSyntaxKind[DomainSyntaxKind["NonNullExpression"] = 19] = "NonNullExpression";
-    DomainSyntaxKind[DomainSyntaxKind["ConditionalExpression"] = 20] = "ConditionalExpression";
-    DomainSyntaxKind[DomainSyntaxKind["BinaryExpression"] = 21] = "BinaryExpression";
-    DomainSyntaxKind[DomainSyntaxKind["ExpressionStatement"] = 22] = "ExpressionStatement";
-    DomainSyntaxKind[DomainSyntaxKind["JsxAttribute"] = 23] = "JsxAttribute";
-    DomainSyntaxKind[DomainSyntaxKind["JsxExpression"] = 24] = "JsxExpression";
-})(DomainSyntaxKind || (DomainSyntaxKind = {}));
-export var DomainBinaryOperator;
-(function (DomainBinaryOperator) {
-    DomainBinaryOperator[DomainBinaryOperator["Plus"] = 0] = "Plus";
-    DomainBinaryOperator[DomainBinaryOperator["Other"] = 1] = "Other";
-})(DomainBinaryOperator || (DomainBinaryOperator = {}));
-export function isDomainIdentifier(node) {
-    return node.kind === DomainSyntaxKind.Identifier;
-}
-export function isDomainStringLiteral(node) {
-    return node.kind === DomainSyntaxKind.StringLiteral;
-}
-export function isDomainNoSubstitutionTemplateLiteral(node) {
-    return node.kind === DomainSyntaxKind.NoSubstitutionTemplateLiteral;
-}
-export function isDomainTailwindClassLiteral(node) {
-    return isDomainStringLiteral(node) || isDomainNoSubstitutionTemplateLiteral(node);
-}
-export function isDomainImportDeclaration(node) {
-    return node.kind === DomainSyntaxKind.ImportDeclaration;
-}
-export function isDomainImportClause(node) {
-    return node !== undefined && node.kind === DomainSyntaxKind.ImportClause;
-}
-export function isDomainNamedImports(node) {
-    return node.kind === DomainSyntaxKind.NamedImports;
-}
-export function isDomainNamespaceImport(node) {
-    return node.kind === DomainSyntaxKind.NamespaceImport;
-}
-export function isDomainCallExpression(node) {
-    return node.kind === DomainSyntaxKind.CallExpression;
-}
-export function isDomainObjectLiteralExpression(node) {
-    return node.kind === DomainSyntaxKind.ObjectLiteralExpression;
-}
-export function isDomainPropertyAssignment(node) {
-    return node.kind === DomainSyntaxKind.PropertyAssignment;
-}
-export function isDomainArrayLiteralExpression(node) {
-    return node.kind === DomainSyntaxKind.ArrayLiteralExpression;
-}
-export function isDomainSpreadElement(node) {
-    return node.kind === DomainSyntaxKind.SpreadElement;
-}
-export function isDomainPropertyAccessExpression(node) {
-    return node.kind === DomainSyntaxKind.PropertyAccessExpression;
-}
-export function isDomainJsxAttribute(node) {
-    return node.kind === DomainSyntaxKind.JsxAttribute;
-}
-export function isDomainJsxExpression(node) {
-    return node.kind === DomainSyntaxKind.JsxExpression;
-}
-export function isDomainExpressionStatement(node) {
-    return node.kind === DomainSyntaxKind.ExpressionStatement;
-}
-export function forEachDomainChild(node, visit) {
-    switch (node.kind) {
-        case DomainSyntaxKind.Unknown:
-            for (const child of node.children) {
-                visit(child);
-            }
-            return;
-        case DomainSyntaxKind.ImportDeclaration:
-            if (node.importClause) {
-                visit(node.importClause);
-            }
-            visit(node.moduleSpecifier);
-            return;
-        case DomainSyntaxKind.ImportClause:
-            if (node.name) {
-                visit(node.name);
-            }
-            if (node.namedBindings) {
-                visit(node.namedBindings);
-            }
-            return;
-        case DomainSyntaxKind.NamedImports:
-            for (const element of node.elements) {
-                visit(element);
-            }
-            return;
-        case DomainSyntaxKind.NamespaceImport:
-            visit(node.name);
-            return;
-        case DomainSyntaxKind.ImportSpecifier:
-            if (node.propertyName) {
-                visit(node.propertyName);
-            }
-            visit(node.name);
-            return;
-        case DomainSyntaxKind.CallExpression:
-            visit(node.expression);
-            for (const arg of node.arguments) {
-                visit(arg);
-            }
-            return;
-        case DomainSyntaxKind.PropertyAccessExpression:
-            visit(node.expression);
-            visit(node.name);
-            return;
-        case DomainSyntaxKind.ObjectLiteralExpression:
-            for (const prop of node.properties) {
-                visit(prop);
-            }
-            return;
-        case DomainSyntaxKind.PropertyAssignment:
-            visit(node.name);
-            visit(node.initializer);
-            return;
-        case DomainSyntaxKind.ArrayLiteralExpression:
-            for (const element of node.elements) {
-                visit(element);
-            }
-            return;
-        case DomainSyntaxKind.SpreadElement:
-            visit(node.expression);
-            return;
-        case DomainSyntaxKind.ParenthesizedExpression:
-        case DomainSyntaxKind.AsExpression:
-        case DomainSyntaxKind.SatisfiesExpression:
-        case DomainSyntaxKind.NonNullExpression:
-            visit(node.expression);
-            return;
-        case DomainSyntaxKind.ConditionalExpression:
-            visit(node.condition);
-            visit(node.whenTrue);
-            visit(node.whenFalse);
-            return;
-        case DomainSyntaxKind.BinaryExpression:
-            visit(node.left);
-            visit(node.right);
-            return;
-        case DomainSyntaxKind.ExpressionStatement:
-            visit(node.expression);
-            return;
-        case DomainSyntaxKind.JsxAttribute:
-            visit(node.name);
-            if (node.initializer) {
-                visit(node.initializer);
-            }
-            return;
-        case DomainSyntaxKind.JsxExpression:
-            if (node.expression) {
-                visit(node.expression);
-            }
-            return;
-        default:
-            return;
-    }
-}
-export function forEachDomainDescendant(node, visit) {
-    visit(node);
-    forEachDomainChild(node, (child) => forEachDomainDescendant(child, visit));
-}
-export function forEachDomainDescendantFromSourceFile(sourceFile, visit) {
-    for (const statement of sourceFile.statements) {
-        forEachDomainDescendant(statement, visit);
-    }
-}
-export function findFirstDomainDescendantWhere(sourceFile, predicate) {
-    let found;
-    forEachDomainDescendantFromSourceFile(sourceFile, (n) => {
-        if (found === undefined && predicate(n)) {
-            found = n;
-        }
-    });
-    return found;
-}
-export function lineOfSourcePosition(sourceText, pos) {
-    const boundedPos = Math.max(0, Math.min(pos, sourceText.length));
-    let line = 1;
-    for (let i = 0; i < boundedPos; i++) {
-        if (sourceText.charCodeAt(i) === 10) {
-            line++;
-        }
-    }
-    return line;
-}

package/dist/lib/arrange/domain/ast/collectors-cn.d.ts

@@ -1,7 +0,0 @@
-import type { ForEachStringLiteralInClassExpressionOptions, TailwindClassLiteral } from "#lib/arrange/domain/types";
-import { type DomainAstNode } from "#lib/arrange/domain/ast/ast-node.model";
-export declare function forEachStringLiteralInClassExpression(expr: DomainAstNode, sink: (classLiteral: TailwindClassLiteral) => void, depth?: number, options?: ForEachStringLiteralInClassExpressionOptions): void;
-export declare function isUnsafeLiteralForCnStyleApplySplit(classLiteral: TailwindClassLiteral): boolean;
-export declare const CN_APPLY_LITERAL_WALK_OPTS: ForEachStringLiteralInClassExpressionOptions;
-export declare function collectUnconditionalTailwindLiteralsFromCnArguments(args: readonly DomainAstNode[]): TailwindClassLiteral[];
-//# sourceMappingURL=collectors-cn.d.ts.map

package/dist/lib/arrange/domain/ast/collectors-cn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collectors-cn.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/collectors-cn.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,4CAA4C,EAC5C,oBAAoB,EACrB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAGL,KAAK,aAAa,EAGnB,MAAM,wCAAwC,CAAC;AAEhD,wBAAgB,qCAAqC,CACnD,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,CAAC,YAAY,EAAE,oBAAoB,KAAK,IAAI,EAClD,KAAK,SAAI,EACT,OAAO,CAAC,EAAE,4CAA4C,GACrD,IAAI,CAsDN;AAED,wBAAgB,mCAAmC,CAAC,YAAY,EAAE,oBAAoB,GAAG,OAAO,CAE/F;AAED,eAAO,MAAM,0BAA0B,EAAE,4CAExC,CAAC;AAEF,wBAAgB,mDAAmD,CACjE,IAAI,EAAE,SAAS,aAAa,EAAE,GAC7B,oBAAoB,EAAE,CAqBxB"}

package/dist/lib/arrange/domain/ast/collectors-cn.js

@@ -1,70 +0,0 @@
-import { MAX_CLASS_EXPR_DEPTH } from "#lib/arrange/domain/constants";
-import { DomainBinaryOperator, DomainSyntaxKind, isDomainArrayLiteralExpression, isDomainTailwindClassLiteral, } from "#lib/arrange/domain/ast/ast-node.model";
-export function forEachStringLiteralInClassExpression(expr, sink, depth = 0, options) {
-    if (depth > MAX_CLASS_EXPR_DEPTH) {
-        return;
-    }
-    if (isDomainTailwindClassLiteral(expr)) {
-        sink(expr);
-        return;
-    }
-    if (expr.kind === DomainSyntaxKind.ParenthesizedExpression) {
-        forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
-        return;
-    }
-    if (expr.kind === DomainSyntaxKind.AsExpression ||
-        expr.kind === DomainSyntaxKind.SatisfiesExpression) {
-        forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
-        return;
-    }
-    if (expr.kind === DomainSyntaxKind.NonNullExpression) {
-        forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
-        return;
-    }
-    if (expr.kind === DomainSyntaxKind.ConditionalExpression) {
-        if (options?.descendIntoConditional === false) {
-            return;
-        }
-        forEachStringLiteralInClassExpression(expr.whenTrue, sink, depth + 1, options);
-        forEachStringLiteralInClassExpression(expr.whenFalse, sink, depth + 1, options);
-        return;
-    }
-    if (expr.kind === DomainSyntaxKind.BinaryExpression &&
-        expr.operator === DomainBinaryOperator.Plus) {
-        forEachStringLiteralInClassExpression(expr.left, sink, depth + 1, options);
-        forEachStringLiteralInClassExpression(expr.right, sink, depth + 1, options);
-        return;
-    }
-    if (isDomainArrayLiteralExpression(expr)) {
-        for (const arrayElement of expr.elements) {
-            if (arrayElement.kind === DomainSyntaxKind.SpreadElement) {
-                continue;
-            }
-            forEachStringLiteralInClassExpression(arrayElement, sink, depth + 1, options);
-        }
-    }
-}
-export function isUnsafeLiteralForCnStyleApplySplit(classLiteral) {
-    return classLiteral.parent !== null && isDomainArrayLiteralExpression(classLiteral.parent);
-}
-export const CN_APPLY_LITERAL_WALK_OPTS = {
-    descendIntoConditional: false,
-};
-export function collectUnconditionalTailwindLiteralsFromCnArguments(args) {
-    const staticLits = [];
-    for (const arg of args) {
-        if (isDomainTailwindClassLiteral(arg)) {
-            if (!isUnsafeLiteralForCnStyleApplySplit(arg)) {
-                staticLits.push(arg);
-            }
-        }
-        else {
-            forEachStringLiteralInClassExpression(arg, (lit) => {
-                if (!isUnsafeLiteralForCnStyleApplySplit(lit)) {
-                    staticLits.push(lit);
-                }
-            }, 0, CN_APPLY_LITERAL_WALK_OPTS);
-        }
-    }
-    return staticLits;
-}

package/dist/lib/arrange/domain/ast/collectors-jsx.d.ts

@@ -1,4 +0,0 @@
-import { type DomainJsxAttribute } from "#lib/arrange/domain/ast/ast-node.model";
-import type { JsxClassNameStatic } from "#lib/arrange/domain/types";
-export declare function jsxClassNameStaticLiteral(jsxClassNameAttribute: DomainJsxAttribute): JsxClassNameStatic | undefined;
-//# sourceMappingURL=collectors-jsx.d.ts.map

package/dist/lib/arrange/domain/ast/collectors-jsx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collectors-jsx.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/collectors-jsx.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,wCAAwC,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,wBAAgB,yBAAyB,CACvC,qBAAqB,EAAE,kBAAkB,GACxC,kBAAkB,GAAG,SAAS,CAsBhC"}

package/dist/lib/arrange/domain/ast/collectors-jsx.js

@@ -1,21 +0,0 @@
-import { isDomainIdentifier, isDomainJsxExpression, isDomainTailwindClassLiteral, } from "#lib/arrange/domain/ast/ast-node.model";
-export function jsxClassNameStaticLiteral(jsxClassNameAttribute) {
-    if (!isDomainIdentifier(jsxClassNameAttribute.name) ||
-        jsxClassNameAttribute.name.text !== "className") {
-        return undefined;
-    }
-    const init = jsxClassNameAttribute.initializer;
-    if (!init) {
-        return undefined;
-    }
-    if (isDomainTailwindClassLiteral(init)) {
-        return { lit: init, valueNode: init };
-    }
-    if (isDomainJsxExpression(init) && init.expression) {
-        const jsxExpressionBody = init.expression;
-        if (isDomainTailwindClassLiteral(jsxExpressionBody)) {
-            return { lit: jsxExpressionBody, valueNode: init };
-        }
-    }
-    return undefined;
-}

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

@@ -1,13 +0,0 @@
-import { type DomainCallExpression, type DomainObjectLiteralExpression, type DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
-import type { StringNode, TailwindClassLiteral } from "#lib/arrange/domain/types";
-type StringNodeVisitor = (classLiteral: TailwindClassLiteral, sourceFile: DomainSourceFile, cnCall?: DomainCallExpression) => void;
-export declare function traverseTvObject(sourceFile: DomainSourceFile, obj: DomainObjectLiteralExpression, visitor: StringNodeVisitor, depth?: number, knownBindings?: Set<string>): void;
-export declare function collectCnCallsInsideTv(sourceFile: DomainSourceFile, obj: DomainObjectLiteralExpression, knownBindings: Set<string>, depth?: number): DomainCallExpression[];
-export declare function listAllCnCallsInsideTvInSourceFile(sourceFile: DomainSourceFile, knownBindings: Set<string>): DomainCallExpression[];
-export declare function makeStringNode(nodes: TailwindClassLiteral[], sourceFile: DomainSourceFile, isTvContext: boolean, cnCall?: DomainCallExpression): StringNode;
-export declare function slotClassString(stringNode: StringNode): string;
-export declare function emitTvSlot(lits: TailwindClassLiteral[], sourceFile: DomainSourceFile, cnCall: DomainCallExpression | undefined, results: StringNode[], seenNodePos: Set<number>): void;
-export declare function collectTvSlots(sourceFile: DomainSourceFile, obj: DomainObjectLiteralExpression, knownBindings: Set<string>, results: StringNode[], seenNodePos: Set<number>, depth?: number): void;
-export declare function collectGroupableStringNodes(sourceFile: DomainSourceFile): StringNode[];
-export {};
-//# sourceMappingURL=collectors-tv.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"collectors-tv.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/collectors-tv.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,6BAA6B,EAClC,KAAK,gBAAgB,EAQtB,MAAM,wCAAwC,CAAC;AAOhD,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAQlF,KAAK,iBAAiB,GAAG,CACvB,YAAY,EAAE,oBAAoB,EAClC,UAAU,EAAE,gBAAgB,EAC5B,MAAM,CAAC,EAAE,oBAAoB,KAC1B,IAAI,CAAC;AAEV,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,gBAAgB,EAC5B,GAAG,EAAE,6BAA6B,EAClC,OAAO,EAAE,iBAAiB,EAC1B,KAAK,SAAI,EACT,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC1B,IAAI,CA2EN;AAED,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,gBAAgB,EAC5B,GAAG,EAAE,6BAA6B,EAClC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,EAC1B,KAAK,SAAI,GACR,oBAAoB,EAAE,CAkDxB;AAED,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,gBAAgB,EAC5B,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,oBAAoB,EAAE,CAkBxB;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,oBAAoB,EAAE,EAC7B,UAAU,EAAE,gBAAgB,EAC5B,WAAW,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE,oBAAoB,GAC5B,UAAU,CAUZ;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAE9D;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,oBAAoB,EAAE,EAC5B,UAAU,EAAE,gBAAgB,EAC5B,MAAM,EAAE,oBAAoB,GAAG,SAAS,EACxC,OAAO,EAAE,UAAU,EAAE,EACrB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GACvB,IAAI,CAmBN;AAED,wBAAgB,cAAc,CAC5B,UAAU,EAAE,gBAAgB,EAC5B,GAAG,EAAE,6BAA6B,EAClC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,EAC1B,OAAO,EAAE,UAAU,EAAE,EACrB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,KAAK,SAAI,GACR,IAAI,CAiHN;AAED,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,gBAAgB,GAAG,UAAU,EAAE,CAuCtF"}

package/dist/lib/arrange/domain/ast/collectors-tv.js

@@ -1,302 +0,0 @@
-import { APPLY_MIN_TOKENS, MAX_OBJECT_DEPTH } from "#lib/arrange/domain/constants";
-import { isDomainArrayLiteralExpression, isDomainCallExpression, isDomainObjectLiteralExpression, isDomainPropertyAssignment, isDomainSpreadElement, isDomainTailwindClassLiteral, forEachDomainChild, } from "#lib/arrange/domain/ast/ast-node.model";
-import { CN_APPLY_LITERAL_WALK_OPTS, collectUnconditionalTailwindLiteralsFromCnArguments, forEachStringLiteralInClassExpression, isUnsafeLiteralForCnStyleApplySplit, } from "#lib/arrange/domain/ast/collectors-cn";
-import { tokenizeClassString } from "#lib/arrange/domain/tokenizer";
-import { buildKnownCnTvBindings, isCnOrTvIdentifier, propertyAssignmentNameText, } from "#lib/arrange/domain/ast/ast-helpers";
-export function traverseTvObject(sourceFile, obj, visitor, depth = 0, knownBindings) {
-    if (depth > MAX_OBJECT_DEPTH) {
-        return;
-    }
-    for (const prop of obj.properties) {
-        if (!isDomainPropertyAssignment(prop)) {
-            continue;
-        }
-        const init = prop.initializer;
-        if (isDomainTailwindClassLiteral(init)) {
-            visitor(init, sourceFile, undefined);
-        }
-        else if (isDomainArrayLiteralExpression(init)) {
-            for (const arrayElement of init.elements) {
-                if (isDomainSpreadElement(arrayElement)) {
-                    continue;
-                }
-                if (isDomainTailwindClassLiteral(arrayElement)) {
-                    visitor(arrayElement, sourceFile, undefined);
-                }
-                else if (isDomainCallExpression(arrayElement) &&
-                    isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) {
-                    for (const arg of arrayElement.arguments) {
-                        forEachStringLiteralInClassExpression(arg, (lit) => {
-                            visitor(lit, sourceFile, arrayElement);
-                        });
-                    }
-                }
-                else if (isDomainObjectLiteralExpression(arrayElement)) {
-                    for (const objectProperty of arrayElement.properties) {
-                        if (!isDomainPropertyAssignment(objectProperty)) {
-                            continue;
-                        }
-                        const propName = propertyAssignmentNameText(objectProperty);
-                        if (propName !== "className" && propName !== "class") {
-                            continue;
-                        }
-                        const innerInit = objectProperty.initializer;
-                        if (isDomainTailwindClassLiteral(innerInit)) {
-                            visitor(innerInit, sourceFile, undefined);
-                        }
-                        else if (isDomainArrayLiteralExpression(innerInit)) {
-                            for (const nestedArrayElement of innerInit.elements) {
-                                if (isDomainSpreadElement(nestedArrayElement)) {
-                                    continue;
-                                }
-                                if (isDomainTailwindClassLiteral(nestedArrayElement)) {
-                                    visitor(nestedArrayElement, sourceFile, undefined);
-                                }
-                            }
-                        }
-                        else if (isDomainCallExpression(innerInit) &&
-                            isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) {
-                            for (const arg of innerInit.arguments) {
-                                forEachStringLiteralInClassExpression(arg, (lit) => {
-                                    visitor(lit, sourceFile, innerInit);
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        else if (isDomainObjectLiteralExpression(init)) {
-            traverseTvObject(sourceFile, init, visitor, depth + 1, knownBindings);
-        }
-        else if (isDomainCallExpression(init) &&
-            isCnOrTvIdentifier(init.expression, "cn", knownBindings)) {
-            for (const arg of init.arguments) {
-                forEachStringLiteralInClassExpression(arg, (lit) => {
-                    visitor(lit, sourceFile, init);
-                });
-            }
-        }
-    }
-}
-export function collectCnCallsInsideTv(sourceFile, obj, knownBindings, depth = 0) {
-    if (depth > MAX_OBJECT_DEPTH) {
-        return [];
-    }
-    const calls = [];
-    for (const prop of obj.properties) {
-        if (!isDomainPropertyAssignment(prop)) {
-            continue;
-        }
-        const init = prop.initializer;
-        if (isDomainArrayLiteralExpression(init)) {
-            for (const arrayElement of init.elements) {
-                if (isDomainSpreadElement(arrayElement)) {
-                    continue;
-                }
-                if (isDomainCallExpression(arrayElement) &&
-                    isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) {
-                    calls.push(arrayElement);
-                }
-                else if (isDomainObjectLiteralExpression(arrayElement)) {
-                    for (const objectProperty of arrayElement.properties) {
-                        if (!isDomainPropertyAssignment(objectProperty)) {
-                            continue;
-                        }
-                        const propName = propertyAssignmentNameText(objectProperty);
-                        if (propName !== "className" && propName !== "class") {
-                            continue;
-                        }
-                        const innerInit = objectProperty.initializer;
-                        if (isDomainCallExpression(innerInit) &&
-                            isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) {
-                            calls.push(innerInit);
-                        }
-                    }
-                }
-            }
-        }
-        else if (isDomainObjectLiteralExpression(init)) {
-            calls.push(...collectCnCallsInsideTv(sourceFile, init, knownBindings, depth + 1));
-        }
-        else if (isDomainCallExpression(init) &&
-            isCnOrTvIdentifier(init.expression, "cn", knownBindings)) {
-            calls.push(init);
-        }
-    }
-    return calls;
-}
-export function listAllCnCallsInsideTvInSourceFile(sourceFile, knownBindings) {
-    const calls = [];
-    const visitSubtree = (tsNode) => {
-        if (isDomainCallExpression(tsNode) &&
-            isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
-            const arg0 = tsNode.arguments[0];
-            if (arg0 && isDomainObjectLiteralExpression(arg0)) {
-                calls.push(...collectCnCallsInsideTv(sourceFile, arg0, knownBindings, 0));
-            }
-        }
-        forEachDomainChild(tsNode, visitSubtree);
-    };
-    for (const stmt of sourceFile.statements) {
-        visitSubtree(stmt);
-    }
-    return calls;
-}
-export function makeStringNode(nodes, sourceFile, isTvContext, cnCall) {
-    return {
-        nodes,
-        sf: sourceFile,
-        isTvContext,
-        cnCall,
-        get primaryClassLiteral() {
-            return this.nodes[0];
-        },
-    };
-}
-export function slotClassString(stringNode) {
-    return stringNode.nodes.map((literal) => literal.text).join(" ");
-}
-export function emitTvSlot(lits, sourceFile, cnCall, results, seenNodePos) {
-    if (lits.length === 0) {
-        return;
-    }
-    const firstPos = lits[0].pos;
-    if (seenNodePos.has(firstPos)) {
-        return;
-    }
-    seenNodePos.add(firstPos);
-    const totalTokens = lits.reduce((accumulatedTokenCount, literal) => accumulatedTokenCount + tokenizeClassString(literal.text).length, 0);
-    if (totalTokens < APPLY_MIN_TOKENS) {
-        return;
-    }
-    results.push(makeStringNode(lits, sourceFile, true, cnCall));
-}
-export function collectTvSlots(sourceFile, obj, knownBindings, results, seenNodePos, depth = 0) {
-    if (depth > MAX_OBJECT_DEPTH) {
-        return;
-    }
-    for (const prop of obj.properties) {
-        if (!isDomainPropertyAssignment(prop)) {
-            continue;
-        }
-        const init = prop.initializer;
-        if (isDomainTailwindClassLiteral(init)) {
-            emitTvSlot([init], sourceFile, undefined, results, seenNodePos);
-        }
-        else if (isDomainArrayLiteralExpression(init)) {
-            const arrayPos = init.pos;
-            if (seenNodePos.has(arrayPos)) {
-                continue;
-            }
-            seenNodePos.add(arrayPos);
-            const staticLits = [];
-            for (const arrayElement of init.elements) {
-                if (isDomainSpreadElement(arrayElement)) {
-                    continue;
-                }
-                if (isDomainTailwindClassLiteral(arrayElement)) {
-                    staticLits.push(arrayElement);
-                }
-                else if (isDomainCallExpression(arrayElement) &&
-                    isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) {
-                    for (const arg of arrayElement.arguments) {
-                        forEachStringLiteralInClassExpression(arg, (lit) => {
-                            if (!isUnsafeLiteralForCnStyleApplySplit(lit)) {
-                                staticLits.push(lit);
-                            }
-                        }, 0, CN_APPLY_LITERAL_WALK_OPTS);
-                    }
-                }
-                else if (isDomainObjectLiteralExpression(arrayElement)) {
-                    for (const objectProperty of arrayElement.properties) {
-                        if (!isDomainPropertyAssignment(objectProperty)) {
-                            continue;
-                        }
-                        const propName = propertyAssignmentNameText(objectProperty);
-                        if (propName !== "className" && propName !== "class") {
-                            continue;
-                        }
-                        const innerInit = objectProperty.initializer;
-                        if (isDomainTailwindClassLiteral(innerInit)) {
-                            emitTvSlot([innerInit], sourceFile, undefined, results, seenNodePos);
-                        }
-                        else if (isDomainArrayLiteralExpression(innerInit)) {
-                            const innerLits = [];
-                            for (const nestedArrayElement of innerInit.elements) {
-                                if (!isDomainSpreadElement(nestedArrayElement) &&
-                                    isDomainTailwindClassLiteral(nestedArrayElement)) {
-                                    innerLits.push(nestedArrayElement);
-                                }
-                            }
-                            emitTvSlot(innerLits, sourceFile, undefined, results, seenNodePos);
-                        }
-                        else if (isDomainCallExpression(innerInit) &&
-                            isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) {
-                            const cnLits = [];
-                            for (const arg of innerInit.arguments) {
-                                forEachStringLiteralInClassExpression(arg, (lit) => {
-                                    if (!isUnsafeLiteralForCnStyleApplySplit(lit)) {
-                                        cnLits.push(lit);
-                                    }
-                                }, 0, CN_APPLY_LITERAL_WALK_OPTS);
-                            }
-                            emitTvSlot(cnLits, sourceFile, innerInit, results, seenNodePos);
-                        }
-                    }
-                }
-            }
-            if (staticLits.length > 0) {
-                emitTvSlot(staticLits, sourceFile, undefined, results, seenNodePos);
-            }
-        }
-        else if (isDomainObjectLiteralExpression(init)) {
-            collectTvSlots(sourceFile, init, knownBindings, results, seenNodePos, depth + 1);
-        }
-        else if (isDomainCallExpression(init) &&
-            isCnOrTvIdentifier(init.expression, "cn", knownBindings)) {
-            const cnLits = [];
-            for (const arg of init.arguments) {
-                forEachStringLiteralInClassExpression(arg, (lit) => {
-                    if (!isUnsafeLiteralForCnStyleApplySplit(lit)) {
-                        cnLits.push(lit);
-                    }
-                }, 0, CN_APPLY_LITERAL_WALK_OPTS);
-            }
-            emitTvSlot(cnLits, sourceFile, init, results, seenNodePos);
-        }
-    }
-}
-export function collectGroupableStringNodes(sourceFile) {
-    const results = [];
-    const seenNodePos = new Set();
-    const knownBindings = buildKnownCnTvBindings(sourceFile);
-    const visitTypeScriptSubtree = (tsNode) => {
-        if (isDomainCallExpression(tsNode)) {
-            if (isCnOrTvIdentifier(tsNode.expression, "cn", knownBindings)) {
-                const callPos = tsNode.pos;
-                if (seenNodePos.has(callPos)) {
-                    forEachDomainChild(tsNode, visitTypeScriptSubtree);
-                    return;
-                }
-                seenNodePos.add(callPos);
-                const staticLits = collectUnconditionalTailwindLiteralsFromCnArguments(tsNode.arguments);
-                const totalTokens = staticLits.reduce((accumulatedTokenCount, literal) => accumulatedTokenCount + tokenizeClassString(literal.text).length, 0);
-                if (staticLits.length > 0 && totalTokens >= APPLY_MIN_TOKENS) {
-                    results.push(makeStringNode(staticLits, sourceFile, false, tsNode));
-                }
-            }
-            else if (isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
-                const arg0 = tsNode.arguments[0];
-                if (arg0 && isDomainObjectLiteralExpression(arg0)) {
-                    collectTvSlots(sourceFile, arg0, knownBindings, results, seenNodePos);
-                }
-            }
-        }
-        forEachDomainChild(tsNode, visitTypeScriptSubtree);
-    };
-    for (const stmt of sourceFile.statements) {
-        visitTypeScriptSubtree(stmt);
-    }
-    return results;
-}

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

@@ -1,8 +0,0 @@
-import type { GroupTarget, PlannedGroupEdit, StringNode } from "#lib/arrange/domain/types";
-import { type DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
-export declare function targetReplaceStart(target: GroupTarget): number;
-export declare function collectLongJsxClassNameTargets(sourceFile: DomainSourceFile): GroupTarget[];
-export declare function collectGroupTargets(sourceFile: DomainSourceFile, filePath: string): GroupTarget[];
-export declare function formatCnCallReplacement(stringNode: StringNode, sourceText: string, withClassName: boolean): string;
-export declare function planGroupEditForTarget(target: GroupTarget, textAfterUnwrap: string, withClassName: boolean): PlannedGroupEdit | undefined;
-//# sourceMappingURL=targets.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/targets.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAS3F,OAAO,EAEL,KAAK,gBAAgB,EAKtB,MAAM,wCAAwC,CAAC;AAEhD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAK9D;AAED,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,gBAAgB,GAAG,WAAW,EAAE,CAoB1F;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE,CASjG;AAED,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,OAAO,GACrB,MAAM,CAyCR;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,WAAW,EACnB,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,OAAO,GACrB,gBAAgB,GAAG,SAAS,CA6E9B"}