yaxa-svelte 2.0.4 → 2.1.0

package/dist/components/elements/CodeBlock.test.js

@@ -48,6 +48,36 @@ describe('tokenizeCode', () => {
         const line4 = tokens[4].map((t) => ({ text: t.text, type: t.type }));
         expect(line4).toContainEqual({ text: 'assert', type: 'keyword' });
     });
+    it('tokenizes Python 3.13+ syntax: type parameters, TypeIs narrowing, match/case and decorators', () => {
+        const pyCode = `type Point[T = int] = tuple[T, T]
+@deprecated
+def is_str(val: object) -> TypeIs[str]:
+    match val:
+        case str():
+            return True
+        case _:
+            return False`;
+        const tokens = tokenizeCode(pyCode, 'python');
+        expect(tokens).toHaveLength(8);
+        // Line 0: type Point[T = int] = tuple[T, T]
+        const line0 = tokens[0].map((t) => ({ text: t.text, type: t.type }));
+        expect(line0).toContainEqual({ text: 'type', type: 'keyword' });
+        expect(line0).toContainEqual({ text: 'int', type: 'macro' });
+        expect(line0).toContainEqual({ text: 'tuple', type: 'macro' });
+        // Line 1: @deprecated
+        const line1 = tokens[1].map((t) => ({ text: t.text, type: t.type }));
+        expect(line1).toContainEqual({ text: '@deprecated', type: 'decorator' });
+        // Line 2: def is_str(val: object) -> TypeIs[str]:
+        const line2 = tokens[2].map((t) => ({ text: t.text, type: t.type }));
+        expect(line2).toContainEqual({ text: 'def', type: 'keyword' });
+        expect(line2).toContainEqual({ text: 'TypeIs', type: 'macro' });
+        expect(line2).toContainEqual({ text: 'str', type: 'macro' });
+        // Line 3 & 4: match / case
+        const line3 = tokens[3].map((t) => ({ text: t.text, type: t.type }));
+        expect(line3).toContainEqual({ text: 'match', type: 'keyword' });
+        const line4 = tokens[4].map((t) => ({ text: t.text, type: t.type }));
+        expect(line4).toContainEqual({ text: 'case', type: 'keyword' });
+    });
     it('tokenizes tailwind css v4 at-rules, variables and hex colors', () => {
         const cssCode = `@theme {
   --color-primary-500: #ff3e00;
@@ -150,4 +180,201 @@ type TaskResult = Awaited<Promise<Record<string, unknown>>>;`;
         const line11 = tokens[11].map((t) => ({ text: t.text, type: t.type }));
         expect(line11).toContainEqual({ text: 'Awaited', type: 'macro' });
     });
