chaincss 2.0.6 → 2.1.0

package/dist/core/constants.d.ts

@@ -2,6 +2,7 @@
  * ChainCSS Constants
  * Shared constants used across the codebase
  */
+import type { ChainCSSConfig } from './types.js';
 export declare const VERSION = "2.0.0";
 export declare const NEVER_ATOMIC_PROPERTIES: string[];
 export declare const ALWAYS_ATOMIC_PROPERTIES: string[];
@@ -12,7 +13,7 @@ export declare const DEFAULT_CLASS_MAP_FILENAME = "class-map.json";
 export declare const DEFAULT_TYPES_FILENAME = "classes.d.ts";
 export declare const DEFAULT_CACHE_PATH = "./.chaincss-cache";
 export declare const CACHE_VERSION = "2.0.0";
-export declare const DEFAULT_ATOMIC_THRESHOLD = 3;
+export declare const DEFAULT_ATOMIC_THRESHOLD = 2;
 export declare const MIN_ATOMIC_THRESHOLD = 2;
 export declare const MAX_ATOMIC_THRESHOLD = 10;
 export declare const NAMING_SCHEMES: readonly ["hash", "readable"];
@@ -46,6 +47,17 @@ export declare const PATTERNS: {
     TOKEN_REFERENCE: RegExp;
     HOVER_STATE: RegExp;
     PSEUDO_CLASS: RegExp;
+    CSS_VARIABLE: RegExp;
+    SHORTHAND_PROPERTY: RegExp;
+    URL_REFERENCE: RegExp;
+    IMPORT_STATEMENT: RegExp;
+    FONT_FACE: RegExp;
+    STYLE_OBJECT: RegExp;
+    CHAIN_METHOD: RegExp;
+    HEX_COLOR: RegExp;
+    RGB_COLOR: RegExp;
+    RGBA_COLOR: RegExp;
+    HSL_COLOR: RegExp;
 };
 export declare const ERROR_MESSAGES: {
     FILE_NOT_FOUND: (file: string) => string;
@@ -71,45 +83,130 @@ export declare const DEFAULT_BREAKPOINTS: {
     tablet: string;
     desktop: string;
 };
-export declare const DEFAULT_CONFIG: {
-    tokens: {
-        enabled: boolean;
-        prefix: string;
+export declare const PERFORMANCE: {
+    readonly MAX_CONCURRENT_COMPILATIONS: 10;
+    readonly BATCH_SIZE: 20;
+    readonly CACHE_PRUNE_INTERVAL_MS: 3600000;
+    readonly CACHE_MAX_ENTRIES: 1000;
+    readonly MAX_MEMORY_USAGE_MB: 512;
+    readonly GC_THRESHOLD_MB: 400;
+    readonly COMPILE_TIMEOUT: 30000;
+    readonly FILE_WATCH_TIMEOUT: 5000;
+    readonly DEBOUNCE_WRITE_MS: 100;
+    readonly THROTTLE_COMPILE_MS: 50;
+};
+export declare const FRAMEWORK_CONFIGS: {
+    readonly react: {
+        readonly extension: ".jsx";
+        readonly componentTemplate: "React.FC";
+        readonly importReact: true;
+        readonly cssInJs: false;
+    };
+    readonly vue: {
+        readonly extension: ".vue";
+        readonly componentTemplate: "defineComponent";
+        readonly importReact: false;
+        readonly cssInJs: true;
+    };
+    readonly svelte: {
+        readonly extension: ".svelte";
+        readonly componentTemplate: "script";
+        readonly importReact: false;
+        readonly cssInJs: true;
     };
-    atomic: {
-        enabled: boolean;
-        threshold: number;
-        naming: string;
-        cache: boolean;
-        cachePath: string;
-        minify: boolean;
-        mode: string;
-        outputStrategy: string;
-        alwaysAtomic: string[];
-        neverAtomic: string[];
-        verbose: boolean;
+    readonly solid: {
+        readonly extension: ".jsx";
+        readonly componentTemplate: "Component";
+        readonly importReact: false;
+        readonly cssInJs: false;
+    };
+    readonly angular: {
+        readonly extension: ".ts";
+        readonly componentTemplate: "Component";
+        readonly importReact: false;
+        readonly cssInJs: true;
+    };
+};
+export type Framework = keyof typeof FRAMEWORK_CONFIGS;
+export declare const ENVIRONMENT_PRESETS: {
+    readonly development: {
+        readonly atomic: {
+            readonly naming: NamingScheme;
+            readonly minify: false;
+            readonly verbose: true;
+            readonly cache: true;
+        };
+        readonly output: {
+            readonly minify: false;
+            readonly sourceComments: true;
+        };
+        readonly debug: true;
+        readonly timeline: true;
+        readonly sourceComments: true;
+        readonly verbose: true;
     };
-    prefixer: {
-        enabled: boolean;
-        mode: PrefixerMode;
-        browsers: string[];
-        sourceMap: boolean;
-        sourceMapInline: boolean;
+    readonly production: {
+        readonly atomic: {
+            readonly naming: NamingScheme;
+            readonly minify: true;
+            readonly verbose: false;
+            readonly cache: true;
+        };
+        readonly output: {
+            readonly minify: true;
+            readonly sourceComments: false;
+        };
+        readonly debug: false;
+        readonly timeline: false;
+        readonly sourceComments: false;
+        readonly verbose: false;
     };
-    output: {
-        cssFile: string;
-        classMapFile: string;
-        typesFile: string;
-        minify: boolean;
-        generateGlobalCSS: boolean;
+    readonly test: {
+        readonly atomic: {
+            readonly naming: NamingScheme;
+            readonly minify: false;
+            readonly verbose: false;
+            readonly cache: false;
+        };
+        readonly output: {
+            readonly minify: false;
+            readonly sourceComments: true;
+        };
+        readonly debug: true;
+        readonly timeline: true;
+        readonly sourceComments: true;
+        readonly verbose: false;
     };
-    debug: boolean;
-    sourceComments: boolean;
-    timeline: boolean;
-    framework: "auto";
-    namespace: string;
-    verbose: boolean;
 };
+export declare const VALIDATION: {
+    readonly MAX_SELECTOR_LENGTH: 100;
+    readonly MAX_STYLE_RULES: 10000;
+    readonly MAX_NESTING_DEPTH: 10;
+    readonly CLASS_NAME: {
+        readonly MIN_LENGTH: 1;
+        readonly MAX_LENGTH: 50;
+        readonly PATTERN: RegExp;
+        readonly RESERVED: readonly ["chain", "css", "style", "global", "atomic"];
+    };
+    readonly PROPERTY_VALUE: {
+        readonly MAX_LENGTH: 5000;
+        readonly ALLOWED_UNITS: readonly ["px", "rem", "em", "%", "vw", "vh", "deg", "rad", "ms", "s"];
+    };
+    readonly BREAKPOINT: {
+        readonly MIN_VALUE: 0;
+        readonly MAX_VALUE: 10000;
+        readonly ALLOWED_UNITS: readonly ["px", "rem", "em", "vw"];
+    };
+};
+export declare const MEMORY: {
+    readonly CACHE_PRUNE_SIZE: number;
+    readonly MAX_STRING_BUFFER: number;
+    readonly BATCH_SIZE: 100;
+    readonly CLEANUP_INTERVAL_MS: 300000;
+    readonly CACHE_CHECK_INTERVAL_MS: 60000;
+    readonly MEMORY_CHECK_INTERVAL_MS: 30000;
+};
+export declare const DEFAULT_CONFIG: ChainCSSConfig;
 export declare const RUNTIME: {
     STYLE_ID_PREFIX: string;
     CLASS_NAME_PREFIX: string;
@@ -126,4 +223,8 @@ export declare const PROD: {
     COMPRESSION_LEVEL: number;
     SOURCE_MAP_COMMENT: string;
 };
-//# sourceMappingURL=constants.d.ts.map
+export declare function isNamingScheme(value: unknown): value is NamingScheme;
+export declare function isAtomicMode(value: unknown): value is AtomicMode;
+export declare function isOutputStrategy(value: unknown): value is OutputStrategy;
+export declare function isPrefixerMode(value: unknown): value is PrefixerMode;
+export declare function isFramework(value: unknown): value is Framework;

package/dist/core/smart-chain.d.ts

@@ -0,0 +1,3 @@
+export declare function smartChain(useTokens?: boolean): any;
+export declare const buildChain: (useTokens?: boolean) => import("../index.js").Chain;
+export declare const runtimeChain: (useTokens?: boolean) => any;

package/dist/core/types.d.ts

@@ -12,7 +12,8 @@ export interface StyleDefinition {
     _generateComponent?: boolean;
     _framework?: 'react' | 'vue' | 'svelte' | 'solid' | 'auto';
     _propsDefinition?: Record<string, any>;
-    [cssProperty: string]: any;
+    /** Explicit bucket for custom CSS properties to avoid index signature issues */
+    customProperties?: Record<string, string | number>;
 }
 export interface AtRule {
     type: 'media' | 'keyframes' | 'font-face' | 'supports' | 'container' | 'layer' | 'counter-style' | 'property';
@@ -39,22 +40,59 @@ export interface AtomicClass {
     prop: string;
     value: string;
     usageCount: number;
+    sourceFile?: string;
+    hash?: string;
+    rules?: string;
 }
 export interface CompileResult {
     css: string;
     classMap: Record<string, string>;
     atomicClasses: AtomicClass[];
-    stats: {
-        totalStyles: number;
-        atomicStyles: number;
-        uniqueProperties: number;
-        savings: string;
-    };
+    stats: CompileStats;
+    warnings?: string[];
+    errors?: string[];
+}
+export interface CompileStats {
+    totalStyles: number;
+    atomicStyles: number;
+    uniqueProperties: number;
+    savings: string;
+    cacheHitRate?: number;
+    compileTime?: number;
+}
+export interface AtomicOptimizerOptions {
+    enabled: boolean;
+    threshold: number;
+    naming: 'hash' | 'readable';
+    cache: boolean;
+    cachePath: string;
+    minify: boolean;
+    mode: 'standard' | 'atomic' | 'hybrid';
+    outputStrategy: 'component-first' | 'utility-first';
+    alwaysAtomic: string[];
+    neverAtomic: string[];
+    verbose: boolean;
+}
+export interface TokenContext {
+    tokens: Record<string, any>;
+    prefix: string;
+    transform?: (value: any) => any;
 }
 export interface ChainCSSConfig {
+    inputs?: string[];
+    output?: {
+        cssFile?: string;
+        classMapFile?: string;
+        typesFile?: string;
+        minify?: boolean;
+        generateGlobalCSS?: boolean;
+        outputDir?: string;
+    };
     tokens?: {
         enabled?: boolean;
         prefix?: string;
+        transform?: (value: any) => any;
+        tokens?: Record<string, any>;
     };
     atomic?: {
         enabled?: boolean;
@@ -68,25 +106,94 @@ export interface ChainCSSConfig {
         alwaysAtomic?: string[];
         neverAtomic?: string[];
         verbose?: boolean;
+        maxAtomicClasses?: number;
+        reuseThreshold?: number;
     };
     prefixer?: {
         enabled?: boolean;
         mode?: 'auto' | 'full' | 'lightweight';
         browsers?: string[];
         sourceMap?: boolean;
+        sourceMapInline?: boolean;
+        remove?: boolean;
     };
-    output?: {
-        cssFile?: string;
-        classMapFile?: string;
-        typesFile?: string;
-        minify?: boolean;
-        generateGlobalCSS?: boolean;
-    };
+    cachePath?: string;
+    cacheEnabled?: boolean;
+    persistentCachePath?: string;
+    cacheMaxAgeDays?: number;
+    cacheMaxSizeMB?: number;
     timeline?: boolean;
     sourceComments?: boolean;
     debug?: boolean;
+    sourceMap?: boolean;
+    watch?: boolean;
+    hmr?: boolean;
     breakpoints?: Record<string, string>;
+    framework?: 'react' | 'vue' | 'svelte' | 'solid' | 'angular' | 'auto';
+    esmOnly?: boolean;
     namespace?: string;
     verbose?: boolean;
+    silent?: boolean;
+    profiling?: boolean;
+    classNameGenerator?: (name: string, options?: any) => string;
+    plugins?: ChainCSSPlugin[];
+    minifySelectors?: boolean;
+    extractCritical?: boolean;
+}
+export interface ChainCSSPlugin {
+    name: string;
+    setup?: (compiler: any) => void;
+    transform?: (code: string, id: string) => string | null;
+    transformCSS?: (css: string, filePath: string) => string;
+    transformAST?: (ast: any) => any;
+}
+export interface CompileOptions {
+    writeFiles?: boolean;
+    minify?: boolean;
+    sourceMap?: boolean;
+    verbose?: boolean;
+    watch?: boolean;
+}
+export interface ScanResult {
+    files: string[];
+    styles: StyleDefinition[];
+    errors: Error[];
+    warnings: string[];
+}
+export interface CacheEntry {
+    hash: string;
+    timestamp: number;
+    result: CompileResult;
+    dependencies: string[];
+    accessCount: number;
+}
+export interface TokenValue {
+    value: any;
+    description?: string;
+    deprecated?: boolean;
+    aliases?: string[];
+}
+export interface DesignTokens {
+    colors: Record<string, TokenValue | string>;
+    spacing: Record<string, TokenValue | string>;
+    typography: Record<string, TokenValue | string>;
+    breakpoints: Record<string, TokenValue | string>;
+    animations: Record<string, TokenValue | any>;
+    [key: string]: any;
+}
+export interface BreakpointConfig {
+    name: string;
+    minWidth?: number;
+    maxWidth?: number;
+    query: string;
+    priority?: number;
 }
-//# sourceMappingURL=types.d.ts.map
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type RequiredKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;
+export type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export declare function isStyleDefinition(value: any): value is StyleDefinition;
+export declare function isAtRule(value: any): value is AtRule;
+export declare function isAtomicClass(value: any): value is AtomicClass;
+export declare function isCompileResult(value: any): value is CompileResult;

package/dist/core/utils.d.ts

@@ -1,37 +1,154 @@
 /**
- * Generate a hash for a string
+ * 1. RE-EXPORTS
+ * Re-exporting everything from common-utils ensures the Compiler
+ * can still find processStyleObject, resolveToken, and kebabCase
+ * without changing its import statements.
+ */
+export * from './common-utils.js';
+/**
+ * 2. HASHING & NAMING (Node/Compiler Only)
  */
 export declare function hashString(str: string, length?: number): string;
+export declare function generateClassName(styleId: string, naming?: 'hash' | 'readable'): string;
+export declare function generateAtomicClassName(prop: string, value: string, type?: 'atomic' | 'utility'): string;
+export declare function generateComponentClassName(componentName: string, hash?: string): string;
+/**
+ * 3. OBJECT MANIPULATION
+ */
+export declare function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T;
+export declare function deepClone<T>(obj: T): T;
+export declare function deepEqual(obj1: any, obj2: any): boolean;
+export declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+export declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * 4. FILE SYSTEM UTILS (Node Only)
+ */
+export declare function ensureDir(dir: string): void;
+export declare function writeFile(filePath: string, content: string): void;
+export declare function readFile(filePath: string): string;
+export declare function fileExists(filePath: string): boolean;
+export declare function getFileExtension(filePath: string): string;
+export declare function getBaseName(filePath: string): string;
+export declare function getDirName(filePath: string): string;
+export declare function resolvePath(filePath: string): string;
+export declare function isDirectory(filePath: string): boolean;
+export declare function getAllFiles(dir: string, pattern?: RegExp): string[];
 /**
- * Convert camelCase to kebab-case
+ * 5. FORMATTING
  */
+export declare function formatCSS(css: string, minify?: boolean): string;
+export declare function formatJS(code: string, minify?: boolean): string;
 export declare function kebabCase(str: string): string;
+export declare function camelCase(str: string): string;
+export declare function pascalCase(str: string): string;
+export declare function snakeCase(str: string): string;
 /**
- * Generate a unique class name
+ * 6. STRING UTILITIES
  */
-export declare function generateClassName(styleId: string, naming?: 'hash' | 'readable'): string;
+export declare function truncate(str: string, length: number, suffix?: string): string;
+export declare function indent(str: string, level?: number, char?: string): string;
+export declare function stripIndent(str: string): string;
 /**
- * Deep merge objects
+ * 7. ARRAY UTILITIES
  */
-export declare function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T;
+export declare function unique<T>(arr: T[], key?: keyof T): T[];
+export declare function chunk<T>(arr: T[], size: number): T[][];
+export declare function groupBy<T>(arr: T[], key: keyof T): Record<string, T[]>;
 /**
- * Ensure directory exists
+ * 8. PERFORMANCE UTILITIES
  */
-export declare function ensureDir(dir: string): void;
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, delay: number): (...args: Parameters<T>) => void;
+export declare function throttle<T extends (...args: any[]) => any>(fn: T, limit: number): (...args: Parameters<T>) => void;
 /**
- * Write file with parent directory creation
+ * 9. ERROR HANDLING
  */
-export declare function writeFile(filePath: string, content: string): void;
+export declare class ChainCSSError extends Error {
+    code: string;
+    details?: any;
+    constructor(message: string, code?: string, details?: any);
+}
+export declare function tryOrWarn<T>(fn: () => T, defaultValue: T, message?: string): T;
+export declare function tryOrThrow<T>(fn: () => T, errorMessage?: string): T;
 /**
- * Format CSS (minify or beautify)
+ * 10. LOGGING UTILITIES (Node Only)
  */
-export declare function formatCSS(css: string, minify?: boolean): string;
+declare const LOG_LEVELS: {
+    debug: number;
+    info: number;
+    warn: number;
+    error: number;
+    silent: number;
+};
+export declare function setLogLevel(level: keyof typeof LOG_LEVELS): void;
+export declare function logDebug(message: string, ...args: any[]): void;
+export declare function logInfo(message: string, ...args: any[]): void;
+export declare function logWarn(message: string, ...args: any[]): void;
+export declare function logError(message: string, ...args: any[]): void;
 /**
- * Get file extension
+ * 11. MEMORY MANAGEMENT
  */
-export declare function getFileExtension(filePath: string): string;
+export declare function getMemoryUsage(): {
+    rss: number;
+    heapTotal: number;
+    heapUsed: number;
+    external: number;
+};
+export declare function formatBytes(bytes: number): string;
 /**
- * Get base name without extension
+ * 12. VALIDATION UTILITIES
  */
-export declare function getBaseName(filePath: string): string;
-//# sourceMappingURL=utils.d.ts.map
+export declare function isValidSelector(selector: string): boolean;
+export declare function isValidClassName(className: string): boolean;
+export declare function isValidCSSProperty(prop: string): boolean;
+/**
+ * 13. EXPORTS
+ */
+declare const _default: {
+    hashString: typeof hashString;
+    generateClassName: typeof generateClassName;
+    generateAtomicClassName: typeof generateAtomicClassName;
+    generateComponentClassName: typeof generateComponentClassName;
+    deepMerge: typeof deepMerge;
+    deepClone: typeof deepClone;
+    deepEqual: typeof deepEqual;
+    pick: typeof pick;
+    omit: typeof omit;
+    ensureDir: typeof ensureDir;
+    writeFile: typeof writeFile;
+    readFile: typeof readFile;
+    fileExists: typeof fileExists;
+    getFileExtension: typeof getFileExtension;
+    getBaseName: typeof getBaseName;
+    getDirName: typeof getDirName;
+    resolvePath: typeof resolvePath;
+    isDirectory: typeof isDirectory;
+    getAllFiles: typeof getAllFiles;
+    formatCSS: typeof formatCSS;
+    formatJS: typeof formatJS;
+    kebabCase: typeof kebabCase;
+    camelCase: typeof camelCase;
+    pascalCase: typeof pascalCase;
+    snakeCase: typeof snakeCase;
+    truncate: typeof truncate;
+    indent: typeof indent;
+    stripIndent: typeof stripIndent;
+    unique: typeof unique;
+    chunk: typeof chunk;
+    groupBy: typeof groupBy;
+    debounce: typeof debounce;
+    throttle: typeof throttle;
+    ChainCSSError: typeof ChainCSSError;
+    tryOrWarn: typeof tryOrWarn;
+    tryOrThrow: typeof tryOrThrow;
+    setLogLevel: typeof setLogLevel;
+    logDebug: typeof logDebug;
+    logInfo: typeof logInfo;
+    logWarn: typeof logWarn;
+    logError: typeof logError;
+    getMemoryUsage: typeof getMemoryUsage;
+    formatBytes: typeof formatBytes;
+    isValidSelector: typeof isValidSelector;
+    isValidClassName: typeof isValidClassName;
+    isValidCSSProperty: typeof isValidCSSProperty;
+};
+export default _default;

package/dist/index.d.ts

@@ -1,13 +1,57 @@
+/**
+ * ChainCSS - Zero-runtime CSS-in-JS with Atomic CSS optimization
+ * @packageDocumentation
+ */
+export { smartChain, smartChain as chainV3, buildChain, runtimeChain } from './core/smart-chain.js';
+export { autoDetector, AutoDetector, type ValueType, type Mode } from './core/auto-detector.js';
+export { useSmartStyles, createSmartComponent, withSmartStyles } from './runtime/auto-hooks.js';
 export { ChainCSSCompiler, compileChainCSS } from './core/compiler.js';
-export { $, recipe, createTokens, configureAtomic, tokens } from './compiler/btt.js';
+export { chain, chain as $, // Alias for convenience
+recipe, // Variant system
+createTokens, // Design token creation
+configureAtomic, // Atomic CSS configuration
+tokens, // Default token instance
+enableDebug, // Debug mode
+setBreakpoints, // Responsive breakpoints
+enableTimeline, // Style timeline tracking
+getStyleHistory, // Timeline history
+getStyleChanges, // Timeline changes
+getStyleDiff, // Timeline diff
+exportTimeline, // Export timeline
+clearTimeline } from './compiler/btt.js';
 export { AtomicOptimizer } from './compiler/atomic-optimizer.js';
 export { ChainCSSPrefixer } from './compiler/prefixer.js';
-export { DesignTokens, createTokens as createTokensUtil, responsive } from './compiler/tokens.js';
+export { DesignTokens, createTokens as createDesignTokens } from './compiler/tokens.js';
 export { createThemeContract, validateTheme, createTheme, Theme } from './compiler/theme-contract.js';
 export { CacheManager } from './compiler/cache-manager.js';
-export type { StyleDefinition, AtRule, NestedRule, ThemeBlock } from './compiler/btt.js';
-export type { AtomicClass, AtomicOptimizerOptions, AtomicOptimizerStats } from './compiler/atomic-optimizer.js';
-export type { PrefixerConfig } from './compiler/prefixer.js';
-export type { ThemeContract, ThemeTokens, TokensStructure } from './compiler/theme-contract.js';
-export type { ChainCSSConfig, CompileResult } from './core/types.js';
-//# sourceMappingURL=index.d.ts.map
+export { PersistentCache } from './compiler/content-addressable-cache.js';
+export { shorthandMap, macros, handleShorthand, isShorthand, expandShorthand, getAvailableShorthands } from './compiler/shorthands.js';
+export { helpers } from './compiler/helpers.js';
+export { animationPresets, createAnimation, getAnimationPreset, hasAnimationPreset, getAnimationPresetNames } from './compiler/animations.js';
+export { getSuggestion, getSuggestions, getPropertySuggestion, getShorthandSuggestion } from './compiler/suggestions.js';
+export type { StyleDefinition, AtRule, NestedRule, ThemeBlock, Recipe, RecipeOptions, ChainObject } from './compiler/btt.js';
+export type { AtomicClass, AtomicOptimizerOptions, AtomicOptimizerStats, ComponentClassMapEntry, OptimizeResult } from './compiler/atomic-optimizer.js';
+export type { PrefixerConfig, PrefixerResult } from './compiler/prefixer.js';
+export type { ThemeContract, ThemeTokens } from './compiler/theme-contract.js';
+export type { TokensStructure } from './compiler/tokens.js';
+export type { ChainCSSConfig, CompileResult, ChainCSSPlugin } from './core/types.js';
+export type { Chain } from './compiler/Chain.js';
+export type { AnimationConfig, KeyframeDefinition } from './compiler/animations.js';
+export type { BreakpointsMap, ResponsiveStyle } from './compiler/breakpoints.js';
+export * from './runtime/index.js';
+export declare const VERSION = "3.0.0";
+import { chain } from './compiler/Chain.js';
+export default chain;
+export type { Properties as CSSProperties } from 'csstype';
+export type TokenValue<T = string> = T | `$${string}`;
+export type ResponsiveValue<T> = T | {
+    base?: T;
+    sm?: T;
+    md?: T;
+    lg?: T;
+    xl?: T;
+    '2xl'?: T;
+    [key: string]: T | undefined;
+};
+export type StyleWithTokens<T = any> = T | ((tokens: DesignTokens) => T);
+import { DesignTokens } from './compiler/tokens.js';