rainbowindex 0.2.2 → 0.4.0

package/dist/{index-CfDtWufj.d.ts → context-ruu2x_jR.d.ts}

@@ -105,27 +105,19 @@ type CornerShape = CornerShapeKeyword | {
 declare const defaultTheme: Theme;
 
 /**
- * ri() — class merge function.
- * Replaces both tailwind-merge and clsx.
+ * Compilation-context lifecycle — all mutable state behind ri().
  *
- * 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.
+ * The engine creates a CompilationContext via createCompilationContext(),
+ * mutates it during compilation (register* functions), then finalizes it so
+ * ri() can read the published snapshot without interference from concurrent
+ * compilations. Split from merge/index.ts so the merge algorithm stays pure
+ * runtime and every piece of mutable state lives in one file.
  *
- * ## 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);
+ * The default ri() LRU cache lives here rather than next to the merge loop
+ * because finalizeCompilationContext() must clear it: conflict resolution
+ * rules may change between compilations, and stale entries from a previous
+ * compilation (with different custom utilities) must never be returned.
  */
-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>;
@@ -142,57 +134,6 @@ interface CompilationSnapshot {
     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;
-interface MergeDrop {
-    index: number;
-    className: string;
-    /** Ascending indices of the surviving classes that together claimed every
-     *  CSS property this class sets (px-4 + py-4 jointly dominate p-2). */
-    overriddenBy: number[];
-}
-interface MergeAnalysis {
-    /** The merged output — identical to ri()'s result for this token list. */
-    output: string;
-    /** Indices of surviving classes, ascending. */
-    kept: number[];
-    /** Dropped classes with attribution, ascending by index. */
-    dropped: MergeDrop[];
-}
-/**
- * Explain ri()'s conflict resolution for a list of class tokens — which
- * classes the right-most-wins scan drops, and which survivors claimed their
- * properties. Powers "this class is overridden" editor diagnostics.
- *
- * Unlike ri(), the input is pre-tokenized: one class per element, no falsy
- * filtering, no whitespace splitting — exactly the token list an editor
- * extracts from one class attribute. `snapshot` binds custom utilities, text
- * sizes, and color names the same way createRi(snapshot) does (editors build
- * one with createThemeSnapshot()); without it, the module-level state of the
- * most recent compile applies. Uncached — call sites own their memoization.
- */
-declare function analyzeMerge(classes: readonly string[], snapshot?: CompilationSnapshot): MergeAnalysis;
 /**
  * Create a fresh compilation context.
  * Called at the start of each compile() pass.
@@ -220,6 +161,10 @@ declare function registerCustomFontFamilies(ctx: CompilationContext, families: s
  * match the shade pattern and need no registration.
  */
 declare function registerColorNames(ctx: CompilationContext, names: string[]): void;
+/**
+ * Snapshot compilation context into module-level state that ri() reads from.
+ * Called at the end of compile() to atomically publish the new state.
+ */
 declare function finalizeCompilationContext(ctx: CompilationContext): CompilationSnapshot;
 
-export { type AnimationDefinition as A, type ColorDefinition as C, DEFAULT_TEXT_SIZES as D, type FluidConfig as F, type MergeAnalysis as M, 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, type MergeDrop as n, analyzeMerge as o, registerColorNames as r };
+export { type AnimationDefinition as A, type ColorDefinition as C, type DarkModeConfig 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, defaultTheme as e, finalizeCompilationContext as f, registerCustomFontFamilies as g, registerCustomTextSizes as h, registerCustomUtility as i, type CornerShape as j, registerColorNames as r };

package/dist/editor.d.ts

@@ -1,18 +1,8 @@
-import { P as ParsedDirective, R as ResolvedTheme } from './index-DK6APAGD.js';
-export { b as createThemeSnapshot } from './index-DK6APAGD.js';
-import { C as ColorDefinition, b as CompilationSnapshot, M as MergeAnalysis } from './index-CfDtWufj.js';
-export { n as MergeDrop, o as analyzeMerge, f as defaultTheme } from './index-CfDtWufj.js';
+import { P as ParsedDirective, R as ResolvedTheme } from './index-BB2HoeMj.js';
+export { b as createThemeSnapshot } from './index-BB2HoeMj.js';
+import { b as CompilationSnapshot, C as ColorDefinition } from './context-ruu2x_jR.js';
+export { e as defaultTheme } from './context-ruu2x_jR.js';
 
-/** Helper-call names whose string arguments are walked for class literals.
- *  Exported for editor tooling so completion-context detection can match the
- *  scanner's own behavior. */
-declare const CLASS_HELPER_NAMES: readonly string[];
-/** Variant-config helper names (`cva`/`tv`) whose config objects are walked. */
-declare const VARIANT_HELPER_NAMES: readonly string[];
-interface SourceExtractionInput {
-    path?: string;
-    content: string;
-}
 type CandidateOrigin = "attribute" | "helper" | "safelist" | "plain";
 interface ClassCandidate {
     /** The class string in expanded form — for variant-group members this
@@ -27,14 +17,35 @@ interface ClassCandidate {
     origin: CandidateOrigin;
     /** The call the class was found in, when origin is "helper"/"safelist". */
     helperName?: string;
+    /** Identity of the innermost scanned helper/safelist call context:
+     *  candidates from the same call share one id, distinct calls get distinct
+     *  ids. A class helper nested inside another class helper's arguments is
+     *  not scanned as its own call — its literals belong to the outer call —
+     *  while a class helper inside a cva/tv config does get its own id. Ids
+     *  are only comparable within one extraction's result. Absent for
+     *  attribute/plain candidates. */
+    callId?: number;
     /** For variant-group members: span of the group's variant prefix (`hover:`). */
     groupPrefix?: {
         start: number;
         end: number;
     };
 }
-declare function expandVariantGroups(input: string, warnings?: string[]): string;
+
+/** Helper-call names whose string arguments are walked for class literals.
+ *  Exported for editor tooling so completion-context detection can match the
+ *  scanner's own behavior. */
+declare const CLASS_HELPER_NAMES: readonly string[];
+/** Variant-config helper names (`cva`/`tv`) whose config objects are walked. */
+declare const VARIANT_HELPER_NAMES: readonly string[];
 declare function extractClasses(source: string, warnings?: string[]): Set<string>;
+
+declare function expandVariantGroups(input: string, warnings?: string[]): string;
+
+interface SourceExtractionInput {
+    path?: string;
+    content: string;
+}
 declare function extractClassesFromSource(input: SourceExtractionInput, warnings?: string[]): Set<string>;
 /**
  * Position-aware variant of `extractClassesFromSource` for editor tooling.
@@ -177,6 +188,13 @@ interface ParsedUtility {
  */
 declare function parseUtility(raw: string): ParsedUtility;
 
+/**
+ * Shared leaf helpers for the utility generators — result types, tiny
+ * constructors, and value-grammar helpers. Lives below both the generators
+ * and the dispatch index (which imports every generator) so that generators
+ * never import their own aggregator: generator ↔ index cycles would let
+ * modules observe partially initialized exports.
+ */
 interface CSSDeclaration {
     property: string;
     value: string;
@@ -268,6 +286,32 @@ declare function createClassInspector(theme: ResolvedTheme): ClassInspector;
  */
 declare function findClosest(input: string, candidates: string[], maxDistance?: number): string | null;
 
+/**
+ * The single registration table for built-in utility roots: each row binds a
+ * set of roots to the generators that resolve them (in probe order) AND to the
+ * value space editor enumeration tries for them. index.ts derives
+ * PREFIX_DISPATCH from the resolver columns; enumerate.ts derives
+ * UTILITY_VALUE_SPACES from the spec column — adding a root forces deciding
+ * both in one row, so the two can never drift.
+ *
+ * Value spaces are deliberately GENEROUS (which theme namespaces and keyword
+ * families to TRY per functional root): every enumeration candidate is probed
+ * through the real utility resolver, which stays the single authority — a
+ * spec can over-approximate freely and never emit something `validate()`
+ * would reject. `{ kinds: [] }` marks a statics-only root.
+ *
+ * Ordering is load-bearing twice over: row order fixes PREFIX_DISPATCH key
+ * insertion order (which drives cross-root enumeration dedup labels), and
+ * per-root resolver order fixes which generator wins a contested root.
+ */
+
+type ValueSpaceKind = "color" | "special-color" | "spacing" | "fraction" | "text-size" | "fluid-text-size" | "font-slot" | "weight" | "rounded" | "rounded-side" | "shadow" | "z" | "ease" | "blur" | "animation" | "leading" | "tracking" | "opacity" | "duration" | "breakpoint" | "int" | "percent" | "keywords";
+interface ValueSpaceSpec {
+    kinds: readonly ValueSpaceKind[];
+    /** Extra value parts to try verbatim (for "keywords" and beyond). */
+    keywords?: readonly string[];
+}
+
 /**
  * Class enumeration — the completion universe for editor tooling.
  *
@@ -276,23 +320,19 @@ declare function findClosest(input: string, candidates: string[], maxDistance?:
  * root), then every candidate is probed through the real utility resolver.
  * The resolver is the single authority — an enumerated class is one that
  * actually compiles, so the table can over-approximate freely and can never
- * emit something `validate()` would reject. Coverage is enforced the other
- * way by tests: every PREFIX_DISPATCH root must appear in the table (an empty
- * spec marks a statics-only root), so adding a generator root without
- * deciding its value space fails CI.
+ * emit something `validate()` would reject. Coverage is structural: the table
+ * derives from ROOT_GROUPS (roots.ts), where `spec` is a required field of
+ * every row — adding a root forces deciding its value space in the same row
+ * (an empty spec marks a statics-only root); the CI check in enumerate.test.ts
+ * stays on as a regression tripwire.
  *
  * Statics come from the merge conflict tables (STATIC_UTILITIES) plus each
  * generator's own static-map keys — probed too, for the same guarantee.
  */
 
-type ValueSpaceKind = "color" | "special-color" | "spacing" | "fraction" | "text-size" | "fluid-text-size" | "font-slot" | "weight" | "rounded" | "rounded-side" | "shadow" | "z" | "ease" | "blur" | "animation" | "leading" | "tracking" | "opacity" | "duration" | "breakpoint" | "int" | "percent" | "keywords";
-interface ValueSpaceSpec {
-    kinds: readonly ValueSpaceKind[];
-    /** Extra value parts to try verbatim (for "keywords" and beyond). */
-    keywords?: readonly string[];
-}
-/** Root → value spaces to try. Coverage of every PREFIX_DISPATCH root is
- *  enforced by __tests__/core/enumerate.test.ts. */
+/** Root → value spaces to try, derived from ROOT_GROUPS. Every
+ *  PREFIX_DISPATCH root is present by construction — both maps are built
+ *  from the same rows. */
 declare const UTILITY_VALUE_SPACES: ReadonlyMap<string, ValueSpaceSpec>;
 interface EnumeratedClass {
     name: string;
@@ -324,6 +364,44 @@ interface ClassEnumeration {
  */
 declare function enumerateClassNames(theme: ResolvedTheme): ClassEnumeration;
 
+/**
+ * analyzeMerge() — editor-only merge diagnostics.
+ *
+ * Explains ri()'s right-most-wins conflict resolution by threading a
+ * MergeTrace through the shared merge loop. Split from merge/index.ts so the
+ * browser-facing runtime file stays free of editor-only analysis; consumed by
+ * editor/session.ts and the editor entry.
+ */
+
+interface MergeDrop {
+    index: number;
+    className: string;
+    /** Ascending indices of the surviving classes that together claimed every
+     *  CSS property this class sets (px-4 + py-4 jointly dominate p-2). */
+    overriddenBy: number[];
+}
+interface MergeAnalysis {
+    /** The merged output — identical to ri()'s result for this token list. */
+    output: string;
+    /** Indices of surviving classes, ascending. */
+    kept: number[];
+    /** Dropped classes with attribution, ascending by index. */
+    dropped: MergeDrop[];
+}
+/**
+ * Explain ri()'s conflict resolution for a list of class tokens — which
+ * classes the right-most-wins scan drops, and which survivors claimed their
+ * properties. Powers "this class is overridden" editor diagnostics.
+ *
+ * Unlike ri(), the input is pre-tokenized: one class per element, no falsy
+ * filtering, no whitespace splitting — exactly the token list an editor
+ * extracts from one class attribute. `snapshot` binds custom utilities, text
+ * sizes, and color names the same way createRi(snapshot) does (editors build
+ * one with createThemeSnapshot()); without it, the module-level state of the
+ * most recent compile applies. Uncached — call sites own their memoization.
+ */
+declare function analyzeMerge(classes: readonly string[], snapshot?: CompilationSnapshot): MergeAnalysis;
+
 /**
  * Color swatches and theme-token introspection for editor tooling.
  *
@@ -461,4 +539,4 @@ declare const EDITOR_API_VERSION = 1;
 /** Feature-detection roster for this entry. */
 declare const editorCapabilities: readonly string[];
 
-export { CANONICAL_COLOR_STOPS, CLASS_HELPER_NAMES, CSS_ENTRY_CANDIDATES, type CandidateOrigin, type ClassCandidate, type ClassEnumeration, type ClassExplanation, type ClassInspector, type ClassTemplate, type ClassValidation, ColorDefinition, type ColorSwatch, CompilationSnapshot, type Diagnostic, type DiagnosticSeverity, EDITOR_API_VERSION, type EditorSession, type EnumeratedClass, MergeAnalysis, ParsedDirective, type ParsedUtility, type ProjectAnalysis, RI_IMPORT_SPECIFIERS, ResolvedTheme, type SourceExtractionInput, type SwatchColor, type ThemeTokens, UTILITY_VALUE_SPACES, VARIANT_HELPER_NAMES, type ValueSpaceKind, type ValueSpaceSpec, type VariantInfo, type VariantKind, analyzeProjectCSS, createClassInspector, createEditorSession, cssColorToHex, diagnosticFromWarning, editorCapabilities, enumerateClassNames, expandVariantGroups, extractClassCandidates, extractClasses, extractClassesFromSource, findClosest, hasRIActivation, isSourceFile, listThemeTokens, listVariants, oklchToHex, parseUtility, resolveColorSwatch, severityForCode, version, warningCode };
+export { CANONICAL_COLOR_STOPS, CLASS_HELPER_NAMES, CSS_ENTRY_CANDIDATES, type CandidateOrigin, type ClassCandidate, type ClassEnumeration, type ClassExplanation, type ClassInspector, type ClassTemplate, type ClassValidation, ColorDefinition, type ColorSwatch, CompilationSnapshot, type Diagnostic, type DiagnosticSeverity, EDITOR_API_VERSION, type EditorSession, type EnumeratedClass, type MergeAnalysis, type MergeDrop, ParsedDirective, type ParsedUtility, type ProjectAnalysis, RI_IMPORT_SPECIFIERS, ResolvedTheme, type SourceExtractionInput, type SwatchColor, type ThemeTokens, UTILITY_VALUE_SPACES, VARIANT_HELPER_NAMES, type ValueSpaceKind, type ValueSpaceSpec, type VariantInfo, type VariantKind, analyzeMerge, analyzeProjectCSS, createClassInspector, createEditorSession, cssColorToHex, diagnosticFromWarning, editorCapabilities, enumerateClassNames, expandVariantGroups, extractClassCandidates, extractClasses, extractClassesFromSource, findClosest, hasRIActivation, isSourceFile, listThemeTokens, listVariants, oklchToHex, parseUtility, resolveColorSwatch, severityForCode, version, warningCode };

package/dist/editor.mjs

@@ -2,7 +2,10 @@ import {
   CSS_ENTRY_CANDIDATES,
   UTILITY_VALUE_SPACES,
   enumerateClassNames
-} from "./chunk-KYDEHYIE.mjs";
+} from "./chunk-YLB6FGIG.mjs";
+import {
+  isSourceFile
+} from "./chunk-3HRMFZGE.mjs";
 import {
   CLASS_HELPER_NAMES,
   RI_IMPORT_SPECIFIERS,
@@ -20,22 +23,22 @@ import {
   extractClassesFromSource,
   findClosest,
   hasRIActivation,
-  isSourceFile,
   listVariants,
   parseUtility,
   severityForCode,
   warningCode
-} from "./chunk-W6XIBM4M.mjs";
+} from "./chunk-6DAHUFNU.mjs";
 import {
-  analyzeMerge,
   computeDarkStop,
   defaultTheme,
   formatOklch,
   generateStop,
   linearToSrgb,
+  mergeUncached,
   oklabToLinearSrgb,
-  oklchToOklab
-} from "./chunk-SOMDX7V6.mjs";
+  oklchToOklab,
+  resolverFor
+} from "./chunk-5Y7EXXLS.mjs";
 
 // src/engine/inspector.ts
 var RESOLUTION_CACHE_CAP = 1e4;
@@ -57,16 +60,22 @@ function createClassInspector(theme) {
   }
   function variantSuggestionCorpus() {
     if (!variantNames) {
-      variantNames = variants().filter((v) => v.kind !== "pattern").map((v) => v.name);
+      const names = [];
+      for (const v of variants()) {
+        if (v.kind !== "pattern") names.push(v.name);
+      }
+      variantNames = names;
     }
     return variantNames;
   }
   function utilitySuggestionCorpus() {
     if (!utilityCorpus) {
-      utilityCorpus = [
-        ...STATIC_UTILITIES,
-        ...theme.customUtilities.filter((u) => !u.functional).map((u) => u.name)
-      ];
+      const names = new Set(STATIC_UTILITIES);
+      for (const custom of theme.customUtilities) {
+        if (!custom.functional) names.add(custom.name);
+      }
+      for (const entry of enumerateClassNames(theme).classes) names.add(entry.name);
+      utilityCorpus = [...names];
     }
     return utilityCorpus;
   }
@@ -153,6 +162,28 @@ function createClassInspector(theme) {
   };
 }
 
+// src/merge/analyze.ts
+function analyzeMerge(classes, snapshot) {
+  const resolve = resolverFor(snapshot);
+  const trace = { claimers: /* @__PURE__ */ new Map(), dropped: [] };
+  const output = mergeUncached(classes, resolve, trace);
+  trace.dropped.sort((a, b) => a.index - b.index);
+  const droppedIndexes = new Set(trace.dropped.map((d) => d.index));
+  const kept = [];
+  for (let i = 0; i < classes.length; i++) {
+    if (!droppedIndexes.has(i)) kept.push(i);
+  }
+  return {
+    output,
+    kept,
+    dropped: trace.dropped.map((d) => ({
+      index: d.index,
+      className: classes[d.index],
+      overriddenBy: d.overriddenBy
+    }))
+  };
+}
+
 // src/theme/swatch.ts
 var CANONICAL_COLOR_STOPS = Object.freeze([
   50,
@@ -352,10 +383,11 @@ function createEditorSession(options = {}) {
 }
 
 // src/entries/editor.ts
-var version = true ? "0.2.2" : "0.0.0-dev";
+var version = true ? "0.4.0" : "0.0.0-dev";
 var EDITOR_API_VERSION = 1;
 var editorCapabilities = Object.freeze([
   "class-candidates",
+  "candidate-call-ids",
   "css-entry-detection",
   "theme-analysis",
   "class-inspection",

package/dist/{index-DK6APAGD.d.ts → index-BB2HoeMj.d.ts}

@@ -1,4 +1,4 @@
-import { C as ColorDefinition, l as DarkModeConfig, m as CornerShape, A as AnimationDefinition, F as FluidConfig, b as CompilationSnapshot } from './index-CfDtWufj.js';
+import { C as ColorDefinition, D as DarkModeConfig, j as CornerShape, A as AnimationDefinition, F as FluidConfig, b as CompilationSnapshot } from './context-ruu2x_jR.js';
 
 /** Provider discriminant for a slot, derived from its faces. */
 type FontProviderKind = "google" | "system" | "local" | "manual";

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { PluginCreator } from 'postcss';
-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';
+export { C as ColorDefinition, a as CompilationContext, b as CompilationSnapshot, F as FluidConfig, T as TextSize, c as Theme, d as createCompilationContext, e as defaultTheme, f as finalizeCompilationContext, r as registerColorNames, g as registerCustomFontFamilies, h as registerCustomTextSizes, i as registerCustomUtility } from './context-ruu2x_jR.js';
+export { D as DEFAULT_TEXT_SIZES, c as createRi, r as ri, s as safelist } from './safelist-D9-Plqta.js';
+import { R as ResolvedTheme, P as ParsedDirective } from './index-BB2HoeMj.js';
+export { C as CompilationResult, a as CompiledRule, c as createCompiler } from './index-BB2HoeMj.js';
 
 interface RainbowIndexOptions {
     sources?: string[];

package/dist/index.mjs

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

package/dist/safelist-D9-Plqta.d.ts

@@ -0,0 +1,109 @@
+import { b as CompilationSnapshot } from './context-ruu2x_jR.js';
+
+/**
+ * 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.
+ *
+ * This file is the pure merge runtime. Its siblings hold the other merge
+ * concepts: props.ts (claim data), resolve.ts (dual-mode claim resolution),
+ * context.ts (compilation-context lifecycle + published state), analyze.ts
+ * (editor-only merge diagnostics).
+ *
+ * ## 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[];
+
+/**
+ * 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;
+
+/**
+ * Claim resolution for ri() — utility name → CSS properties it sets.
+ *
+ * Split from merge/index.ts so each merge file is one concept: this file owns
+ * the dual-mode dispatch tables and resolvePropsWith(); index.ts owns the
+ * merge algorithm; context.ts owns the compilation-context lifecycle.
+ *
+ * Everything here is immutable module-init data plus pure closures over it —
+ * the mutable published compilation state lives in context.ts, and callers
+ * thread it in through resolvePropsWith()'s parameters.
+ */
+declare const DEFAULT_TEXT_SIZES: readonly ["xs", "sm", "base", "lg", "xl", "2xl", "3xl", "4xl", "5xl"];
+
+/**
+ * `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 { DEFAULT_TEXT_SIZES as D, createRi as c, ri as r, safelist as s };