+    it('tokenizes YAML keys, anchors, aliases, tags, booleans and document markers', () => {
+        const yamlCode = `---
+# App configuration
+name: "yaxa-app"
+version: 2.1
+enabled: true
+maintenance: off
+defaults: &base_config
+  timeout: 30
+production: *base_config
+tag_demo: !custom_tag
+created_at: 2026-10-27`;
+        const tokens = tokenizeCode(yamlCode, 'yaml');
+        expect(tokens).toHaveLength(11);
+        // Line 0: ---
+        expect(tokens[0][0]).toEqual({ text: '---', type: 'punctuation' });
+        // Line 1: # App configuration
+        expect(tokens[1][0]).toEqual({ text: '# App configuration', type: 'comment' });
+        // Line 2: name: "yaxa-app"
+        const line2 = tokens[2].map((t) => ({ text: t.text, type: t.type }));
+        expect(line2).toContainEqual({ text: 'name', type: 'attr' });
+        expect(line2).toContainEqual({ text: '"yaxa-app"', type: 'string' });
+        // Line 4: enabled: true
+        const line4 = tokens[4].map((t) => ({ text: t.text, type: t.type }));
+        expect(line4).toContainEqual({ text: 'enabled', type: 'attr' });
+        expect(line4).toContainEqual({ text: 'true', type: 'keyword' });
+        // Line 5: maintenance: off
+        const line5 = tokens[5].map((t) => ({ text: t.text, type: t.type }));
+        expect(line5).toContainEqual({ text: 'maintenance', type: 'attr' });
+        expect(line5).toContainEqual({ text: 'off', type: 'keyword' });
+        // Line 6: defaults: &base_config
+        const line6 = tokens[6].map((t) => ({ text: t.text, type: t.type }));
+        expect(line6).toContainEqual({ text: 'defaults', type: 'attr' });
+        expect(line6).toContainEqual({ text: '&base_config', type: 'macro' });
+        // Line 8: production: *base_config
+        const line8 = tokens[8].map((t) => ({ text: t.text, type: t.type }));
+        expect(line8).toContainEqual({ text: 'production', type: 'attr' });
+        expect(line8).toContainEqual({ text: '*base_config', type: 'macro' });
+        // Line 9: tag_demo: !custom_tag
+        const line9 = tokens[9].map((t) => ({ text: t.text, type: t.type }));
+        expect(line9).toContainEqual({ text: 'tag_demo', type: 'attr' });
+        expect(line9).toContainEqual({ text: '!custom_tag', type: 'directive' });
+        // Line 10: created_at: 2026-10-27
+        const line10 = tokens[10].map((t) => ({ text: t.text, type: t.type }));
+        expect(line10).toContainEqual({ text: 'created_at', type: 'attr' });
+        expect(line10).toContainEqual({ text: '2026-10-27', type: 'number' });
+    });
+    it('tokenizes TOML table headers, keys, dates, and multiline strings', () => {
+        const tomlCode = `[server]
+port = 8080
+enabled = true
+started = 1979-05-27T07:32:00Z
+bio = """
+Hello World
+Multilined
+"""`;
+        const tokens = tokenizeCode(tomlCode, 'toml');
+        expect(tokens).toHaveLength(8);
+        // Line 0: [server]
+        expect(tokens[0][0]).toEqual({ text: '[server]', type: 'directive' });
+        // Line 1: port = 8080
+        const line1 = tokens[1].map((t) => ({ text: t.text, type: t.type }));
+        expect(line1).toContainEqual({ text: 'port', type: 'attr' });
+        expect(line1).toContainEqual({ text: '8080', type: 'number' });
+        // Line 2: enabled = true
+        const line2 = tokens[2].map((t) => ({ text: t.text, type: t.type }));
+        expect(line2).toContainEqual({ text: 'enabled', type: 'attr' });
+        expect(line2).toContainEqual({ text: 'true', type: 'keyword' });
+        // Line 3: started = 1979-05-27T07:32:00Z
+        const line3 = tokens[3].map((t) => ({ text: t.text, type: t.type }));
+        expect(line3).toContainEqual({ text: 'started', type: 'attr' });
+        expect(line3).toContainEqual({ text: '1979-05-27T07:32:00Z', type: 'number' });
+        // Multiline string across lines 4, 5, 6, 7
+        expect(tokens[4].some((t) => t.type === 'string')).toBe(true);
+        expect(tokens[5][0].type).toBe('string');
+        expect(tokens[6][0].type).toBe('string');
+        expect(tokens[7].some((t) => t.type === 'string')).toBe(true);
+    });
+    it('tokenizes Rust attributes, macros, lifetimes, and standard types to Tier 1 standard', () => {
+        const rustCode = `#[derive(Debug, Clone)]
+pub fn process<'a>(name: &'a str) -> Option<String> {
+    let items: Vec<i32> = vec![1, 2, 3];
+    println!("Processed: {}", name);
+    Some(name.to_string())
+}`;
+        const tokens = tokenizeCode(rustCode, 'rust');
+        expect(tokens).toHaveLength(6);
+        // Line 0: #[derive(Debug, Clone)]
+        expect(tokens[0][0].type).toBe('decorator');
+        // Line 1: pub fn process<'a>(name: &'a str) -> Option<String>
+        const line1 = tokens[1].map((t) => ({ text: t.text, type: t.type }));
+        expect(line1).toContainEqual({ text: 'pub', type: 'keyword' });
+        expect(line1).toContainEqual({ text: 'fn', type: 'keyword' });
+        expect(line1).toContainEqual({ text: "'a", type: 'macro' });
+        expect(line1).toContainEqual({ text: 'str', type: 'macro' });
+        expect(line1).toContainEqual({ text: 'Option', type: 'macro' });
+        expect(line1).toContainEqual({ text: 'String', type: 'macro' });
+        // Line 2: let items: Vec<i32> = vec![1, 2, 3];
+        const line2 = tokens[2].map((t) => ({ text: t.text, type: t.type }));
+        expect(line2).toContainEqual({ text: 'Vec', type: 'macro' });
+        expect(line2).toContainEqual({ text: 'i32', type: 'macro' });
+        expect(line2).toContainEqual({ text: 'vec!', type: 'macro' });
+        // Line 3: println!("...")
+        const line3 = tokens[3].map((t) => ({ text: t.text, type: t.type }));
+        expect(line3).toContainEqual({ text: 'println!', type: 'macro' });
+        // Line 4: Some(...)
+        const line4 = tokens[4].map((t) => ({ text: t.text, type: t.type }));
+        expect(line4).toContainEqual({ text: 'Some', type: 'macro' });
+    });
+    it('tokenizes Go built-in functions and primitive types to Tier 1 standard', () => {
+        const goCode = `package main
+func NewBuffer(size int) (error, any) {
+    buf := make([]byte, size)
+    println(len(buf))
+    return nil, buf
+}`;
+        const tokens = tokenizeCode(goCode, 'go');
+        expect(tokens).toHaveLength(6);
+        // Line 0: package main
+        expect(tokens[0].some((t) => t.text === 'package' && t.type === 'keyword')).toBe(true);
+        // Line 1: func NewBuffer(size int) (error, any)
+        const line1 = tokens[1].map((t) => ({ text: t.text, type: t.type }));
+        expect(line1).toContainEqual({ text: 'func', type: 'keyword' });
+        expect(line1).toContainEqual({ text: 'int', type: 'macro' });
+        expect(line1).toContainEqual({ text: 'error', type: 'macro' });
+        expect(line1).toContainEqual({ text: 'any', type: 'macro' });
+        // Line 2: make([]byte)
+        const line2 = tokens[2].map((t) => ({ text: t.text, type: t.type }));
+        expect(line2).toContainEqual({ text: 'make', type: 'function' });
+        expect(line2).toContainEqual({ text: 'byte', type: 'macro' });
+        // Line 3: len(buf)
+        const line3 = tokens[3].map((t) => ({ text: t.text, type: t.type }));
+        expect(line3).toContainEqual({ text: 'len', type: 'function' });
+    });
+    it('tokenizes SQL DDL, constraints, clauses, and data types to Tier 1 standard', () => {
+        const sqlCode = `CREATE TABLE users (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    email VARCHAR(255) NOT NULL UNIQUE,
+    metadata JSONB,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+SELECT id, email FROM users WHERE id IS NOT NULL ORDER BY created_at DESC LIMIT 10;`;
+        const tokens = tokenizeCode(sqlCode, 'sql');
+        expect(tokens).toHaveLength(7);
+        // Line 0: CREATE TABLE users (
+        const line0 = tokens[0].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line0).toContainEqual({ text: 'CREATE', type: 'keyword' });
+        expect(line0).toContainEqual({ text: 'TABLE', type: 'keyword' });
+        // Line 1: id UUID PRIMARY KEY DEFAULT ...
+        const line1 = tokens[1].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line1).toContainEqual({ text: 'UUID', type: 'macro' });
+        expect(line1).toContainEqual({ text: 'PRIMARY', type: 'keyword' });
+        expect(line1).toContainEqual({ text: 'KEY', type: 'keyword' });
+        expect(line1).toContainEqual({ text: 'DEFAULT', type: 'keyword' });
+        // Line 2: VARCHAR
+        const line2 = tokens[2].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line2).toContainEqual({ text: 'VARCHAR', type: 'macro' });
+        expect(line2).toContainEqual({ text: 'NOT', type: 'keyword' });
+        expect(line2).toContainEqual({ text: 'NULL', type: 'keyword' });
+        expect(line2).toContainEqual({ text: 'UNIQUE', type: 'keyword' });
+        // Line 3: JSONB
+        const line3 = tokens[3].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line3).toContainEqual({ text: 'JSONB', type: 'macro' });
+        // Line 4: TIMESTAMPTZ
+        const line4 = tokens[4].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line4).toContainEqual({ text: 'TIMESTAMPTZ', type: 'macro' });
+        // Line 6: SELECT query
+        const line6 = tokens[6].map((t) => ({ text: t.text.toUpperCase(), type: t.type }));
+        expect(line6).toContainEqual({ text: 'SELECT', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'FROM', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'WHERE', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'ORDER', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'BY', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'DESC', type: 'keyword' });
+        expect(line6).toContainEqual({ text: 'LIMIT', type: 'keyword' });
+    });
+    it('tokenizes GraphQL queries, variables, directives, and scalar types to Tier 1 standard', () => {
+        const gqlCode = `query GetUser($userId: ID!, $withDetails: Boolean = true) {
+  user(id: $userId) {
+    id
+    name
+    email @include(if: $withDetails)
+  }
+}`;
+        const tokens = tokenizeCode(gqlCode, 'graphql');
+        expect(tokens).toHaveLength(7);
+        // Line 0: query GetUser($userId: ID!, $withDetails: Boolean = true)
+        const line0 = tokens[0].map((t) => ({ text: t.text, type: t.type }));
+        expect(line0).toContainEqual({ text: 'query', type: 'keyword' });
+        expect(line0).toContainEqual({ text: '$userId', type: 'macro' });
+        expect(line0).toContainEqual({ text: 'ID', type: 'macro' });
+        expect(line0).toContainEqual({ text: '$withDetails', type: 'macro' });
+        expect(line0).toContainEqual({ text: 'Boolean', type: 'macro' });
+        // Line 4: email @include(if: $withDetails)
+        const line4 = tokens[4].map((t) => ({ text: t.text, type: t.type }));
+        expect(line4).toContainEqual({ text: '@include', type: 'decorator' });
+    });
 });

