rainbowindex 0.1.4 → 0.2.0

package/dist/browser.d.ts

@@ -1,1323 +1,5 @@
-/**
- * Rainbow Index AST Types
- *
- * Defines the Abstract Syntax Tree structure for CSS parsing and generation.
- */
-/** Source location tracking for source maps */
-interface Source {
-    file: string | null;
-    code: string;
-}
-type SourceLocation = [source: Source, start: number, end: number];
-/** CSS Style Rule: selector { declarations } */
-interface StyleRule {
-    kind: "rule";
-    selector: string;
-    nodes: AstNode[];
-    src?: SourceLocation;
-    dst?: SourceLocation;
-}
-/** CSS At-Rule: @name params { nodes } */
-interface AtRule {
-    kind: "at-rule";
-    name: string;
-    params: string;
-    nodes: AstNode[];
-    src?: SourceLocation;
-    dst?: SourceLocation;
-}
-/** CSS Declaration: property: value */
-interface Declaration {
-    kind: "declaration";
-    property: string;
-    value: string | undefined;
-    important: boolean;
-    src?: SourceLocation;
-    dst?: SourceLocation;
-}
-/** CSS Comment */
-interface Comment {
-    kind: "comment";
-    value: string;
-    src?: SourceLocation;
-    dst?: SourceLocation;
-}
-/** Internal context node for tracking metadata during compilation */
-interface Context {
-    kind: "context";
-    context: Record<string, string | boolean>;
-    nodes: AstNode[];
-}
-/** At-root node for hoisting content outside current rule */
-interface AtRoot {
-    kind: "at-root";
-    nodes: AstNode[];
-}
-/** Union of all AST node types */
-type AstNode = StyleRule | AtRule | Declaration | Comment | Context | AtRoot;
+export { C as ColorDefinition, a as CompilationContext, b as CompilationSnapshot, D as DEFAULT_TEXT_SIZES, F as FluidConfig, T as TextSize, c as Theme, d as createCompilationContext, e as createRi, f as defaultTheme, g as finalizeCompilationContext, r as registerColorNames, h as registerCustomFontFamilies, i as registerCustomTextSizes, j as registerCustomUtility, k as ri, s as safelist } from './safelist-DRk1XXxi.js';
 
-/**
- * Source Map Generator
- *
- * Generates source maps in the standard v3 format with VLQ encoding.
- * Also provides ECMA-426 decoded source map types for structured access.
- *
- * ## Pipeline Stages and Source Map Flow
- *
- * The Rainbow Index build pipeline generates source maps through multiple stages:
- *
- * 1. **Parser** (parse.ts)
- *    - Input: Raw CSS/Rainbow syntax
- *    - Output: AST with `src[]` location metadata
- *    - Source Map: Implicit via SourceLocation tuples on nodes
- *
- * 2. **Compiler** (compile.ts)
- *    - Input: AST with `src[]`
- *    - Output: Transformed AST with `dst[]` added
- *    - Source Map: `createSourceMap({ ast })` generates DecodedSourceMap
- *
- * 3. **Printer** (print.ts)
- *    - Input: Compiled AST
- *    - Output: CSS string
- *    - Source Map: `generateSourceMap()` produces v3 SourceMap
- *
- * 4. **Optimizer** (optimize.ts in @rainbowindex/node)
- *    - Input: CSS string + optional source map
- *    - Output: Optimized CSS + composed source map
- *    - Source Map: Uses `@jridgewell/remapping` for composition
- *
- * ## Composition Functions
- *
- * - `chainSourceMaps(original, transformed)`: Chains two sequential maps.
- *   Maps from final output -> intermediate -> original source.
- *
- * - `mergeSourceMaps(maps[])`: Combines maps from parallel sources.
- *   Used when concatenating CSS from multiple input files.
- *
- * - `@jridgewell/remapping`: External library used in optimizer for
- *   composing maps through Lightning CSS and MagicString transformations.
- *
- * ## Example Usage
- *
- * ```typescript
- * // Chain maps through a 3-stage pipeline
- * const map1 = chainSourceMaps(parseMap, compileMap);
- * const finalMap = chainSourceMaps(map1, optimizeMap);
- *
- * // Merge maps from multiple input files
- * const bundleMap = mergeSourceMaps([resetMap, utilsMap, componentsMap]);
- * ```
- */
+declare function browserEntryUnavailable(): never;
 
