rainbowindex 0.0.0 → 0.2.0

package/dist/index.css

@@ -0,0 +1,2 @@
+/* Rainbow Index CSS entry: Bare CSS imports resolve here; PostCSS compiles the output. */
+@preflight;

package/dist/index.d.ts

@@ -0,0 +1,289 @@
+import { PluginCreator } from 'postcss';
+import { C as ColorDefinition, l as DarkModeConfig, m as CornerShape, A as AnimationDefinition, F as FluidConfig } from './safelist-DRk1XXxi.js';
+export { a as CompilationContext, b as CompilationSnapshot, D as DEFAULT_TEXT_SIZES, 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';
+
+interface RainbowIndexOptions {
+    sources?: string[];
+    cwd?: string;
+}
+declare const rainbowindex: PluginCreator<RainbowIndexOptions>;
+
+/**
+ * Font loading system — @font directive processing, @font-face generation,
+ * metrics-adjusted fallbacks for zero CLS.
+ *
+ * A slot (sans/serif/mono/custom) maps to one --font-<slot> variable and one
+ * family name, but can own multiple faces — e.g. an upright + an italic file,
+ * or split unicode ranges. Each FontFace emits one @font-face for local
+ * providers; google/system/manual slots carry a single face.
+ */
+
+/** Provider discriminant for a slot, derived from its faces. */
+type FontProviderKind = "google" | "system" | "local" | "manual";
+interface FontFace {
+    /** Provider: "google", "system", a file path/URL, or "" (manual stack — no @font-face). */
+    provider: string;
+    /** Weight range ("300 900"), list ("400,700"), or single ("400"). */
+    weight: string;
+    /** A single valid font-style descriptor: "normal", "italic", or "oblique <range>".
+     *  (Google faces may carry "normal italic" — that drives the URL's ital axis, not a descriptor.) */
+    style: string;
+    /** font-display strategy. */
+    display: string;
+    /** Unicode subsets — used as a Google Fonts URL hint. */
+    subset: string;
+    /** Optional unicode-range descriptor emitted into the @font-face (local subsetting). */
+    unicodeRange?: string;
+    /** Per-face preload override; when undefined the slot-level default applies. */
+    preload?: boolean;
+    /** Whether the weight was explicitly set by the user (not a default).
+     *  Used by refreshFontWeightDefaults() to avoid overriding user intent. */
+    _weightExplicit?: boolean;
+    /** Whether the style was explicitly set by the user (not a default).
+     *  Used by refreshFontWeightDefaults() to avoid overriding user intent. */
+    _styleExplicit?: boolean;
+}
+interface FontSlot {
+    /** Target slot: "sans", "serif", "mono", or custom like "display". */
+    slot: string;
+    /** Font family name — shared by every face in the slot. */
+    family: string;
+    /** Provider discriminant, derived from the slot's faces. */
+    kind: FontProviderKind;
+    /** Fallback font stack. */
+    fallback: string[];
+    /** Font feature settings — applied via the font-<slot> utility. */
+    features: string | null;
+    /** Font variation settings — applied via the font-<slot> utility. */
+    variation: string | null;
+    /** Slot-level preload default for faces that don't set their own. */
+    preload: boolean;
+    /** One or more faces — each emits an @font-face for local providers. */
+    faces: FontFace[];
+    /** User-specified fallback font for metrics-adjusted @font-face. */
+    metricsFallback?: string;
+    /** User-specified size-adjust percentage. */
+    sizeAdjust?: number;
+    /** User-specified ascent-override percentage. */
+    ascent?: number;
+    /** User-specified descent-override percentage. */
+    descent?: number;
+    /** User-specified line-gap-override percentage. */
+    lineGap?: number;
+}
+interface FontOutput {
+    imports: string[];
+    fontFaces: string[];
+    variables: string[];
+    warnings: string[];
+}
+
+/**
+ * Raw-extractable directive names — the single source for the DirectiveType
+ * union and the name sets in directives/index.ts (which add the PostCSS-only
+ * apply/slot names on top for activation detection).
+ */
+declare const DIRECTIVE_TYPE_NAMES: readonly ["color", "text", "spacing", "breakpoint", "rounded", "shadow", "weight", "ease", "blur", "z", "animate", "fluid", "font", "preflight", "utility", "custom", "source", "leading", "tracking", "opacity", "duration", "layer", "register"];
+type DirectiveType = (typeof DIRECTIVE_TYPE_NAMES)[number];
+interface ParsedDirective {
+    type: DirectiveType;
+    body: string;
+    modifier?: string;
+}
+interface PreflightConfig {
+    core: boolean;
+    typography: boolean;
+    content: boolean;
+    forms: boolean;
+    interactive: boolean;
+    modern: boolean;
+}
+interface CustomUtility {
+    name: string;
+    functional: boolean;
+    body: string;
+}
+interface CustomVariant {
+    name: string;
+    selector: string;
+}
+interface SourceDirective {
+    pattern: string;
+    negated: boolean;
+    inline: boolean;
+    classes?: string[];
+    /**
+     * Marks the pattern as a trusted, fully-qualified absolute path produced
+     * by internal machinery (auto-discovery from installed deps). User-facing
+     * `@source` patterns are validated to be relative — this flag bypasses
+     * that check for patterns we generate ourselves and that intentionally
+     * point outside the project's cwd (into `node_modules`).
+     */
+    absolute?: boolean;
+}
+interface LayerConfig {
+    order: string[] | null;
+    utilities: string | null;
+    base: string | null;
+    wrapAll: string | null;
+}
+/**
+ * A custom-property registration produced by an `@register` directive — the
+ * structured form of a CSS `@property` rule. `syntax` is stored already quoted
+ * (e.g. `"<length>"`) so it can be emitted verbatim. `initialValue` is optional
+ * only when `syntax` is the universal `"*"`; the parser drops typed registrations
+ * that lack one (a typed `@property` without `initial-value` is invalid CSS and
+ * silently ignored by browsers).
+ */
+interface PropertyRegistration {
+    name: string;
+    syntax: string;
+    inherits: boolean;
+    initialValue?: string;
+}
+interface ResolvedTheme {
+    readonly colors: Readonly<Record<string, ColorDefinition>>;
+    readonly darkConfig: Readonly<DarkModeConfig>;
+    readonly text: Readonly<Record<string, {
+        fontSize: string;
+        lineHeight: string;
+    }>>;
+    readonly spacing: Readonly<{
+        base: string;
+    }>;
+    readonly breakpoints: Readonly<Record<string, string>>;
+    readonly rounded: Readonly<Record<string, string>>;
+    readonly roundedRoof: string;
+    /**
+     * Corner shape set via `@rounded <shape>`. `null` means no shape was configured —
+     * the compiler emits neither a `corner-shape` rule nor the fallback `@supports not`
+     * block. Non-null values trigger both.
+     */
+    readonly roundedShape: CornerShape | null;
+    /**
+     * Multiplier applied to `border-radius` inside
+     * `@supports (corner-shape: <shape>)` so that — in browsers that do
+     * render the configured shape — radii are bumped to match the visual
+     * weight a plain round corner would have at the raw radius in
+     * non-supporting browsers. Derived from the per-shape default table,
+     * overridable via `--corner-scale` in the `@rounded` body. Ignored when
+     * `roundedShape` is null.
+     */
+    readonly roundedShapeScale: number;
+    readonly shadows: Readonly<Record<string, string>>;
+    readonly weights: Readonly<Record<string, number>>;
+    readonly easing: Readonly<Record<string, string>>;
+    readonly blur: Readonly<Record<string, string>>;
+    readonly z: Readonly<Record<string, string>>;
+    readonly animations: Readonly<Record<string, AnimationDefinition>>;
+    readonly fluid: Readonly<FluidConfig>;
+    readonly textFluid?: Readonly<FluidConfig>;
+    readonly spacingFluid?: Readonly<FluidConfig>;
+    readonly fonts: readonly FontSlot[];
+    readonly preflight: Readonly<PreflightConfig>;
+    readonly customUtilities: readonly CustomUtility[];
+    readonly customVariants: readonly CustomVariant[];
+    readonly sources: readonly SourceDirective[];
+    readonly leading: Readonly<Record<string, string>>;
+    readonly tracking: Readonly<Record<string, string>>;
+    readonly opacity: Readonly<Record<string, string>>;
+    readonly duration: Readonly<Record<string, string>>;
+    readonly layer: Readonly<LayerConfig> | null;
+    /** Custom properties registered via `@register` → emitted as `@property` rules. */
+    readonly registeredProperties: readonly PropertyRegistration[];
+    readonly warnings: readonly string[];
+}
+
+type FontResolver = (fonts: ResolvedTheme["fonts"]) => Promise<ResolvedTheme["fonts"]> | ResolvedTheme["fonts"];
+interface FinalizeProjectResult {
+    css: string;
+    /** Generated output only — user CSS is carried separately in `userCSS`. */
+    sections: string[];
+    /** The user's own CSS (RI directives stripped), appended after `sections` in `css`. */
+    userCSS: string;
+    classNames: string[];
+    theme: ResolvedTheme;
+    directives: ParsedDirective[];
+    warnings: string[];
+}
+
+interface SourceEntry {
+    path?: string;
+    content: string;
+}
+interface CompileProjectOptions {
+    css: string;
+    sources?: Iterable<SourceEntry>;
+    classNames?: Iterable<string>;
+    resolveFonts?: FontResolver;
+    processCssFunctions?: boolean;
+}
+/** compileProject returns the pipeline result unmodified — one shape, two names. */
+type CompileProjectResult = FinalizeProjectResult;
+declare function compileProject(options: CompileProjectOptions): Promise<CompileProjectResult>;
+
+interface CompiledRule {
+    /** The original class name (escaped for CSS selector). */
+    selector: string;
+    /** Sort key for deterministic ordering. */
+    sortKey: number;
+    /** CSS declarations as a string block. */
+    css: string;
+}
+interface CompilationResult {
+    /** All compiled CSS rules. */
+    rules: CompiledRule[];
+    /** @keyframes blocks needed. */
+    keyframes: string[];
+    /** @property declarations needed. */
+    properties: string[];
+    /** Map of used color hue → set of used suffixes (for token pruning). */
+    usedColorStops: Map<string, Set<number>>;
+    /** Set of used text size names (for token pruning). */
+    usedTextSizes: Set<string>;
+    /** Set of used font slot names (for token pruning). */
+    usedFonts: Set<string>;
+    /** Set of used rounded value names (for token pruning). */
+    usedRounded: Set<string>;
+    /** Set of used shadow names (for token pruning). */
+    usedShadows: Set<string>;
+    /** Set of used animation shorthand names (for token pruning). */
+    usedAnimations: Set<string>;
+    /** Warnings emitted during compilation. */
+    warnings: string[];
+}
+
+/**
+ * Create an isolated compiler instance for SSR / concurrent-compilation
+ * environments. Returns a `compile()` function that does NOT touch module-level
+ * state, and a `createRi()` that produces a merge function bound to the
+ * compilation's snapshot.
+ *
+ * **Isolation scope:** Compilation context, variant map cache, and font output
+ * cache are fully isolated per instance. Google Fonts metadata (from fonts.ts)
+ * is intentionally shared read-only across instances — it is populated once
+ * via atomic swap and never mutated afterward, so concurrent reads are safe.
+ *
+ * **Font output cache lifecycle:** `fontOutputCache` is cleared at the start
+ * of each `compile()` call, so it only caches within a single compilation pass.
+ * If the same compiler instance is reused across compilations (the expected SSR
+ * pattern), each compilation starts with a fresh font cache.
+ *
+ * @example
+ * ```ts
+ * import { createCompiler } from "rainbowindex";
+ *
+ * const compiler = createCompiler();
+ * const result = compiler.compile(classNames, theme);
+ * const ri = compiler.createRi();
+ * ```
+ */
+declare function createCompiler(): {
+    compile: (classNames: Iterable<string>, theme: ResolvedTheme) => CompilationResult;
+    createRi: () => (...inputs: (string | false | null | undefined)[]) => string;
+    /** Isolated font output cache for this compiler instance. Pass to
+     *  `assembleSections()` to avoid sharing module-level font state. */
+    fontOutputCache: Map<string, FontOutput>;
+};
+
+export { ColorDefinition, type CompilationResult, type CompileProjectOptions, type CompileProjectResult, type CompiledRule, FluidConfig, type RainbowIndexOptions, compileProject, createCompiler, rainbowindex as default };

package/dist/index.mjs

@@ -0,0 +1,71 @@
+import {
+  safelist
+} from "./chunk-PD4ZXGJ6.mjs";
+import {
+  postcss_default
+} from "./chunk-KCSNR2TV.mjs";
+import {
+  analyzeProjectCSS,
+  createCompiler,
+  extractClassesFromSource,
+  finalizeProjectCompilation,
+  pushWarningsDeduped,
+  resolveGoogleFonts
+} from "./chunk-RPXZ3O6R.mjs";
+import {
+  DEFAULT_TEXT_SIZES,
+  createCompilationContext,
+  createRi,
+  defaultTheme,
+  finalizeCompilationContext,
+  registerColorNames,
+  registerCustomFontFamilies,
+  registerCustomTextSizes,
+  registerCustomUtility,
+  ri
+} from "./chunk-5N4GPK26.mjs";
+
+// src/project/index.ts
+async function compileProject(options) {
+  const analysis = analyzeProjectCSS(options.css);
+  const classNames = /* @__PURE__ */ new Set();
+  if (options.classNames) {
+    for (const cls of options.classNames) {
+      classNames.add(cls);
+    }
+  }
+  if (options.sources) {
+    const extractionWarnings = [];
+    for (const source of options.sources) {
+      for (const cls of extractClassesFromSource(source, extractionWarnings)) {
+        classNames.add(cls);
+      }
+    }
+    pushWarningsDeduped(analysis.warnings, extractionWarnings, analysis.warningSeen);
+  }
+  return finalizeProjectCompilation({
+    css: options.css,
+    classNames,
+    analysis,
+    // Default to resolving google font weights so headless callers aren't silently
+    // stuck with "100 900" defaults; opt out with RI_OFFLINE / RI_FETCH_FONTS.
+    resolveFonts: options.resolveFonts ?? resolveGoogleFonts,
+    processCssFunctions: options.processCssFunctions
+  });
+}
+export {
+  DEFAULT_TEXT_SIZES,
+  compileProject,
+  createCompilationContext,
+  createCompiler,
+  createRi,
+  postcss_default as default,
+  defaultTheme,
+  finalizeCompilationContext,
+  registerColorNames,
+  registerCustomFontFamilies,
+  registerCustomTextSizes,
+  registerCustomUtility,
+  ri,
+  safelist
+};

package/dist/optimize-6NWJVT6W.mjs

@@ -0,0 +1,24 @@
+// src/cli/optimize.ts
+import { transform } from "lightningcss";
+function optimizeCSS(css) {
+  try {
+    const result = transform({
+      filename: "output.css",
+      code: Buffer.from(css),
+      minify: true,
+      targets: {
+        chrome: 96 << 16,
+        firefox: 91 << 16,
+        safari: 15 << 16 | 4 << 8
+      }
+    });
+    return result.code.toString();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const sanitized = msg.replace(/\/[a-zA-Z][\w.-]*(?:\/[\w.-]+)+/g, "<path>").replace(/[A-Z]:\\[\w.-]+(?:\\[\w.-]+)+/gi, "<path>");
+    throw new Error(`CSS optimization failed: ${sanitized}`);
+  }
+}
+export {
+  optimizeCSS
+};

package/dist/safelist-DRk1XXxi.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Generative color system — color domain model, OKLCH ramp generation,
+ * and light-dark() pairing.
+ *
+ * 2 numbers (chroma + hue) → 19-stop palette with automatic dark mode.
+ *
+ * The ramp is sampled from a fixed reference profile (`L_PROFILE` / `C_SHAPE` /
+ * `H_DRIFT`, captured from the reference palette): lightness is a curved,
+ * compressed scale (low suffix → light, high → dark), chroma is an asymmetric
+ * bell peaking at stop 500, and hue is near-flat. Dark mode is a simple ramp
+ * reversal — the dark value is the stop the ramp reaches at the mirror position
+ * (`1000 - suffix`), so stop 500 pivots to itself.
+ */
+/** Per-color dark mode override strategy. */
+type ColorDarkOverride = {
+    strategy: "mirror";
+} | {
+    strategy: "fixed";
+} | {
+    strategy: "shift";
+    chromaDelta: number;
+    hueDelta: number;
+};
+/**
+ * Color definition — discriminated union supporting:
+ * - Generative: `brand: 0.18 330;` → 19-stop palette with auto dark mode
+ * - Explicit: `accent: oklch(0.72 0.21 330);` → single color value
+ * - Pair: `surface: oklch(0.98 0.01 260) / oklch(0.15 0.01 260);` → light/dark pair
+ * - Alias: `theme: brand;` → references another color's palette via var()
+ */
+type ColorDefinition = {
+    type: "generative";
+    chroma: number;
+    hue: number;
+    dark?: ColorDarkOverride;
+    inline?: boolean;
+    parabolic?: boolean;
+    chromaBoost?: boolean;
+} | {
+    type: "explicit";
+    value: string;
+} | {
+    type: "keyword";
+    value: string;
+} | {
+    type: "pair";
+    light: string;
+    dark: string;
+} | {
+    type: "alias";
+    source: string;
+};
+interface DarkModeConfig {
+    mode: "auto" | "off";
+    chromaBoost: number;
+    hueShift: number;
+}
+
+/**
+ * Default theme values — the static data that ships if the user writes no directives.
+ * `directives.ts` (Phase 5) parses user overrides and merges them with these defaults.
+ */
+
+interface TextSize {
+    fontSize: string;
+    lineHeight: string;
+}
+type FluidUnit = "vw" | "vi" | "vmin" | "vmax";
+interface FluidConfig {
+    min: string;
+    max: string;
+    unit?: FluidUnit;
+    multiplier?: number;
+}
+interface AnimationDefinition {
+    shorthand: string;
+    keyframes: string;
+}
+interface Theme {
+    spacing: {
+        base: string;
+    };
+    colors: Record<string, ColorDefinition>;
+    text: Record<string, TextSize>;
+    breakpoints: Record<string, string>;
+    rounded: Record<string, string>;
+    shadows: Record<string, string>;
+    weights: Record<string, number>;
+    easing: Record<string, string>;
+    fluid: FluidConfig;
+    animations: Record<string, AnimationDefinition>;
+    blur: Record<string, string>;
+}
+/**
+ * Keyword corner-shape values. `superellipse(N)` is represented separately
+ * as `{ superellipse: N }` since the numeric parameter isn't a keyword.
+ * Single source for the type, the scale table below, and the @rounded
+ * modifier parser (directives/parsers.ts).
+ */
+declare const CORNER_SHAPE_KEYWORDS: readonly ["round", "scoop", "bevel", "notch", "square", "squircle"];
+type CornerShapeKeyword = (typeof CORNER_SHAPE_KEYWORDS)[number];
+type CornerShape = CornerShapeKeyword | {
+    superellipse: number;
+};
+declare const defaultTheme: Theme;
+
+/**
+ * ri() — class merge function.
+ * Replaces both tailwind-merge and clsx.
+ *
+ * Re-exported from the package's main and browser entries as `ri()`.
+ * Right-to-left scan: rightmost class wins when two classes set the same CSS property.
+ *
+ * ## Concurrency
+ *
+ * The default `ri()` export uses module-level state published by
+ * `finalizeCompilationContext()`. This is safe for single-compilation
+ * environments (typical browser usage, single Vite build, PostCSS).
+ *
+ * In multi-tenant / SSR / concurrent-compilation environments, use
+ * `createRi(snapshot)` instead — it captures a frozen snapshot of the
+ * compilation state and uses its own independent cache:
+ *
+ *   const snapshot = finalizeCompilationContext(ctx);
+ *   const ri = createRi(snapshot);
+ */
+type ClassInput = string | false | null | undefined | ClassInput[];
+declare const DEFAULT_TEXT_SIZES: readonly ["xs", "sm", "base", "lg", "xl", "2xl", "3xl", "4xl", "5xl"];
+interface CompilationContext {
+    customStaticProps: Record<string, string[]>;
+    textSizes: Set<string>;
+    fontFamilies: Set<string>;
+    colorNames: Set<string>;
+}
+/**
+ * Frozen snapshot of compilation state for SSR-safe ri() instances.
+ * Created by finalizeCompilationContext() and consumed by createRi().
+ */
+interface CompilationSnapshot {
+    readonly customStaticProps: Readonly<Record<string, string[]>>;
+    readonly textSizes: ReadonlySet<string>;
+    readonly fontFamilies: ReadonlySet<string>;
+    readonly colorNames: ReadonlySet<string>;
+}
+/**
+ * Merge class names with conflict resolution (replaces both tailwind-merge and clsx).
+ * Rightmost class wins when two classes set the same CSS property.
+ * Falsy values are filtered.
+ *
+ * @example
+ * ri('p-2 bg-red-500', 'p-4')           // → 'bg-red-500 p-4'
+ * ri('px-2 py-1', 'p-4')                // → 'p-4' (shorthand wins)
+ * ri('flex', isActive && 'bg-blue-500') // → 'flex bg-blue-500'
+ * ri('text-lg text-red-500')            // → 'text-lg text-red-500' (different properties)
+ */
+declare function ri(...inputs: ClassInput[]): string;
+/**
+ * Create an isolated ri() instance bound to a specific compilation snapshot.
+ * Use this in SSR or multi-compilation environments where the global ri()
+ * would be corrupted by concurrent compilations.
+ *
+ * @example
+ * const snapshot = finalizeCompilationContext(ctx);
+ * const ri = createRi(snapshot);
+ * ri('p-2 bg-red-500', 'p-4') // → 'bg-red-500 p-4'
+ */
+declare function createRi(snapshot?: CompilationSnapshot): (...inputs: ClassInput[]) => string;
+/**
+ * Create a fresh compilation context.
+ * Called at the start of each compile() pass.
+ */
+declare function createCompilationContext(): CompilationContext;
+/**
+ * Register a custom utility's CSS properties in the compilation context.
+ * Called by the engine when processing @utility directives.
+ */
+declare function registerCustomUtility(ctx: CompilationContext, name: string, properties: string[]): void;
+/**
+ * Register custom text sizes so the merge function correctly classifies
+ * text-{custom} as a font-size utility rather than a color utility.
+ */
+declare function registerCustomTextSizes(ctx: CompilationContext, sizes: string[]): void;
+/**
+ * Register custom font family names so the merge function correctly classifies
+ * font-{custom} as a font-family utility rather than a font-weight utility.
+ */
+declare function registerCustomFontFamilies(ctx: CompilationContext, families: string[]): void;
+/**
+ * Register the resolved theme's color names so the merge function classifies
+ * bare flat colors (border-accent for `@color { accent: … }`) as color
+ * utilities rather than width/weight ones. Shaded forms (accent-500) already
+ * match the shade pattern and need no registration.
+ */
+declare function registerColorNames(ctx: CompilationContext, names: string[]): void;
+declare function finalizeCompilationContext(ctx: CompilationContext): CompilationSnapshot;
+
+/**
+ * `safelist()` — declare utility classes that must be emitted regardless of
+ * whether the consumer's source files reference them directly.
+ *
+ * At runtime this is a plain identity-join: pass any number of strings (and
+ * falsy values, which are filtered) and receive a single space-joined string
+ * suitable for `className`. The function performs no global registration, has
+ * no side effects, and is tree-shake-safe.
+ *
+ * The build-time meaning comes from the scanner: when the source-file
+ * extractor encounters a `safelist(...)` call, it extracts every literal
+ * string argument as a class declaration — so the classes get emitted in the
+ * final CSS even though the consumer's source never names them literally.
+ *
+ * Primary use case is component libraries that ship classNames inside their
+ * bundled code (e.g. a curated icon set whose strokes are described by
+ * utility classes). The library wraps its declarations in `safelist(...)`,
+ * the consumer's setup points the scanner at the library's `dist/`, and the
+ * classes flow through unchanged. The Vite plugin auto-discovers libraries
+ * that opt in via a `rainbowindex.safelistSources` field in their
+ * `package.json`, so consumers typically don't have to add `@source` lines
+ * by hand.
+ *
+ *   const ICON_BASE = safelist("stroke-cap-round", "stroke-join-round");
+ *   const SidebarLeft = defineIcon({
+ *     primitives: SIDEBAR,
+ *     className: safelist(ICON_BASE, "-scale-x-100"),
+ *   });
+ *
+ * Scanner contract:
+ * - Only STATIC string literals at the call site are extracted. Values
+ *   passed through variables (`safelist(ICON_BASE, ...)`) won't be re-read
+ *   at the outer call site, but the original `safelist("stroke-cap-round",
+ *   ...)` that produced `ICON_BASE` is itself extracted, so the classes are
+ *   still covered.
+ * - Template literals with no `${…}` interpolation are extracted; templates
+ *   with interpolation are skipped.
+ * - Falsy arguments are dropped at runtime so conditional fragments compose
+ *   naturally: `safelist("flex", side === "left" && "flex-row-reverse")`.
+ */
+declare function safelist(...parts: ReadonlyArray<string | false | null | undefined>): string;
+
+export { type AnimationDefinition as A, type ColorDefinition as C, DEFAULT_TEXT_SIZES as D, type FluidConfig as F, type TextSize as T, type CompilationContext as a, type CompilationSnapshot as b, type Theme as c, createCompilationContext as d, createRi as e, defaultTheme as f, finalizeCompilationContext as g, registerCustomFontFamilies as h, registerCustomTextSizes as i, registerCustomUtility as j, ri as k, type DarkModeConfig as l, type CornerShape as m, registerColorNames as r, safelist as s };

package/dist/vite.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from 'vite';
+
+declare function rainbowindexVite(): Plugin;
+
+export { rainbowindexVite as default };