package/dist/components/elements/CodeDiff.svelte

@@ -318,6 +318,8 @@
 										>{token.text}</span
 									>{:else if token.type === 'macro'}<span
 										class="font-semibold text-indigo-600 dark:text-indigo-400">{token.text}</span
+									>{:else if token.type === 'decorator'}<span
+										class="text-purple-600 dark:text-purple-400">{token.text}</span
 									>{:else if token.type === 'number'}<span
 										class="text-purple-600 dark:text-purple-400">{token.text}</span
 									>{:else if token.type === 'punctuation'}<span
@@ -378,6 +380,12 @@
 									<span class="text-amber-600 dark:text-amber-300">{token.text}</span>
 								{:else if token.type === 'function'}
 									<span class="text-sky-600 dark:text-sky-400">{token.text}</span>
+								{:else if token.type === 'macro'}
+									<span class="font-semibold text-indigo-600 dark:text-indigo-400"
+										>{token.text}</span
+									>
+								{:else if token.type === 'decorator'}
+									<span class="text-purple-600 dark:text-purple-400">{token.text}</span>
 								{:else if token.type === 'number'}
 									<span class="text-purple-600 dark:text-purple-400">{token.text}</span>
 								{:else if token.type === 'punctuation'}
@@ -437,6 +445,12 @@
 									<span class="text-amber-600 dark:text-amber-300">{token.text}</span>
 								{:else if token.type === 'function'}
 									<span class="text-sky-600 dark:text-sky-400">{token.text}</span>
