rainbowindex 0.6.0 → 0.7.0

package/dist/session-CMaskdB7.d.ts

@@ -0,0 +1,543 @@
+import { R as ResolvedTheme, I as ImportResolver } from './imports-C9esHd5Q.js';
+import { a as CompilationSnapshot } from './context-DcBtnnan.js';
+import { C as ColorDefinition } from './index-Czx-EUwh.js';
+
+/** Where a candidate was found. "expression" marks a string literal sitting
+ *  in a JS expression position that cannot be a class list — today, an
+ *  operand of `==`/`!=` (`mode === "default"`). It is NOT a certain origin:
+ *  editors should treat it like "plain" and never report it as a bad class. */
+type CandidateOrigin = "attribute" | "helper" | "safelist" | "plain" | "expression";
+interface ClassCandidate {
+    /** The class string in expanded form — for variant-group members this
+     *  includes the group prefix (`hover:bg-red-500`) even though the span
+     *  covers only the member token inside the braces. */
+    value: string;
+    /** Absolute [start, end) span of the visible token in the original source.
+     *  `source.slice(start, end)` is the member token for group members and
+     *  `value` itself everywhere else. */
+    start: number;
+    end: number;
+    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;
+    };
+}
+
+/**
+ * Structured diagnostics — the typed view of the `[RI-NNNN] message` warning
+ * strings, for editor tooling that anchors problems to source spans.
+ *
+ * The legacy string arrays stay the wire format everywhere (and the warning
+ * budget/dedup in warnings.ts keeps operating on them); a Diagnostic carries
+ * the same full message text verbatim, plus the parsed code, a severity
+ * derived from the documented code-range convention, and — when the emission
+ * site knew one — a [start, end) span into the CSS input. Consumers can rely
+ * on `diagnostics[i].message === warnings[i]` wherever both are returned.
+ */
+type DiagnosticSeverity = "error" | "warning";
+interface Diagnostic {
+    /** The RI-NNNN code, or null when the message carries no parseable code. */
+    code: string | null;
+    severity: DiagnosticSeverity;
+    /** The full legacy warning text, including the `[RI-NNNN]` prefix. */
+    message: string;
+    /** [start, end) span in the analyzed CSS input, or null when unknown. */
+    start: number | null;
+    end: number | null;
+}
+/** Extract the RI-NNNN code from a legacy warning string, or null. */
+declare function warningCode(message: string): string | null;
+/**
+ * Severity by code range — the same convention warnings.ts budgets by:
+ * RI-0xxx (fatal/bootstrap) and RI-2xxx (compile/runtime errors) are errors,
+ * everything else (informational 1xxx ranges) is a warning.
+ */
+declare function severityForCode(code: string | null): DiagnosticSeverity;
+/** Wrap a legacy warning string as a Diagnostic, with an optional span. */
+declare function diagnosticFromWarning(message: string, span?: readonly [number, number] | null): Diagnostic;
+
+/**
+ * Parses utility class strings into structured tokens.
+ *
+ * "hover:bg-red-500"  → { variants: ["hover"], utility: "bg", value: "red-500" }
+ * "sm:p-4"            → { variants: ["sm"], utility: "p", value: "4" }
+ * "text-center!"      → { variants: [], utility: "text-center", value: null, important: true }
+ * "p-[13px]"          → { variants: [], utility: "p", value: "[13px]", arbitrary: true }
+ * "@md:flex"           → { variants: ["@md"], utility: "flex", value: null }
+ * "pl-physical-4"     → { variants: [], utility: "pl", value: "4", physical: true }
+ */
+interface ParsedUtility {
+    /** Original class string before parsing */
+    raw: string;
+    /** Variant prefixes in order, e.g. ["hover"], ["sm", "hover"] */
+    variants: string[];
+    /** The utility name (everything before the value separator), e.g. "bg", "p", "text" */
+    utility: string;
+    /** The value part after the last `-`, or null for valueless utilities like "flex" */
+    value: string | null;
+    /** Whether the value is an arbitrary bracket expression like [13px] */
+    arbitrary: boolean;
+    /** Whether !important is applied */
+    important: boolean;
+    /** Whether the -physical- infix is present */
+    physical: boolean;
+    /** Whether the utility is negative (prefixed with -) */
+    negative: boolean;
+    /** When the class is an arbitrary property like [color:red] */
+    arbitraryProperty: {
+        property: string;
+        value: string;
+    } | null;
+    /**
+     * Explicit type hint extracted from an arbitrary value, e.g. the `length`
+     * in `border-[length:1rem]` or `border-(color:--my-color)`. When set, it
+     * forces a specific dispatch path in generators — see `borderGenerator`,
+     * `colorGenerator`, etc. Null when no hint was provided.
+     */
+    dataType: string | null;
+}
+/**
+ * Parse a single utility class string into its structural components.
+ */
+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;
+}
+
+/**
+ * Variant resolution — maps variant names to CSS wrappers.
+ *
+ * Handles pseudo-classes, pseudo-elements, media queries, responsive breakpoints,
+ * container queries, data/aria attributes, :has()/:not(), arbitrary variants,
+ * and custom variants.
+ */
+
+type VariantKind = "pseudo-class" | "pseudo-element" | "media" | "breakpoint" | "container" | "special" | "custom" | "pattern";
+interface VariantInfo {
+    /** The variant as typed before the `:` — for patterns, the family prefix. */
+    name: string;
+    kind: VariantKind;
+    /** What the variant emits — a selector suffix, an at-rule, or (for
+     *  patterns) a description of the accepted form. */
+    wraps: string;
+}
+/**
+ * Enumerate every concrete variant the given theme resolves, plus the
+ * open-ended pattern families. Concrete entries (kind ≠ "pattern") are
+ * guaranteed to resolve via resolveVariant — the list mirrors its checks,
+ * including the CSS-length guard on breakpoint values.
+ */
+declare function listVariants(theme: ResolvedTheme): VariantInfo[];
+
+/**
+ * Class inspector — single-class validation and explanation for editor
+ * tooling, running the exact resolution the compile loop performs.
+ *
+ * The compiler intentionally drops unknown utilities silently (reserved
+ * RI-1001): the build scanner over-collects, so at build time an unresolved
+ * candidate is usually noise. Inside an editor the certainty is inverted — a
+ * token in a class attribute is meant to be a class — so the inspector
+ * finally gives RI-1001 a voice: `validate()` reports WHY a class produces no
+ * CSS, with a typo suggestion when one is close enough.
+ *
+ * An inspector instance owns the per-theme caches the compile loop rebuilds
+ * per pass (custom-variant map, variant memo, breakpoint weights) plus a
+ * resolution cache, so per-keystroke validation of the same classes is cheap.
+ * Create one per theme and drop it when the theme changes.
+ */
+
+type ClassValidation = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "unknown-utility" | "unknown-variant" | "invalid-arbitrary";
+    /** The failing fragment — the variant for "unknown-variant", the
+     *  base class (variants stripped) otherwise. */
+    offender: string;
+    /** Closest known name within typo distance, when one exists. */
+    suggestion?: string;
+};
+interface ClassExplanation {
+    parsed: ParsedUtility;
+    /** Root declarations before variant wrapping. */
+    declarations: CSSDeclaration[];
+    /** Escaped selector, including variant suffixes (`.hover\:px-2:hover`). */
+    selector: string;
+    /** The complete rule text, including wrapping at-rules. */
+    css: string;
+    /** Deterministic ordering key — lower emits earlier in generated CSS. */
+    sortKey: number;
+    /**
+     * A marker class (`group`, `peer/sidebar`): valid, and wearing no CSS of its
+     * own. `declarations` is empty and `css` is "", so a caller rendering a
+     * preview shows nothing; `selector` is the anchor a `group-*` / `peer-*`
+     * variant matches on this element.
+     */
+    marker?: true;
+}
+interface ClassInspector {
+    readonly theme: ResolvedTheme;
+    /** Would this class produce CSS under the theme? Reports why not. */
+    validate(className: string): ClassValidation;
+    /** Structured breakdown + generated CSS, or null when invalid. */
+    explain(className: string): ClassExplanation | null;
+    /** Every variant the theme resolves (cached). */
+    variants(): readonly VariantInfo[];
+}
+declare function createClassInspector(theme: ResolvedTheme): ClassInspector;
+
+/**
+ * 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" | "fluid-range" | "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.
+ *
+ * Design: candidates are generated from a deliberately GENEROUS value-space
+ * table (which theme namespaces and keyword families to TRY per functional
+ * 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 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.
+ */
+
+/** 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;
+    /** How the class was produced: a static table, a custom @utility, or the
+     *  value-space kind that filled the functional root. */
+    kind: ValueSpaceKind | "static" | "custom";
+    /** The functional root, or null for statics/custom statics. */
+    root: string | null;
+}
+interface ClassTemplate {
+    root: string;
+    /** The open-ended space: numeric spacing scale, plain numbers, or a
+     *  functional custom utility that accepts any suffix. */
+    kind: "spacing" | "number" | "custom";
+    example: string;
+}
+interface ClassEnumeration {
+    /** Every finite concrete class, probed valid, sorted by name. */
+    classes: EnumeratedClass[];
+    /** Families whose value space is infinite — offer as snippets. */
+    templates: ClassTemplate[];
+}
+/**
+ * Enumerate the finite completion universe for a theme. Every returned class
+ * has been resolved by the real utility resolver — `validate()` accepts each
+ * one by construction. Infinite families (the spacing scale, numeric values,
+ * functional custom utilities) come back as templates; a template is emitted
+ * only when at least one of its probes resolved.
+ */
+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.
+ *
+ * Resolves a theme color (and stop) to concrete light/dark colors — the same
+ * OKLCH math the CSS variable emitter uses (generateStop / computeDarkStop),
+ * plus an sRGB hex conversion for completion-item swatches and sidebar chips.
+ * Pure computation, no IO.
+ */
+
+/** The canonical palette stops every generative color defines. */
+declare const CANONICAL_COLOR_STOPS: readonly number[];
+/** Convert an OKLCH color to a #rrggbb hex string (sRGB, channel-clamped). */
+declare function oklchToHex(l: number, c: number, h: number): string;
+/** Best-effort hex for the CSS color texts theme definitions hold: `oklch()`
+ *  and hex literals. Anything else (named colors, rgb(), vars) returns null —
+ *  the raw CSS text still travels alongside. */
+declare function cssColorToHex(css: string): string | null;
+interface SwatchColor {
+    /** CSS color text (`oklch(…)`, or the definition's own value verbatim). */
+    css: string;
+    /** sRGB hex, or null when the CSS text isn't convertible. */
+    hex: string | null;
+}
+interface ColorSwatch {
+    light: SwatchColor;
+    /** Null when the theme's dark mode is off or the color has no dark form. */
+    dark: SwatchColor | null;
+}
+/**
+ * Resolve a theme color name (+ stop, for generative palettes) to concrete
+ * light/dark swatch colors — exactly the values the emitted CSS variables
+ * carry. Theme-defined colors always win; the fixed semantic swatches
+ * (paper/ink/white/black) apply only when the theme does not define the name,
+ * mirroring the emitter (a user `@color { white: … }` palette emits
+ * `--color-white-*` variables that suffixed utilities resolve against).
+ * Returns null for unknown names, unresolvable aliases, and keyword colors
+ * with no concrete value (transparent, currentColor).
+ */
+declare function resolveColorSwatch(theme: ResolvedTheme, name: string, stop?: number): ColorSwatch | null;
+interface ThemeTokens {
+    /** Color names with their definition kind — pair with resolveColorSwatch. */
+    colors: Array<{
+        name: string;
+        kind: ColorDefinition["type"];
+    }>;
+    colorStops: readonly number[];
+    spacingBase: string;
+    textSizes: Array<{
+        name: string;
+        fontSize: string;
+        lineHeight: string;
+    }>;
+    breakpoints: Record<string, string>;
+    shadows: Record<string, string>;
+    weights: Record<string, number>;
+    easing: Record<string, string>;
+    blur: Record<string, string>;
+    z: Record<string, string>;
+    leading: Record<string, string>;
+    tracking: Record<string, string>;
+    opacity: Record<string, string>;
+    duration: Record<string, string>;
+    /** Named radii from `@rounded { roof: 24px; }` — the class is `rounded-roof`.
+     *  Unnamed radii are spacing multiples and carry no token. */
+    radii: Record<string, string>;
+    /** Named ranges from `@fluid <name> { min; max; }` — each one makes the scope
+     *  class `fluid-<name>`. A bound absent from the block is absent here. */
+    fluidRanges: Record<string, {
+        min?: string;
+        max?: string;
+    }>;
+    fonts: Array<{
+        slot: string;
+        family: string;
+    }>;
+    animations: string[];
+}
+/** One render-ready view of a theme's token namespaces for sidebar chips and
+ *  completion detail — plain data, no theme internals to traverse. */
+declare function listThemeTokens(theme: ResolvedTheme): ThemeTokens;
+
+/**
+ * `renderStylesheet` — a theme plus a class list in, a stylesheet out.
+ *
+ * The rest of `rainbowindex/editor` answers questions *about* classes:
+ * is this one valid, what does it mean, what could you type next. This one
+ * produces the artifact itself, which is what a playground, a docs example,
+ * and a "show me the generated CSS" hover all need.
+ *
+ * It is the pure core of the build pipeline: the same `createCompiler()` and
+ * `assembleSections()` the PostCSS plugin and the CLI run, with the two steps
+ * that touch the world left out.
+ *
+ *   - **Fonts are not resolved.** `@font … from google` needs the Google
+ *     metadata endpoint to narrow a family's weights, which is IO. The slot
+ *     still emits its `@import` and its `--font-*` variable; only the weight
+ *     narrowing is missing, so the sheet differs from a Node build only for a
+ *     Google slot whose declared weights the provider would have trimmed.
+ *   - **`@apply` is not expanded.** That rewrite is PostCSS's job — it edits
+ *     the user's own rules in place — and pulling PostCSS in would double the
+ *     weight of an entry that exists to stay small. An `@apply` left in
+ *     `userCSS` passes through verbatim.
+ *
+ * Everything else — token pruning, `@property` registration, preflight,
+ * `[data-theme]` overrides, rule ordering — is the production path.
+ */
+
+interface RenderStylesheetOptions {
+    /**
+     * Classes the user wrote by hand, when that is a subset of `classNames`.
+     * Diagnostics that would be noise for a generated class — an unknown
+     * utility inside a scanned template literal, say — are raised only for
+     * these. Omit to treat every class as authored.
+     */
+    authoredClassNames?: ReadonlySet<string>;
+    /**
+     * The project's own CSS, with RI directives already removed (the entry's
+     * `stripRIDirectives` does that). It is scanned for `var(--color-…)` and
+     * friends before assembly, so a token only the user's CSS names survives
+     * pruning, and it is appended to the output after the generated sections —
+     * the same order a real build emits.
+     */
+    userCSS?: string;
+}
+interface RenderedStylesheet {
+    /** The generated sections and `userCSS`, joined as a build would emit them. */
+    css: string;
+    /** Generated output only, in canonical section order. */
+    sections: string[];
+    /** `userCSS` after `--ri-*` CSS functions were compiled, or "". */
+    userCSS: string;
+    /** Compile and assembly warnings, in `[RI-NNNN] message` form. */
+    warnings: string[];
+}
+/**
+ * Compile `classNames` against `theme` and assemble the stylesheet.
+ *
+ * Pure: no filesystem, no network, no module-level state. Two calls with the
+ * same arguments return the same CSS, and concurrent calls cannot see each
+ * other's fonts — the compiler owns its caches.
+ */
+declare function renderStylesheet(theme: ResolvedTheme, classNames: Iterable<string>, options?: RenderStylesheetOptions): RenderedStylesheet;
+
+/**
+ * Editor session — the façade that ties the editor toolkit together.
+ *
+ * An editor host holds one session per workspace, calls `setCss()` whenever
+ * the project's CSS entry changes, and everything else per keystroke. The
+ * session owns the caching story: theme analysis, the class inspector, the
+ * enumeration, token introspection, and the merge snapshot are computed
+ * lazily and invalidated together when the CSS changes — callers never
+ * juggle per-theme cache keys themselves. Every capability is also exported
+ * à la carte from `rainbowindex/editor` for hosts that want finer control.
+ *
+ * Pure computation, no IO: the host reads the CSS file (see
+ * CSS_ENTRY_CANDIDATES / hasRIActivation for locating it) and passes text.
+ */
+
+interface EditorSession {
+    /** The CSS input the session is currently analyzing. */
+    readonly css: string;
+    /** Swap the CSS input; all theme-derived caches invalidate together.
+     *  A no-op when the text is unchanged. */
+    setCss(css: string): void;
+    readonly theme: ResolvedTheme;
+    /** Positioned diagnostics for the CSS input (see ProjectAnalysis). */
+    readonly diagnostics: readonly Diagnostic[];
+    /** Single-class validation/explanation, cached per theme. */
+    readonly inspector: ClassInspector;
+    /** The finite completion universe + templates, cached per theme. */
+    enumerate(): ClassEnumeration;
+    /** Render-ready token namespaces, cached per theme. */
+    tokens(): ThemeTokens;
+    /** The merge snapshot for this theme, cached. */
+    snapshot(): CompilationSnapshot;
+    /** analyzeMerge bound to this theme's snapshot. */
+    analyzeMerge(classes: readonly string[]): MergeAnalysis;
+    /** Position-aware class extraction for a source document. */
+    extractCandidates(content: string, path?: string): ClassCandidate[];
+    /**
+     * Files pulled in by `@import`, in first-visit order, or empty when no
+     * resolver was supplied. A host watches these: editing an imported token
+     * file must invalidate the session just as editing the entry does.
+     */
+    readonly importedFiles: readonly string[];
+    /** Light/dark swatch for a theme color (+ stop), or null. */
+    swatch(name: string, stop?: number): ColorSwatch | null;
+    /**
+     * Compile `classNames` against this session's theme and assemble the
+     * stylesheet, the way a build would.
+     *
+     * `userCSS` defaults to this session's own CSS entry with the directives
+     * stripped — imports already inlined — so `session.render(classes)` on its
+     * own reproduces the project's sheet. Pass `userCSS: ""` for the generated
+     * output alone. See `renderStylesheet` for what a pure render leaves out.
+     */
+    render(classNames: Iterable<string>, options?: RenderStylesheetOptions): RenderedStylesheet;
+    /**
+     * Order a class list the way the generated stylesheet orders its rules,
+     * through this session's cached inspector. See `sortClasses` — in
+     * particular, do not sort a list that reaches `ri()`.
+     */
+    sortClasses(classNames: readonly string[]): string[];
+}
+declare function createEditorSession(options?: {
+    css?: string;
+    /**
+     * Turns an `@import` specifier into text, so directives in imported
+     * files reach the theme. Synchronous by design: the host already has
+     * its open documents in memory, and this entry does no IO of its own.
+     * Without one, imports pass through and their directives stay unread.
+     */
+    resolveImport?: ImportResolver;
+    /** Identity of the CSS entry — the base for relative specifiers. */
+    cssPath?: string;
+}): EditorSession;
+
+export { resolveColorSwatch as A, severityForCode as B, type ClassCandidate as C, type Diagnostic as D, type EditorSession as E, warningCode as F, type MergeAnalysis as M, type ParsedUtility as P, type RenderStylesheetOptions as R, type SwatchColor as S, type ThemeTokens as T, UTILITY_VALUE_SPACES as U, type ValueSpaceKind as V, CANONICAL_COLOR_STOPS as a, type CandidateOrigin as b, type ClassEnumeration as c, type ClassExplanation as d, type ClassInspector as e, type ClassTemplate as f, type ClassValidation as g, type ColorSwatch as h, type DiagnosticSeverity as i, type EnumeratedClass as j, type MergeDrop as k, type RenderedStylesheet as l, type ValueSpaceSpec as m, type VariantInfo as n, type VariantKind as o, analyzeMerge as p, createClassInspector as q, createEditorSession as r, cssColorToHex as s, diagnosticFromWarning as t, enumerateClassNames as u, listThemeTokens as v, listVariants as w, oklchToHex as x, parseUtility as y, renderStylesheet as z };