@codefast/cli 0.3.13-canary.1 → 0.3.13-canary.3

package/dist/lib/arrange/domain/ast/ast-node.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-node.model.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/ast-node.model.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,210 @@
+/**
+ * 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.collector.d.ts

@@ -0,0 +1,7 @@
+import type { ForEachStringLiteralInClassExpressionOptions, TailwindClassLiteral } from "#lib/arrange/domain/types.domain";
+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.collector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectors-cn.collector.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/collectors-cn.collector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,4CAA4C,EAC5C,oBAAoB,EACrB,MAAM,kCAAkC,CAAC;AAC1C,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.collector.js

@@ -0,0 +1,70 @@
+import { MAX_CLASS_EXPR_DEPTH } from "#lib/arrange/domain/constants.domain";
+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.collector.d.ts

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

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

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

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

@@ -0,0 +1,21 @@
+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.collector.d.ts

@@ -0,0 +1,13 @@
+import { type DomainCallExpression, type DomainObjectLiteralExpression, type DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
+import type { StringNode, TailwindClassLiteral } from "#lib/arrange/domain/types.domain";
+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.collector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectors-tv.collector.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/collectors-tv.collector.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,kCAAkC,CAAC;AAQzF,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.collector.js

@@ -0,0 +1,302 @@
+import { APPLY_MIN_TOKENS, MAX_OBJECT_DEPTH } from "#lib/arrange/domain/constants.domain";
+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.collector";
+import { tokenizeClassString } from "#lib/arrange/domain/tokenizer.util";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, propertyAssignmentNameText, } from "#lib/arrange/domain/ast/ast-helpers.helper";
+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;
+}