+								{:else if token.type === 'macro'}
+									<span class="font-semibold text-indigo-600 dark:text-indigo-400"
+										>{token.text}</span
+									>
+								{:else if token.type === 'decorator'}
+									<span class="text-purple-600 dark:text-purple-400">{token.text}</span>
 								{:else if token.type === 'number'}
 									<span class="text-purple-600 dark:text-purple-400">{token.text}</span>
 								{:else if token.type === 'punctuation'}

package/dist/components/elements/CodeDiff.test.js

@@ -49,4 +49,20 @@ describe('CodeDiff Component & Diff Algorithm', () => {
         expect(target.textContent).toContain('Greeting.svelte');
         cleanup();
     });
+    it('should highlight modern Python 3.13 and macro tokens in diff view', () => {
+        const original = `def check(val: object):\n  return False`;
+        const modified = `@deprecated\ndef check(val: object) -> TypeIs[str]:\n  return True`;
+        const { target, cleanup } = renderComponent(CodeDiff, {
+            original,
+            modified,
+            filename: 'validator.py',
+            language: 'python',
+            viewMode: 'unified'
+        });
+        expect(target.textContent).toContain('@deprecated');
+        expect(target.textContent).toContain('TypeIs');
+        expect(target.textContent).toContain('+3');
+        expect(target.textContent).toContain('-2');
+        cleanup();
+    });
 });

