rainbowindex 0.2.0 → 0.2.2

package/dist/index-DK6APAGD.d.ts

@@ -0,0 +1,260 @@
+import { C as ColorDefinition, l as DarkModeConfig, m as CornerShape, A as AnimationDefinition, F as FluidConfig, b as CompilationSnapshot } from './index-CfDtWufj.js';
+
+/** 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;
+}
+
+/**
+ * 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.
+ */
+
+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[];
+}
+
+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[];
+}
+
+/**
+ * Build a CompilationSnapshot straight from a resolved theme — no compile
+ * pass, no module-level state. Editor tooling pairs this with
+ * analyzeMerge()/createRi() for theme-accurate merge semantics.
+ */
+declare function createThemeSnapshot(theme: ResolvedTheme): CompilationSnapshot;
+/**
+ * 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 { type CompilationResult as C, type ParsedDirective as P, type ResolvedTheme as R, type CompiledRule as a, createThemeSnapshot as b, createCompiler as c };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 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';
+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 } from './index-CfDtWufj.js';
+import { R as ResolvedTheme, P as ParsedDirective } from './index-DK6APAGD.js';
+export { C as CompilationResult, a as CompiledRule, c as createCompiler } from './index-DK6APAGD.js';
+export { s as safelist } from './safelist-CH3_PywB.js';
 
 interface RainbowIndexOptions {
     sources?: string[];
@@ -8,192 +10,6 @@ interface RainbowIndexOptions {
 }
 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;
@@ -222,68 +38,4 @@ interface CompileProjectOptions {
 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 };
+export { type CompileProjectOptions, type CompileProjectResult, type RainbowIndexOptions, compileProject, rainbowindex as default };

package/dist/index.mjs

@@ -3,15 +3,17 @@ import {
 } from "./chunk-PD4ZXGJ6.mjs";
 import {
   postcss_default
-} from "./chunk-KCSNR2TV.mjs";
+} from "./chunk-CUUW2K35.mjs";
+import {
+  finalizeProjectCompilation,
+  resolveGoogleFonts
+} from "./chunk-FHATRQMN.mjs";
 import {
   analyzeProjectCSS,
   createCompiler,
   extractClassesFromSource,
-  finalizeProjectCompilation,
-  pushWarningsDeduped,
-  resolveGoogleFonts
-} from "./chunk-RPXZ3O6R.mjs";
+  pushWarningsDeduped
+} from "./chunk-W6XIBM4M.mjs";
 import {
   DEFAULT_TEXT_SIZES,
   createCompilationContext,
@@ -23,7 +25,7 @@ import {
   registerCustomTextSizes,
   registerCustomUtility,
   ri
-} from "./chunk-5N4GPK26.mjs";
+} from "./chunk-SOMDX7V6.mjs";
 
 // src/project/index.ts
 async function compileProject(options) {

package/dist/safelist-CH3_PywB.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `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 { safelist as s };

package/dist/vite.mjs

@@ -1,6 +1,7 @@
 import {
   postcss_default
-} from "./chunk-KCSNR2TV.mjs";
+} from "./chunk-CUUW2K35.mjs";
+import "./chunk-FHATRQMN.mjs";
 import {
   expandApplyGroups,
   findClosingBrace,
@@ -8,10 +9,10 @@ import {
   isAtRuleBoundary,
   isAtRuleNameChar,
   isSourceFile
-} from "./chunk-RPXZ3O6R.mjs";
+} from "./chunk-W6XIBM4M.mjs";
 import {
   devWarn
-} from "./chunk-5N4GPK26.mjs";
+} from "./chunk-SOMDX7V6.mjs";
 
 // src/integrations/vite.ts
 import { existsSync } from "fs";