-/**
- * Standard source map format (JSON v3 specification).
- * @see https://sourcemaps.info/spec.html
- */
-interface SourceMap {
-    version: 3;
-    file?: string;
-    sourceRoot?: string;
-    sources: string[];
-    sourcesContent: (string | null)[];
-    names: string[];
-    mappings: string;
-}
-
-/**
- * AST Printer
- *
- * Converts AST nodes back to CSS strings.
- * Optimized following tailwindcss patterns:
- * - Pre-computed indentation array
- * - Separate CSS generation from source map tracking
- * - ECMA-426 decoded source maps with deferred VLQ encoding
- * - Binary search position lookups via line tables
- */
-
-interface PrintOptions {
-    /** Use minified output (no whitespace) */
-    minify?: boolean;
-    /** Indentation string (default: "  ") */
-    indent?: string;
-    /** Generate source map */
-    sourceMap?: boolean;
-    /**
-     * Return decoded source map (ECMA-426 format) instead of V3.
-     * This is faster as it skips VLQ encoding.
-     * Use encodeSourceMap() to convert to V3 when needed.
-     */
-    decodedSourceMap?: boolean;
-    /** Output file name for source map */
-    file?: string;
-}
-/**
- * Convert AST to CSS string.
- */
-declare function print(ast: AstNode[], options?: PrintOptions): string;
-/**
- * Minify CSS by removing whitespace and comments.
- */
-declare function minify(css: string): string;
-
-/**
- * Candidate Types
- *
- * Defines the structure of parsed utility class candidates.
- * A candidate like "hover:bg-red-500/75" is parsed into its constituent parts.
- */
-/** A named value like "red-500" in "bg-red-500" */
-interface NamedValue {
-    kind: "named";
-    /** The value name, e.g., "red-500" */
-    value: string;
-    /** Fraction part if present, e.g., "1/2" in "w-1/2" */
-    fraction: string | null;
-}
-/** An arbitrary value like "[#ff0000]" in "bg-[#ff0000]" */
-interface ArbitraryValue {
-    kind: "arbitrary";
-    /** The raw value inside brackets */
-    value: string;
-    /** Optional data type hint, e.g., "color" in "bg-[color:#ff0000]" */
-    dataType: string | null;
-}
-type CandidateValue = NamedValue | ArbitraryValue;
-/** A named modifier like "75" in "bg-red-500/75" */
-interface NamedModifier {
-    kind: "named";
-    value: string;
-}
-/** An arbitrary modifier like "[0.5]" in "bg-red-500/[0.5]" */
-interface ArbitraryModifier {
-    kind: "arbitrary";
-    value: string;
-    dashedIdent: string | null;
-}
-type CandidateModifier = NamedModifier | ArbitraryModifier;
-/** A static variant like "hover" */
-interface StaticVariant {
-    kind: "static";
-    root: string;
-}
-/** A functional variant like "aria-disabled" or "md" */
-interface FunctionalVariant {
-    kind: "functional";
-    root: string;
-    value: CandidateValue | null;
-    modifier: CandidateModifier | null;
-}
-/** An arbitrary variant like "[&_p]" */
-interface ArbitraryVariant {
-    kind: "arbitrary";
-    selector: string;
-    relative: boolean;
-}
-/** A compound variant like "group-hover" */
-interface CompoundVariant {
-    kind: "compound";
-    root: string;
-    modifier: CandidateModifier | null;
-    variant: Variant;
-}
-type Variant = StaticVariant | FunctionalVariant | ArbitraryVariant | CompoundVariant;
-/** A static candidate like "flex" or "hidden" */
-interface StaticCandidate {
-    kind: "static";
-    /** The utility name */
-    root: string;
-    /** Applied variants in order */
-    variants: Variant[];
-    /** Whether !important is applied */
-    important: boolean;
-    /** Original raw string */
-    raw: string;
-}
-/** A functional candidate like "bg-red-500" or "p-4" */
-interface FunctionalCandidate {
-    kind: "functional";
-    /** The utility prefix, e.g., "bg" */
-    root: string;
-    /** The value part */
-    value: CandidateValue | null;
-    /** The modifier part (e.g., opacity) */
-    modifier: CandidateModifier | null;
-    /** Applied variants in order */
-    variants: Variant[];
-    /** Whether !important is applied */
-    important: boolean;
-    /** Original raw string */
-    raw: string;
-}
-/** An arbitrary property candidate like "[color:red]" */
-interface ArbitraryCandidate {
-    kind: "arbitrary";
-    /** CSS property name */
-    property: string;
-    /** CSS value */
-    value: string;
-    /** The modifier part */
-    modifier: CandidateModifier | null;
-    /** Applied variants in order */
-    variants: Variant[];
-    /** Whether !important is applied */
-    important: boolean;
-    /** Original raw string */
-    raw: string;
-}
-type Candidate = StaticCandidate | FunctionalCandidate | ArbitraryCandidate;
-
-/**
- * Theme System
- *
- * Manages CSS custom property definitions and resolution.
- * Handles @theme declarations and provides lookups for utilities.
- */
-
-declare const enum ThemeOptions {
-    /** No special options */
-    NONE = 0,
-    /** Inline in :root (not registered via @property) */
-    INLINE = 1,
-    /** Reference only - don't output the declaration */
-    REFERENCE = 2,
-    /** Default value that can be overridden */
-    DEFAULT = 4,
-    /** Static value that cannot use var() */
-    STATIC = 8,
-    /** Mark as used (for tree-shaking) */
-    USED = 16
-}
-/** Theme keys always start with -- */
-type ThemeKey = `--${string}`;
-interface ThemeEntry {
-    value: string;
-    options: ThemeOptions;
-    src?: SourceLocation;
-}
-declare class Theme {
-    /** Stored theme values */
-    private values;
-    /** Keyframe animations */
-    private keyframes;
-    /** Theme prefix (e.g., "ri" for --ri-*) */
-    prefix: string | null;
-    /** Track which variables are used */
-    private usedVariables;
-    /**
-     * Create a new Theme with the same values/keyframes.
-     * Used to speed up cold starts without sharing mutation state.
-     */
-    clone(): Theme;
-    /**
-     * Add a theme value.
-     */
-    add(key: string, value: string, options?: ThemeOptions, src?: SourceLocation): void;
-    /**
-     * Get a raw theme value by key.
-     */
-    get(key: string): string | null;
-    /**
-     * Check if a theme key exists.
-     */
-    has(key: string): boolean;
-    /**
-     * Resolve a candidate value against theme keys.
-     *
-     * For example, resolve("red-500", ["--background-color", "--color"])
-     * will look for --background-color-red-500 or --color-red-500.
-     *
-     * Returns a var() reference or the inline value based on ThemeOptions:
-     * - STATIC: always inlines the value (no var())
-     * - INLINE: inlines the value (no var())
-     * - REFERENCE: returns var() with fallback value
-     * - Default: returns var() without fallback
-     *
-     * When a prefix is set, applies it to the emitted var() key.
-     */
-    resolve(candidateValue: string | null, themeKeys: ThemeKey[]): string | null;
-    /**
-     * Get all values in a namespace.
-     * E.g., namespace("--color") returns all --color-* values.
-     */
-    namespace(namespace: ThemeKey): Map<string | null, string>;
-    /**
-     * Add a keyframe animation.
-     */
-    addKeyframes(name: string, keyframes: AtRule): void;
-    /**
-     * Get a keyframe animation.
-     */
-    getKeyframes(name: string): AtRule | null;
-    /**
-     * Get all keyframe animations.
-     */
-    getAllKeyframes(): Map<string, AtRule>;
-    /**
-     * Mark a variable as used.
-     */
-    markUsed(key: string): void;
-    /**
-     * Check if a variable has been used.
-     */
-    isUsed(key: string): boolean;
-    /**
-     * Get all theme entries (for output generation).
-     */
-    entries(): IterableIterator<[string, ThemeEntry]>;
-    /**
-     * Get all used theme entries.
-     */
-    usedEntries(): [string, ThemeEntry][];
-    /**
-     * Create a child theme that inherits from this one.
-     */
-    child(): Theme;
-    /**
-     * Merge another theme into this one.
-     */
-    merge(other: Theme): void;
-}
-
-/**
- * Utility Trie
- *
- * A segment-based trie data structure for O(k) utility prefix matching.
- * Instead of character-by-character traversal, we split by dashes and
- * traverse segment-by-segment, reducing Map lookups significantly.
- *
- * Example:
- * - "bg-gradient-to-r-500" with right-to-left: 5 Map lookups
- * - "bg-gradient-to-r-500" with segment trie: 5 segment lookups (same, but left-to-right)
- *
- * The key advantage is we find the LONGEST match in one forward pass,
- * without needing to backtrack.
- */
-/**
- * A segment-based trie optimized for finding the longest matching utility prefix.
- * Stores dash-separated segments instead of individual characters.
- */
-declare class UtilityTrie {
-    private root;
-    private size;
-    /**
-     * Insert a utility name into the trie.
-     * @param utility - The utility name (e.g., "bg", "bg-gradient-to")
-     */
-    insert(utility: string): void;
-    /**
-     * Check if a utility exists in the trie.
-     * @param utility - The utility name to check
-     */
-    has(utility: string): boolean;
-    /**
-     * Find the longest matching utility prefix in the input string.
-     * Uses inline segment extraction to avoid array allocations.
-     *
-     * @param input - The candidate string (e.g., "bg-red-500")
-     * @returns [root, value] tuple if found, null if no match or entire string is a utility
-     *
-     * @example
-     * ```ts
-     * trie.insert("bg");
-     * trie.insert("bg-gradient-to");
-     *
-     * trie.findLongestPrefix("bg-red-500")
-     * // Returns ["bg", "red-500"]
-     *
-     * trie.findLongestPrefix("bg-gradient-to-r")
-     * // Returns ["bg-gradient-to", "r"]
-     *
-     * trie.findLongestPrefix("flex")
-     * // Returns null (entire string is utility or no match)
-     * ```
-     */
-    findLongestPrefix(input: string): [string, string] | null;
-    /**
-     * Find all utilities that match as prefixes of the input.
-     * Useful for debugging and testing.
-     *
-     * @param input - The candidate string
-     * @returns Array of matching utility prefixes
-     */
-    findAllPrefixes(input: string): string[];
-    /**
-     * Get the number of utilities in the trie.
-     */
-    getSize(): number;
-    /**
-     * Clear all utilities from the trie.
-     */
-    clear(): void;
-}
-
-/**
- * Utilities Registry
- *
- * Manages utility definitions and compilation.
- * Utilities are functions that convert candidates to CSS declarations.
- */
-
-/** Options for utility registration */
-interface UtilityOptions {
-    /** Data types this utility accepts (for Intellisense) */
-    types?: string[];
-}
-/** Compile function for static utilities */
-type StaticCompileFn = (candidate: StaticCandidate, theme: Theme) => AstNode[] | null | undefined;
-/** Compile function for functional utilities */
-type FunctionalCompileFn = (candidate: FunctionalCandidate, theme: Theme) => AstNode[] | null | undefined;
-/**
- * Stored utility definition.
- *
- * PERFORMANCE: All fields are always present (never undefined) to ensure
- * consistent V8 hidden class shapes. This allows the engine to optimize
- * property access without polymorphic inline caches.
- */
-interface UtilityDef {
-    kind: "static" | "functional";
-    /** Static compile function (null for functional utilities) */
-    staticFn: StaticCompileFn | null;
-    /** Functional compile function (null for static utilities) */
-    functionalFn: FunctionalCompileFn | null;
-    /** Utility options (null if none) */
-    options: UtilityOptions | null;
-}
-/** Suggestion group for Intellisense */
-interface SuggestionGroup {
-    name: string;
-    values: string[];
-}
-declare class Utilities {
-    /** Registered utilities by name */
-    private utilities;
-    /** Completion suggestions by utility name */
-    private completions;
-    /** Trie for O(n) utility prefix lookup (lazily built) */
-    private _trie;
-    /** Whether native utility set has been loaded */
-    private _nativeLoaded;
-    /** Cache for findRoot results (per utilities instance) */
-    private _findRootCache;
-    /**
-     * Get or build the utility trie for fast prefix matching.
-     * The trie is lazily built on first access and cached.
-     * Also loads utility set into native Rust for even faster lookups.
-     */
-    getTrie(): UtilityTrie;
-    /**
-     * Find the longest matching utility root for a candidate string.
-     * Uses native Rust when available, falls back to TypeScript trie.
-     *
-     * @param input - The utility part of the candidate (without variants)
-     * @returns [root, value] tuple if found, null otherwise
-     */
-    findRoot(input: string): [string, string] | null;
-    /**
-     * Invalidate the trie cache (call after registering new utilities).
-     */
-    invalidateTrie(): void;
-    /**
-     * Create a new Utilities instance with the same registered utilities.
-     * Keeps caches empty to avoid sharing mutable state.
-     */
-    clone(): Utilities;
-    /**
-     * Register a static utility (no value, like "flex" or "hidden").
-     */
-    static(name: string, compileFn: StaticCompileFn): void;
-    /**
-     * Register a functional utility (with value, like "bg-*" or "p-*").
-     */
-    functional(name: string, compileFn: FunctionalCompileFn, options?: UtilityOptions): void;
-    /**
-     * Check if a utility exists.
-     */
-    has(name: string, kind?: "static" | "functional"): boolean;
-    /**
-     * Get utility definitions by name.
-     */
-    get(name: string): UtilityDef[];
-    /**
-     * Compile a candidate to AST nodes.
-     */
-    compile(candidate: Candidate, theme: Theme): AstNode[] | null;
-    /**
-     * Negate numeric values in declarations.
-     * Only negates CSS custom properties (--*) and simple numeric values.
-     */
-    private negateDeclarations;
-    /**
-     * Check if a value can be simply negated.
-     * Returns true for numeric values (length, percentage, angle, time) and calc()/var().
-     * Uses inferDataType for robust type detection.
-     */
-    private isSimpleNegatable;
-    /**
-     * Register completion suggestions for a utility.
-     */
-    suggest(name: string, groups: () => SuggestionGroup[]): void;
-    /**
-     * Get completion suggestions for a utility.
-     */
-    getCompletions(name: string): SuggestionGroup[];
-    /**
-     * Get all registered utility names.
-     */
-    names(): IterableIterator<string>;
-}
-
-/**
- * Variants Registry
- *
- * Manages variant definitions for conditional styling.
- * Variants wrap utilities in selectors or at-rules.
- */
-
-/** Compound behavior flags */
-declare const enum Compounds {
-    /** Cannot compound with other variants */
-    Never = 0,
-    /** Can compound with at-rules (media, supports, etc.) */
-    AtRules = 1,
-    /** Can compound with style rules (selectors) */
-    StyleRules = 2
-}
-/** Apply function for static variants */
-type StaticApplyFn = (rule: StyleRule, variant: StaticVariant, theme: Theme) => void | null;
-/** Apply function for functional variants */
-type FunctionalApplyFn = (rule: StyleRule, variant: FunctionalVariant, theme: Theme) => void | null;
-/** Variant configuration */
-interface VariantConfig {
-    kind: "static" | "functional";
-    order: number;
-    applyFn: StaticApplyFn | FunctionalApplyFn;
-    compoundsWith: Compounds;
-}
-declare class Variants {
-    /** Registered variants */
-    private variants;
-    /** Special pattern-based variants (like numeric breakpoints) */
-    private patterns;
-    /** Optional class prefix (e.g., "tw-") for compound marker classes */
-    classPrefix: string | null;
-    /** Current ordering index */
-    private orderIndex;
-    /** Current group comparison function */
-    private currentCompareFn?;
-    /**
-     * Pre-computed order map for bitmask operations.
-     * PERFORMANCE: Updated incrementally during registration to avoid
-     * rebuilding the entire map on each access.
-     */
-    private _orderMap;
-    /** Tracks if order map needs rebuilding (variants registered out of order) */
-    private _orderMapDirty;
-    /**
-     * Register a static variant.
-     */
-    static(name: string, applyFn: StaticApplyFn, options?: {
-        compoundsWith?: Compounds;
-        order?: number;
-    }): void;
-    /**
-     * Register a functional variant.
-     */
-    functional(name: string | RegExp, applyFn: FunctionalApplyFn, options?: {
-        compoundsWith?: Compounds;
-        order?: number;
-    }): void;
-    /**
-     * Check if a variant exists.
-     */
-    has(name: string): boolean;
-    /**
-     * Get variant configuration.
-     */
-    get(name: string): VariantConfig | undefined;
-    /**
-     * Apply a variant to a rule.
-     */
-    apply(rule: StyleRule, variant: Variant, theme: Theme): AstNode[] | null;
-    /**
-     * Apply a non-compound variant to a rule.
-     * Used internally by applyCompoundVariant for the `not` variant.
-     */
-    private applyInnerVariant;
-    /**
-     * Get the sort order for a variant.
-     */
-    getOrder(variant: Variant): number;
-    /**
-     * Compare two variants for sorting.
-     * Uses breakpoint comparison for media query variants.
-     *
-     * @returns negative if a < b, 0 if equal, positive if a > b
-     */
-    compareVariants(a: Variant, b: Variant, theme?: Theme): number;
-    /**
-     * Get all registered variant names.
-     */
-    names(): IterableIterator<string>;
-    /**
-     * Create a new Variants instance with the same registered variants.
-     * Keeps caches empty to avoid sharing mutable state.
-     */
-    clone(): Variants;
-    /**
-     * Get a map of variant names to their order indices.
-     * Used for bitmask-based sorting (O(1) comparisons).
-     *
-     * PERFORMANCE: Pre-computed during registration for most cases.
-     * Only rebuilds when custom order values were specified.
-     */
-    getOrderMap(): Map<string, number>;
-    /**
-     * Invalidate the order map (call after registering new variants with custom order).
-     */
-    invalidateOrderMap(): void;
-    /**
-     * Group variants for ordering.
-     */
-    group(fn: () => void): void;
-    /**
-     * Apply a compound variant (group-hover, peer-focus, etc.)
-     *
-     * Compound variants create selectors that target elements based on
-     * the state of a parent/sibling with a matching marker class.
-     *
-     * Examples:
-     * - group-hover:text-paper -> .group:hover .group-hover\:text-paper
-     * - peer-focus:text-paper  -> .peer:focus ~ .peer-focus\:text-paper
-     * - group/sidebar-hover:text-paper -> .group\/sidebar:hover .group\/sidebar-hover\:text-paper
-     */
-    private applyCompoundVariant;
-}
-
-/**
- * Plugin API
- *
- * The API passed to plugin functions for extending the design system.
- */
-
-/**
- * The API object passed to plugin functions.
- */
-interface PluginAPI {
-    /**
-     * Add a static utility class.
-     * @example
-     * addUtility('truncate', {
-     *   overflow: 'hidden',
-     *   'text-overflow': 'ellipsis',
-     *   'white-space': 'nowrap',
-     * })
-     */
-    addUtility(name: string, declarations: Record<string, string>): void;
-    /**
-     * Add a functional utility that accepts values.
-     * @example
-     * addFunctionalUtility('custom-spacing', (value, theme) => ({
-     *   '--custom-spacing': theme.get(`--spacing-${value}`) ?? `${value}rem`,
-     * }))
-     */
-    addFunctionalUtility(name: string, handler: (value: string, theme: Theme) => Record<string, string> | null): void;
-    /**
-     * Add a static variant.
-     * @example
-     * addVariant('hocus', '&:hover, &:focus')
-     */
-    addVariant(name: string, selector: string | ((selector: string) => string)): void;
-    /**
-     * Add a functional variant that accepts values.
-     * @example
-     * addFunctionalVariant('nth', (value) => `&:nth-child(${value})`)
-     */
-    addFunctionalVariant(name: string, handler: (value: string) => string | null): void;
-    /**
-     * Extend the theme with custom values.
-     * @example
-     * extendTheme({
-     *   '--color-brand': '#ff0000',
-     *   '--spacing-huge': '100rem',
-     * })
-     */
-    extendTheme(values: Record<string, string>): void;
-    /**
-     * Add raw CSS to the output.
-     * This CSS will be included in the final output.
-     * @example
-     * addBase({
-     *   'html': { 'font-size': '16px' },
-     *   'body': { 'line-height': '1.5' },
-     * })
-     */
-    addBase(styles: Record<string, Record<string, string>>): void;
-    /**
-     * Add component styles.
-     * Similar to addBase but intended for component-level styles.
-     * @example
-     * addComponents({
-     *   '.btn': {
-     *     padding: '0.5rem 1rem',
-     *     'border-radius': '0.25rem',
-     *   },
-     * })
-     */
-    addComponents(styles: Record<string, Record<string, string>>): void;
-    /**
-     * Get a value from the theme.
-     * @example
-     * theme('--color-red-500') // => 'oklch(0.637 0.237 25.331)'
-     */
-    theme(key: string): string | undefined;
-    /**
-     * Access the design system's theme instance.
-     */
-    readonly themeInstance: Theme;
-    /**
-     * Access the design system's utilities instance.
-     */
-    readonly utilitiesInstance: Utilities;
-    /**
-     * Access the design system's variants instance.
-     */
-    readonly variantsInstance: Variants;
-}
-
-/**
- * Plugin System
- *
- * Core plugin types and loading functionality.
- */
-
-/**
- * A plugin function that extends the design system.
- */
-type PluginFunction = (api: PluginAPI) => void;
-/**
- * A plugin with configuration options.
- */
-interface PluginWithOptions<T = Record<string, unknown>> {
-    (options?: T): PluginFunction;
-    __isPluginWithOptions: true;
-}
-/**
- * A plugin can be either a function or a plugin with options.
- */
-type Plugin = PluginFunction | PluginWithOptions<any>;
-
-/**
- * Constant Folding Optimizer
- *
- * Simplifies calc() expressions at compile time:
- * - calc(2 * 4px) -> 8px
- * - calc(100% - 0px) -> 100%
- * - calc(1rem + 0) -> 1rem
- *
- * ## Supported Operations
- *
- * - **Multiplication**: `calc(N * value)` or `calc(value * N)` where N is unitless
- * - **Division**: `calc(value / N)` where N is unitless and non-zero
- * - **Addition/Subtraction**: `calc(value + value)` with compatible units
- *
- * ## Known Limitations
- *
- * ### Not Folded (Intentionally Preserved)
- *
- * - **`min()`, `max()`, `clamp()`**: CSS comparison functions require runtime
- *   viewport/container context and cannot be evaluated at compile time.
- *   Example: `calc(min(10px, 20px) + 5px)` is preserved as-is.
- *
- * - **`var()` references**: CSS custom properties cannot be evaluated at compile time.
- *   Controlled via `preserveVars` option (default: true).
- *
- * - **Viewport units**: `vw`, `vh`, `vmin`, `vmax`, `svw`, `svh`, `lvw`, `lvh`, `dvw`, `dvh`
- *   require runtime viewport dimensions.
- *
- * - **Container query units**: `cqw`, `cqh`, `cqi`, `cqb`, `cqmin`, `cqmax`
- *   require runtime container context.
- *
- * - **Percentage + length**: `calc(50% + 10px)` cannot be folded because
- *   percentage depends on the containing block.
- *
- * - **Nested calc()**: Complex nested expressions like `calc(calc(1 + 2) * 3)`
- *   are not currently supported.
- *
- * ### Tokenizer Constraints
- *
- * The tokenizer uses simple parsing. Some edge cases may not fold:
- * - Expressions with multiple operators: `calc(1px + 2px + 3px)` (3+ operands)
- * - Complex whitespace patterns
- *
- * ## Unit Compatibility
- *
- * - **Length units** (px, rem, em, cm, mm, in, pt, pc) are compatible with each other
- * - **Angle units** (deg, grad, rad, turn) are compatible with each other
- * - **Time units** (s, ms) are compatible with each other
- * - **Percentage + length**: NOT compatible (preserved as-is)
- *
- * @example
- * // Folded
- * foldCalc("calc(2 * 4px)")     // "8px"
- * foldCalc("calc(10px / 2)")    // "5px"
- * foldCalc("calc(1rem + 1rem)") // "2rem"
- *
- * // Preserved (not folded)
- * foldCalc("calc(min(10px, 20px))")     // unchanged
- * foldCalc("calc(50% + 10px)")          // unchanged
- * foldCalc("calc(100vw - 20px)")        // unchanged
- * foldCalc("calc(var(--size) * 2)")     // unchanged (default)
- */
-
-interface FoldOptions {
-    /** Root font size for rem calculations (default: 16) */
-    rem?: number;
-    /** Preserve calc() for var() references (default: true) */
-    preserveVars?: boolean;
-}
-
-/**
- * CSS Compilation
- *
- * Main compilation pipeline that transforms CSS with utilities.
- */
-
-interface DesignSystem {
-    theme: Theme;
-    utilities: Utilities;
-    variants: Variants;
-    /** Base styles added by plugins */
-    baseStyles: AstNode[];
-    /** Component styles added by plugins */
-    componentStyles: AstNode[];
-    /** Optional prefix for all utility classes (e.g., "tw-") */
-    prefix: string | null;
-    /**
-     * Whether to apply !important to all generated utilities.
-     * Set by @import "tailwindcss" important or @media important.
-     */
-    important: boolean;
-    /** Set of candidates that failed to compile (for diagnostics) */
-    invalidCandidates: Set<string>;
-    /** Set of candidates that are explicitly blocked from use */
-    blockedCandidates: Set<string>;
-    /** Record a candidate as invalid (failed to compile) */
-    recordInvalid(candidate: string): void;
-    /** Check if a candidate is valid (not blocked and has prefix if required) */
-    isValidCandidate(candidate: string): boolean;
-    /** Check if a candidate has the required prefix */
-    hasValidPrefix(candidate: string): boolean;
-    /** Strip the prefix from a candidate if present */
-    stripPrefix(candidate: string): string;
-    /**
-     * Parse a candidate with caching.
-     * Returns cached results for repeated calls with the same input.
-     */
-    parseCandidate(candidate: string): readonly Candidate[];
-    /**
-     * Track CSS variables used in a value.
-     * Marks variables as used in the theme for tree-shaking.
-     */
-    trackUsedVariables(raw: string): void;
-    /**
-     * Get all tracked used variables.
-     */
-    getUsedVariables(): Set<string>;
-    /**
-     * Compile a candidate to AST nodes with caching.
-     * Returns cached results for repeated calls with the same candidate.
-     */
-    compileCandidate(candidate: Candidate): AstNode[] | null;
-    /**
-     * Compile classes to AST nodes (for IntelliSense).
-     * Returns an array of AST nodes for each class, or empty array if invalid.
-     */
-    candidatesToAst(classes: string[]): AstNode[][];
-    /**
-     * Compile classes to CSS strings (for IntelliSense).
-     * Returns CSS string for each class, or null if invalid.
-     */
-    candidatesToCss(classes: string[]): (string | null)[];
-    /**
-     * Symbol-keyed storage for plugin data.
-     * Used for plugin extensibility without polluting the main interface.
-     */
-    storage: Record<symbol, unknown>;
-    /**
-     * Clear all internal caches.
-     * Call this when theme values change, plugins are reloaded,
-     * or when you need to ensure fresh compilation results.
-     *
-     * This invalidates:
-     * - Parsed candidate cache
-     * - Compiled AST cache
-     * - Invalid candidate tracking
-     */
-    clearCaches(): void;
-    /**
-     * Get cache statistics for debugging and monitoring.
-     * Includes hit/miss ratios for performance analysis.
-     */
-    getCacheStats(): {
-        parsedCandidates: {
-            size: number;
-            hits: number;
-            misses: number;
-            hitRate: number;
-        };
-        compiledAst: number;
-    };
-}
-interface DesignSystemOptions {
-    /** List of plugins to load */
-    plugins?: Plugin[];
-    /** Optional prefix for all utility classes (e.g., "tw-") */
-    prefix?: string | null;
-    /** Candidates to explicitly block from use */
-    blockedCandidates?: string[];
-}
-/**
- * Create a design system with default configuration.
- */
-declare function createDesignSystem(options?: DesignSystemOptions): DesignSystem;
-interface CompileOptions {
-    /** Design system to use (creates default if not provided) */
-    designSystem?: DesignSystem;
-    /** Whether to minify output */
-    minify?: boolean;
-    /** Whether to include base styles from plugins */
-    includeBase?: boolean;
-    /** Whether to include component styles from plugins */
-    includeComponents?: boolean;
-    /** Generate source map */
-    sourceMap?: boolean;
-    /** Source file path for source map */
-    from?: string;
-    /**
-     * Fold calc() expressions at compile time.
-     * - calc(2 * 4px) -> 8px
-     * - calc(100% - 0px) -> 100%
-     * - calc(1rem + 1rem) -> 2rem
-     */
-    foldConstants?: boolean | FoldOptions;
-    /**
-     * Substitute custom CSS functions:
-     * - --alpha(color / opacity) -> color-mix()
-     * - --spacing(multiplier) -> calc()
-     * - --theme(variable) -> var() or inlined value
-     */
-    substituteFunctions?: boolean;
-    /**
-     * Sort CSS declarations by property order for consistent output.
-     * (position > display > box model > typography > visual)
-     */
-    sortDeclarations?: boolean;
-}
-interface CompileResult {
-    /** Generated CSS */
-    css: string;
-    /** List of generated class names */
-    classes: string[];
-    /** Source map (when sourceMap option is true) */
-    map?: SourceMap;
-}
-/**
- * Compile a list of utility classes to CSS.
- */
-declare function compileClasses(classes: string[], options?: CompileOptions): CompileResult;
-/**
- * Apply !important to all declarations in the AST.
- * Used by both Node compile and browser build when @media important is set.
- */
-declare function applyImportant(nodes: AstNode[]): AstNode[];
-
-interface CSSParseOptions {
-    /** Source file path for error messages */
-    from?: string;
-    /**
-     * Force tracking of source locations for source map generation.
-     * When true, always uses TypeScript parser (which tracks locations)
-     * instead of the faster native Rust parser (which doesn't track locations).
-     */
-    trackSourceLocations?: boolean;
-}
-interface ParseResult {
-    /** Parsed AST nodes */
-    ast: AstNode[];
-    /** License comments found in the CSS */
-    licenseComments: Comment[];
-    /** Source object for source map generation */
-    source: Source;
-}
-/**
- * Parse CSS string into an AST.
- *
- * Uses native Rust parser when available (3-10x faster),
- * falling back to TypeScript implementation otherwise.
- *
- * Key optimizations:
- * - Native Rust parser with SIMD optimizations
- * - Index-based buffer tracking (single slice at flush time)
- * - Escape sequences tracked separately (rare case)
- * - Inline trim via trimSlice (avoids extra string creation)
- * - Pre-sizes arrays based on input length
- */
-declare function parse(input: string, options?: CSSParseOptions): ParseResult;
-
-/**
- * Directive Error Classes
- *
- * This module contains all error classes used by the directives system.
- * Each error class provides specific context about what went wrong.
- *
- * @module
- */
-/**
- * Available preflight modules.
- *
- * These control which parts of the CSS reset are included:
- * - box-sizing: Universal box-sizing: border-box
- * - document: HTML/body defaults
- * - typography: Text rendering, heading margins
- * - tables: Table border-collapse
- * - forms: Form element normalization
- * - lists: List style reset for ul, ol
- * - media: Image/video responsiveness
- * - spacing: Default margin/padding reset
- * - accessibility: sr-only and reduced-motion
- */
-declare const PREFLIGHT_MODULES: readonly ["box-sizing", "document", "typography", "tables", "forms", "lists", "media", "spacing", "accessibility"];
-type PreflightModule = (typeof PREFLIGHT_MODULES)[number];
-
-/**
- * @rainbowindex Directive
- *
- * Processes the @rainbowindex directive for marking injection points.
- *
- * @module
- */
-
-type RainbowIndexDirectiveType = "base" | "utilities" | "components";
-interface RainbowIndexDirective {
-    /** Type of directive: base, utilities, or components */
-    type: RainbowIndexDirectiveType;
-    /** Source pattern for utilities (optional) */
-    source?: {
-        base: string;
-        pattern: string;
-    } | "none";
-    /** The original AST node (used as a placeholder for utility injection) */
-    node: AtRule;
-}
-
-/**
- * @preflight Directive
- *
- * Processes the @preflight directive for CSS reset configuration.
- *
- * @module
- */
-
-/**
- * Preflight configuration from @preflight directive.
- *
- * @preflight;                      // Full preflight (default)
- * @preflight none;                 // No preflight
- * @preflight not lists;            // Exclude specific modules
- * @preflight not lists, media;     // Exclude multiple modules
- * @preflight only box-sizing;      // Include only specific modules
- * @preflight only box-sizing, forms; // Include only multiple modules
- */
-interface PreflightConfig {
-    /** Mode: full (default), none, include (only), or exclude (not) */
-    mode: "full" | "none" | "include" | "exclude";
-    /** Modules to include or exclude (depending on mode) */
-    modules: PreflightModule[];
-}
-/**
- * Filter preflight styles in a @layer base block.
- *
- * This handles the case where preflight is wrapped in @layer base { ... }
- * and filters the inner nodes based on the PreflightConfig.
- */
-declare function filterPreflightInLayer(ast: AstNode[], config: PreflightConfig): AstNode[];
-
-/**
- * @source Directive
- *
- * Processes the @source directive for candidate source configuration.
- *
- * @module
- */
-
-interface SourceDirective {
-    /** Type of source directive */
-    kind: "glob" | "inline" | "not-inline";
-    /** Glob pattern (for kind: "glob") */
-    pattern?: string;
-    /** Base directory for the pattern */
-    base?: string;
-    /** Whether this is a negated pattern */
-    negated?: boolean;
-    /** Inline candidates (for kind: "inline" or "not-inline") */
-    candidates?: string[];
-}
-
-/**
- * @font Directive
- *
- * Processes the @font directive for web font loading configuration.
- *
- * @module
- */
-
-/**
- * Options for @font directive.
- */
-interface FontDirectiveOptions {
-    /** Specific weights to include */
-    weights?: number[];
-    /** Include italic variants */
-    italic?: boolean;
-    /** Force variable or static font mode */
-    variable?: boolean;
-    /** Font display strategy */
-    display?: "auto" | "block" | "swap" | "fallback" | "optional";
-    /** Hosting mode: cdn (default) or self */
-    host?: "cdn" | "self";
-    /** URL path for self-hosted fonts */
-    path?: string;
-    /** Set theme font family (sans, serif, mono) */
-    set?: "sans" | "serif" | "mono";
-}
-/**
- * Parsed @font directive.
- */
-interface FontDirective {
-    /** Font family name */
-    family: string;
-    /** Provider (currently only "google") */
-    provider: "google";
-    /** Font options */
-    options: FontDirectiveOptions;
-}
-
-/**
- * Utility Injection
- *
- * Functions for injecting compiled utilities into the AST and cleaning up
- * internal nodes after processing.
- *
- * @module
- */
-
-/**
- * Remove @utility nodes from AST.
- *
- * Call this AFTER @apply processing to clean up @utility nodes that were
- * kept for dependency resolution.
- */
-declare function removeUtilityNodes(ast: AstNode[]): AstNode[];
-
-/**
- * Directive Handlers
- *
- * Processes special CSS directives: @rainbowindex, @theme, @color, @apply, @utility, @variant, @source, @layer
- */
-
-type CompileFeaturesFlags = number;
-interface TransformOptions {
-    designSystem: DesignSystem;
-    /** Base directory for @source patterns */
-    base?: string;
-}
-interface TransformResult {
-    /** Transformed AST nodes */
-    ast: AstNode[];
-    /** Collected @source directives */
-    sources: SourceDirective[];
-    /** Inline candidates from @source inline() */
-    inlineCandidates: string[];
-    /** Ignored candidates from @source not inline() */
-    ignoredCandidates: string[];
-    /** Reference imports (path -> true) */
-    referenceImports: Set<string>;
-    /** @rainbowindex directives found (for utility injection) */
-    rainbowIndexDirectives: RainbowIndexDirective[];
-    /** Layers declared via @layer */
-    layers: string[];
-    /** Custom utility registration functions (call with DesignSystem to register and process @apply) */
-    customUtilities: Array<(designSystem: DesignSystem) => void>;
-    /**
-     * Process deferred @apply directives after custom utilities are registered.
-     * Call this after registering customUtilities to expand @apply references
-     * to utilities defined later in the CSS.
-     * Returns a new AST with deferred @apply directives expanded.
-     */
-    processDeferredApply: (ast: AstNode[]) => AstNode[];
-    /** Preflight configuration from @preflight directive */
-    preflightConfig: PreflightConfig;
-    /** Bitmask of detected Rainbow Index features */
-    features: CompileFeaturesFlags;
-    /** @font directives found (for font import generation) */
-    fontDirectives: FontDirective[];
-}
-/**
- * Transform CSS by processing all directives.
- */
-declare function transformCSS(ast: AstNode[], options: TransformOptions): TransformResult;
-
-/**
- * Rainbow Index Browser Entry Point
- *
- * Focused entry point for browser environments with tree-shaking in mind.
- * Only exports functions that are safe and useful in browser contexts.
- *
- * Node.js-specific functionality (file I/O, native modules) is excluded.
- *
- * IMPORTANT: This file must NOT import from "./index" or any barrel exports
- * that include Node.js-specific code. Import directly from specific modules.
- */
-
-/** Feature flags for Lightning CSS integration */
-declare const Features: {
-    /** Enable CSS nesting transformation */
-    readonly Nesting: number;
-    /** Enable media query transformations */
-    readonly MediaQueries: number;
-    /** Transform logical properties */
-    readonly LogicalProperties: number;
-    /** Transform :dir() selector */
-    readonly DirSelector: number;
-    /** Transform light-dark() function */
-    readonly LightDark: number;
-    /** Transform oklch/oklab colors */
-    readonly OklabColors: number;
-    /** Transform lab/lch colors */
-    readonly LabColors: number;
-    /** Transform display-p3 colors */
-    readonly P3Colors: number;
-    /** Transform color() function */
-    readonly ColorFunction: number;
-    /** No features enabled */
-    readonly None: 0;
-    /** All features enabled */
-    readonly All: number;
-};
-type FeatureFlags = number;
-/**
- * Validate that a value is a valid feature flags bitmask.
- * Returns true if the value is a non-negative integer within the valid range.
- */
-declare function isValidFeatureFlags(value: unknown): value is FeatureFlags;
-/**
- * Validate feature flags and return a safe value.
- * If the input is invalid, returns Features.None.
- */
-declare function validateFeatureFlags(value: unknown): FeatureFlags;
-/**
- * Check if specific feature flags are enabled in a bitmask.
- */
-declare function hasFeature(flags: FeatureFlags, feature: FeatureFlags): boolean;
-
-export { type CompileOptions, type CompileResult, type DesignSystem, type FeatureFlags, Features, type ParseResult, type PrintOptions, applyImportant, compileClasses, createDesignSystem, filterPreflightInLayer, hasFeature, isValidFeatureFlags, minify, parse, print, removeUtilityNodes, transformCSS, validateFeatureFlags };
+export { browserEntryUnavailable as default };