package/dist/components/elements/EmptyState.svelte.d.ts

@@ -3,35 +3,15 @@ import type { Snippet } from 'svelte';
 import type { IconSource } from './Icon.svelte';
 export declare const emptyStateVariants: import("tailwind-variants").TVReturnType<{
     size: {
-        sm: "py-6 px-4 gap-2";
-        md: "py-10 px-6 gap-3";
-        lg: "py-16 px-8 gap-4";
+        sm: string;
+        md: string;
+        lg: string;
     };
     bordered: {
-        true: "border border-dashed border-neutral-300 dark:border-neutral-800";
-        false: "border-0";
+        true: string;
+        false: string;
     };
-}, undefined, "flex flex-col items-center justify-center text-center p-8 rounded-2xl bg-white dark:bg-neutral-900/50", {
-    size: {
-        sm: "py-6 px-4 gap-2";
-        md: "py-10 px-6 gap-3";
-        lg: "py-16 px-8 gap-4";
-    };
-    bordered: {
-        true: "border border-dashed border-neutral-300 dark:border-neutral-800";
-        false: "border-0";
-    };
-}, undefined, import("tailwind-variants").TVReturnTypeLike<{
-    size: {
-        sm: "py-6 px-4 gap-2";
-        md: "py-10 px-6 gap-3";
-        lg: "py-16 px-8 gap-4";
-    };
-    bordered: {
-        true: "border border-dashed border-neutral-300 dark:border-neutral-800";
-        false: "border-0";
-    };
-}, undefined>>;
+}, undefined, "flex flex-col items-center justify-center text-center p-8 rounded-2xl bg-white dark:bg-neutral-900/50", undefined, undefined, undefined>;
 export type EmptyStateProps = VariantProps<typeof emptyStateVariants> & {
     title?: string;
     description?: string;

package/dist/components/elements/Icon.svelte.d.ts

@@ -1,29 +1,13 @@
 import type { Component, Snippet } from 'svelte';
 export declare const iconVariants: import("tailwind-variants").TVReturnType<{
     size: {
-        xs: "w-3.5 h-3.5";
-        sm: "w-4 h-4";
-        md: "w-5 h-5";
-        lg: "w-6 h-6";
-        xl: "w-8 h-8";
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
     };
-}, undefined, "inline-flex shrink-0 items-center justify-center", {
-    size: {
-        xs: "w-3.5 h-3.5";
-        sm: "w-4 h-4";
-        md: "w-5 h-5";
-        lg: "w-6 h-6";
-        xl: "w-8 h-8";
-    };
-}, undefined, import("tailwind-variants").TVReturnTypeLike<{
-    size: {
-        xs: "w-3.5 h-3.5";
-        sm: "w-4 h-4";
-        md: "w-5 h-5";
-        lg: "w-6 h-6";
-        xl: "w-8 h-8";
-    };
-}, undefined>>;
+}, undefined, "inline-flex shrink-0 items-center justify-center", undefined, undefined, undefined>;
 export type IconSource = string | Component<{
     class?: string;
     size?: string | number;

package/dist/components/elements/Kbd.svelte.d.ts

@@ -2,26 +2,12 @@ import { type VariantProps } from '../../utils/cn.js';
 import type { Snippet } from 'svelte';
 export declare const kbdVariants: import("tailwind-variants").TVReturnType<{
     size: {
-        xs: "h-4 min-w-[16px] px-1 text-[10px]";
-        sm: "h-5 min-w-[20px] px-1.5 text-xs";
-        md: "h-6 min-w-[24px] px-2 text-xs";
-        lg: "h-7 min-w-[28px] px-2.5 text-sm";
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
     };
-}, undefined, "inline-flex items-center justify-center font-mono font-medium rounded border border-neutral-300 bg-neutral-100 text-neutral-700 shadow-xs dark:border-neutral-700 dark:bg-neutral-800 dark:text-neutral-300 select-none", {
-    size: {
-        xs: "h-4 min-w-[16px] px-1 text-[10px]";
-        sm: "h-5 min-w-[20px] px-1.5 text-xs";
-        md: "h-6 min-w-[24px] px-2 text-xs";
-        lg: "h-7 min-w-[28px] px-2.5 text-sm";
-    };
-}, undefined, import("tailwind-variants").TVReturnTypeLike<{
-    size: {
-        xs: "h-4 min-w-[16px] px-1 text-[10px]";
-        sm: "h-5 min-w-[20px] px-1.5 text-xs";
-        md: "h-6 min-w-[24px] px-2 text-xs";
-        lg: "h-7 min-w-[28px] px-2.5 text-sm";
-    };
-}, undefined>>;
+}, undefined, "inline-flex items-center justify-center font-mono font-medium rounded border border-neutral-300 bg-neutral-100 text-neutral-700 shadow-xs dark:border-neutral-700 dark:bg-neutral-800 dark:text-neutral-300 select-none", undefined, undefined, undefined>;
 export type KbdProps = VariantProps<typeof kbdVariants> & {
     value?: string;
     keys?: string[];

package/dist/components/elements/Progress.svelte.d.ts

@@ -1,44 +1,18 @@
 import { type VariantProps } from '../../utils/cn.js';
 export declare const progressVariants: import("tailwind-variants").TVReturnType<{
     size: {
-        xs: "h-1";
-        sm: "h-1.5";
-        md: "h-2.5";
-        lg: "h-4";
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
     };
     color: {
-        primary: "[&>div]:bg-primary-600";
-        success: "[&>div]:bg-emerald-600";
-        warning: "[&>div]:bg-amber-600";
-        error: "[&>div]:bg-rose-600";
+        primary: string;
+        success: string;
+        warning: string;
+        error: string;
     };
-}, undefined, "relative w-full overflow-hidden rounded-full bg-neutral-200 dark:bg-neutral-800", {
-    size: {
-        xs: "h-1";
-        sm: "h-1.5";
-        md: "h-2.5";
-        lg: "h-4";
-    };
-    color: {
-        primary: "[&>div]:bg-primary-600";
-        success: "[&>div]:bg-emerald-600";
-        warning: "[&>div]:bg-amber-600";
-        error: "[&>div]:bg-rose-600";
-    };
-}, undefined, import("tailwind-variants").TVReturnTypeLike<{
-    size: {
-        xs: "h-1";
-        sm: "h-1.5";
-        md: "h-2.5";
-        lg: "h-4";
-    };
-    color: {
-        primary: "[&>div]:bg-primary-600";
-        success: "[&>div]:bg-emerald-600";
-        warning: "[&>div]:bg-amber-600";
-        error: "[&>div]:bg-rose-600";
-    };
-}, undefined>>;
+}, undefined, "relative w-full overflow-hidden rounded-full bg-neutral-200 dark:bg-neutral-800", undefined, undefined, undefined>;
 export type ProgressProps = VariantProps<typeof progressVariants> & {
     value?: number;
     max?: number;

package/dist/components/elements/Skeleton.svelte.d.ts

@@ -1,41 +1,17 @@
 import { type VariantProps } from '../../utils/cn.js';
 export declare const skeletonVariants: import("tailwind-variants").TVReturnType<{
     variant: {
-        pulse: "animate-pulse";
-        shimmer: "before:absolute before:inset-0 before:-translate-x-full before:animate-[yaxa-shimmer-slide_1.5s_infinite] before:bg-gradient-to-r before:from-transparent before:via-white/60 before:to-transparent motion-reduce:before:animate-none dark:before:via-white/20";
-        none: "";
+        pulse: string;
+        shimmer: string;
+        none: string;
     };
     shape: {
-        rectangle: "rounded-lg";
-        circle: "rounded-full aspect-square";
-        pill: "rounded-full";
-        text: "rounded h-4 my-1";
+        rectangle: string;
+        circle: string;
+        pill: string;
+        text: string;
     };
-}, undefined, "relative overflow-hidden bg-neutral-200 select-none motion-reduce:animate-none dark:bg-neutral-800", {
-    variant: {
-        pulse: "animate-pulse";
-        shimmer: "before:absolute before:inset-0 before:-translate-x-full before:animate-[yaxa-shimmer-slide_1.5s_infinite] before:bg-gradient-to-r before:from-transparent before:via-white/60 before:to-transparent motion-reduce:before:animate-none dark:before:via-white/20";
-        none: "";
-    };
-    shape: {
-        rectangle: "rounded-lg";
-        circle: "rounded-full aspect-square";
-        pill: "rounded-full";
-        text: "rounded h-4 my-1";
-    };
-}, undefined, import("tailwind-variants").TVReturnTypeLike<{
-    variant: {
-        pulse: "animate-pulse";
-        shimmer: "before:absolute before:inset-0 before:-translate-x-full before:animate-[yaxa-shimmer-slide_1.5s_infinite] before:bg-gradient-to-r before:from-transparent before:via-white/60 before:to-transparent motion-reduce:before:animate-none dark:before:via-white/20";
-        none: "";
-    };
-    shape: {
-        rectangle: "rounded-lg";
-        circle: "rounded-full aspect-square";
-        pill: "rounded-full";
-        text: "rounded h-4 my-1";
-    };
-}, undefined>>;
+}, undefined, "relative overflow-hidden bg-neutral-200 select-none motion-reduce:animate-none dark:bg-neutral-800", undefined, undefined, undefined>;
 export type SkeletonRecipe = 'card' | 'user' | 'table-row' | 'metric';
 export type SkeletonProps = VariantProps<typeof skeletonVariants> & {
     recipe?: SkeletonRecipe;

package/dist/components/elements/Terminal.svelte.d.ts

@@ -5,7 +5,7 @@ export interface TerminalLine {
     comment?: string;
     prompt?: string;
 }
-export declare const terminalVariants: import("tailwind-variants").TVReturnType<{} | {} | {}, undefined, "w-full overflow-hidden rounded-xl border border-neutral-800 bg-neutral-950 font-mono shadow-2xl transition-all", {} | {}, undefined, import("tailwind-variants").TVReturnTypeLike<unknown, undefined>>;
+export declare const terminalVariants: import("tailwind-variants").TVReturnType<{}, undefined, "w-full overflow-hidden rounded-xl border border-neutral-800 bg-neutral-950 font-mono shadow-2xl transition-all", undefined, undefined, undefined>;
 export type TerminalProps = VariantProps<typeof terminalVariants> & {
     title?: string;
     lines?: TerminalLine[];

package/dist/components/elements/Timeline.svelte.d.ts

@@ -12,23 +12,11 @@ export interface TimelineItem {
 }
 export declare const timelineVariants: import("tailwind-variants").TVReturnType<{
     size: {
-        sm: "space-y-4 text-xs";
-        md: "space-y-6 text-sm";
-        lg: "space-y-8 text-base";
+        sm: string;
+        md: string;
+        lg: string;
     };
-}, undefined, "relative space-y-6", {
-    size: {
-        sm: "space-y-4 text-xs";
-        md: "space-y-6 text-sm";
-        lg: "space-y-8 text-base";
-    };
-}, undefined, import("tailwind-variants").TVReturnTypeLike<{
-    size: {
-        sm: "space-y-4 text-xs";
-        md: "space-y-6 text-sm";
-        lg: "space-y-8 text-base";
-    };
-}, undefined>>;
+}, undefined, "relative space-y-6", undefined, undefined, undefined>;
 export type TimelineProps = VariantProps<typeof timelineVariants> & {
     items?: TimelineItem[];
     itemSnippet?: Snippet<[TimelineItem]>;

package/dist/components/elements/Tree.svelte.d.ts

@@ -10,20 +10,10 @@ export interface TreeNode {
 }
 export declare const treeVariants: import("tailwind-variants").TVReturnType<{
     size: {
-        sm: "text-xs";
-        md: "text-sm";
+        sm: string;
+        md: string;
     };
-}, undefined, "w-full select-none font-sans text-xs", {
-    size: {
-        sm: "text-xs";
-        md: "text-sm";
-    };
-}, undefined, import("tailwind-variants").TVReturnTypeLike<{
-    size: {
-        sm: "text-xs";
-        md: "text-sm";
-    };
-}, undefined>>;
+}, undefined, "w-full select-none font-sans text-xs", undefined, undefined, undefined>;
 export type TreeProps = VariantProps<typeof treeVariants> & {
     items?: TreeNode[];
     selectedId?: string;

package/dist/components/elements/VirtualList.svelte.d.ts

@@ -2,20 +2,10 @@ import { type VariantProps } from '../../utils/cn.js';
 import type { Snippet } from 'svelte';
 export declare const virtualListVariants: import("tailwind-variants").TVReturnType<{
     bordered: {
-        true: "border border-neutral-200 dark:border-neutral-800";
-        false: "border-0";
+        true: string;
+        false: string;
     };
-}, undefined, "relative w-full overflow-y-auto rounded-xl border border-neutral-200 bg-white dark:border-neutral-800 dark:bg-neutral-900", {
-    bordered: {
-        true: "border border-neutral-200 dark:border-neutral-800";
-        false: "border-0";
-    };
-}, undefined, import("tailwind-variants").TVReturnTypeLike<{
-    bordered: {
-        true: "border border-neutral-200 dark:border-neutral-800";
-        false: "border-0";
-    };
-}, undefined>>;
+}, undefined, "relative w-full overflow-y-auto rounded-xl border border-neutral-200 bg-white dark:border-neutral-800 dark:bg-neutral-900", undefined, undefined, undefined>;
 export type VirtualListProps<T> = VariantProps<typeof virtualListVariants> & {
     items: T[];
     itemHeight?: number;

package/dist/components/forms/Combobox.svelte.d.ts

@@ -10,38 +10,16 @@ export interface ComboboxOption {
 }
 export declare const comboboxVariants: import("tailwind-variants").TVReturnType<{
     size: {
-        sm: "h-9 px-3 text-xs gap-2";
-        md: "h-10 px-3.5 text-sm gap-2.5";
-        lg: "h-12 px-4 text-base gap-3";
+        sm: string;
+        md: string;
+        lg: string;
     };
     status: {
-        default: "border-neutral-300 focus:border-primary-500 focus:ring-primary-500/20 dark:border-neutral-700";
-        error: "border-rose-500 text-rose-900 focus:border-rose-500 focus:ring-rose-500/20 dark:text-rose-100";
-        success: "border-emerald-500 focus:border-emerald-500 focus:ring-emerald-500/20 dark:border-emerald-500";
+        default: string;
+        error: string;
+        success: string;
     };
-}, undefined, "flex w-full items-center justify-between rounded-lg border bg-white text-neutral-900 transition-all duration-150 focus:outline-none focus:ring-2 disabled:cursor-not-allowed disabled:opacity-50 dark:bg-neutral-900 dark:text-neutral-100", {
-    size: {
-        sm: "h-9 px-3 text-xs gap-2";
-        md: "h-10 px-3.5 text-sm gap-2.5";
-        lg: "h-12 px-4 text-base gap-3";
-    };
-    status: {
-        default: "border-neutral-300 focus:border-primary-500 focus:ring-primary-500/20 dark:border-neutral-700";
-        error: "border-rose-500 text-rose-900 focus:border-rose-500 focus:ring-rose-500/20 dark:text-rose-100";
-        success: "border-emerald-500 focus:border-emerald-500 focus:ring-emerald-500/20 dark:border-emerald-500";
-    };
-}, undefined, import("tailwind-variants").TVReturnTypeLike<{
-    size: {
-        sm: "h-9 px-3 text-xs gap-2";
-        md: "h-10 px-3.5 text-sm gap-2.5";
-        lg: "h-12 px-4 text-base gap-3";
-    };
-    status: {
-        default: "border-neutral-300 focus:border-primary-500 focus:ring-primary-500/20 dark:border-neutral-700";
-        error: "border-rose-500 text-rose-900 focus:border-rose-500 focus:ring-rose-500/20 dark:text-rose-100";
-        success: "border-emerald-500 focus:border-emerald-500 focus:ring-emerald-500/20 dark:border-emerald-500";
-    };
-}, undefined>>;
+}, undefined, "flex w-full items-center justify-between rounded-lg border bg-white text-neutral-900 transition-all duration-150 focus:outline-none focus:ring-2 disabled:cursor-not-allowed disabled:opacity-50 dark:bg-neutral-900 dark:text-neutral-100", undefined, undefined, undefined>;
 export type ComboboxProps = VariantProps<typeof comboboxVariants> & {
     id?: string;
     value?: string;