@tenphi/tasty 3.8.0 → 3.9.1

package/dist/{index-DBjd4MAb.d.ts → types-jKZNpias.d.ts}

@@ -1,599 +1,105 @@
 import { Properties } from "csstype";
 
-//#region src/properties/property-type-resolver.d.ts
-/**
- * PropertyTypeResolver
- *
- * Automatically infers CSS @property types from custom property values.
- * Supports deferred resolution for var() reference chains of arbitrary depth.
- */
-declare class PropertyTypeResolver {
-  /** propName → the prop it depends on */
-  private pendingDeps;
-  /** propName → list of props waiting on it */
-  private reverseDeps;
-  /**
-   * Scan CSS declarations and auto-register @property for custom properties
-   * whose types can be inferred from their values.
-   */
-  scanDeclarations(declarations: string, isPropertyDefined: (name: string) => boolean, registerProperty: (name: string, syntax: string, initialValue: string) => void): void;
-  private addDependency;
-  private resolve;
-  private isComplexValue;
-}
+//#region src/utils/css-types.d.ts
+interface CSSProperties extends Properties<string | number> {}
 //#endregion
-//#region src/injector/batch.d.ts
+//#region src/parser/types.d.ts
 /**
- * Deferred CSSOM writes ("batched injection").
- *
- * Every `insertRule()` on a live stylesheet invalidates style for the sheet's
- * scope, so Blink recalculates style the next time anything reads layout or
- * computed style. When components inject during React's render phase and other
- * components read layout in the same pass, the two interleave:
- *
- *   inject -> read (forced recalc) -> inject -> read (forced recalc) -> ...
- *
- * Batching moves every sheet write out from between those reads. Writes are
- * queued in FIFO order and drained in one go, so the tree is invalidated once
- * per flush instead of once per component.
- *
- * ## Ordering
- *
- * A single queue holds *all* writes — component rules, global rules, keyframes,
- * `@property`, `@font-face`, `@counter-style`, `@function` and raw CSS. Draining
- * it in insertion order keeps the sheet byte-identical to unbatched output,
- * which matters because equal-specificity rules resolve by document order.
- *
- * ## Batch windows — why queuing is safe
- *
- * Deferring a write past React's layout phase would let a `useLayoutEffect`
- * measure an element whose rules are not in the sheet yet, reading the unstyled
- * box. `<TastyBatchProvider>` closes that hole by opening a *window* during its
- * render and closing it — flushing — in its `useInsertionEffect`, which React
- * runs in the mutation phase, before any layout effect:
- *
- *   provider renders          -> window OPEN
- *     children render         -> injections queued
- *   provider insertionEffect  -> FLUSH, window CLOSED
- *   layout effects run        -> rules are in the sheet
- *
- * So in the default (`batchInjection: true`) mode a write is only ever queued
- * inside a commit whose flush is already guaranteed by that same commit. Every
- * injection outside a window — a deep update the provider did not re-render
- * for, a `useLayoutEffect` that injects, an event handler, an async callback —
- * is written straight through, exactly as with batching off.
- *
- * `batchInjection: 'always'` opts out of the gate and queues unconditionally.
- * That wins on more commits, at the cost of the measurement hazard above.
- *
- * ## Flush points (earliest wins)
- *
- * 1. `<TastyBatchProvider>`'s `useInsertionEffect` — closes the window.
- * 2. A microtask — a backstop for a render that was aborted or suspended and
- *    therefore never reached its insertion effect. An aborted render mounts
- *    nothing, so nothing can measure what it queued. Microtasks also always
- *    drain before paint, so styles are never visually missing.
- * 3. `flushStyles()` — explicit, and called internally by every injector read
- *    API (`getCSSText`, `cleanup`, `gc`, `destroy`, ...).
+ * A part within a group, representing a slash-separated segment.
+ * For example, in `'2px solid #red / 4px'`, there are two parts:
+ * - Part 0: `2px solid #red`
+ * - Part 1: `4px`
  */
-interface QueuedWrite {
-  /** Perform the deferred sheet write. */
-  run: () => void;
-  /** Set when the owner disposed before the write happened. */
-  cancelled: boolean;
-  /** Set once the write has been applied (or skipped as cancelled). */
-  done: boolean;
+interface StyleDetailsPart {
+  mods: string[];
+  values: string[];
+  colors: string[];
+  all: string[];
+  output: string;
 }
-/** Whether any write is still waiting to hit a stylesheet. */
-declare function hasPendingStyleWrites(): boolean;
-/**
- * Drain every pending sheet write, in insertion order.
- *
- * Safe to call when the queue is empty (the common case, so the guard comes
- * first) and safe to call re-entrantly: a nested `flushStyles()` is a no-op,
- * and work a draining write triggers is written in place by
- * `enqueueStyleWrite` rather than queued behind the rest of the batch.
- */
-declare function flushStyles(): void;
 /**
- * Drop every pending write without applying it. Test helper — production code
- * should call `flushStyles()` instead.
+ * A group of style details, representing a comma-separated segment.
+ * Contains aggregated values from all parts for backward compatibility,
+ * plus the structured `parts` array for handlers that need slash separation.
  */
-declare function resetStyleBatch(): void;
-//#endregion
-//#region src/injector/types.d.ts
-declare global {
-  interface Window {
-    __TASTY__?: string[];
-  }
+interface StyleDetails {
+  input: string;
+  output: string;
+  /** Aggregated mods from all parts (backward compatible) */
+  mods: string[];
+  /** Aggregated values from all parts (backward compatible) */
+  values: string[];
+  /** Aggregated colors from all parts (backward compatible) */
+  colors: string[];
+  /** Aggregated all tokens from all parts (backward compatible) */
+  all: string[];
+  /** Slash-separated parts within this group */
+  parts: StyleDetailsPart[];
 }
-interface InjectResult {
-  className: string;
-  dispose: () => void;
+interface ProcessedStyle {
+  output: string;
+  groups: StyleDetails[];
 }
-interface GlobalInjectResult {
-  dispose: () => void;
+type UnitHandler = (scalar: number) => string;
+interface ParserOptions {
+  functions?: Record<string, (parsed: StyleDetails[]) => string>;
+  units?: Record<string, string | UnitHandler>;
+  cacheSize?: number;
 }
-type DisposeFunction = () => void;
-interface StyleInjectorConfig {
-  nonce?: string;
-  maxRulesPerSheet?: number;
-  forceTextInjection?: boolean;
-  /** Enable development mode features: performance metrics and debug information storage */
-  devMode?: boolean;
-  /**
-   * Global predefined states for advanced state mapping.
-   * These are state aliases that can be used in any component.
-   * Example: { '@mobile': '@media(w < 920px)', '@dark': '@root(theme=dark)' }
-   */
-  states?: Record<string, string>;
-  /**
-   * Automatically infer and register CSS @property declarations
-   * from custom property values. When false, only explicit @property are used.
-   * @default true
-   */
-  autoPropertyTypes?: boolean;
-  /** Garbage collection configuration for unused styles */
-  gc?: GCConfig;
+//#endregion
+//#region src/parser/parser.d.ts
+declare class StyleParser {
+  private opts;
+  private cache;
+  constructor(opts?: ParserOptions);
+  process(src: string): ProcessedStyle;
+  setFunctions(functions: Required<ParserOptions>['functions']): void;
+  setUnits(units: Required<ParserOptions>['units']): void;
+  updateOptions(patch: Partial<ParserOptions>): void;
   /**
-   * Prefix prepended to every generated identifier.
-   * Mirrors the `namePrefix` field on the public `TastyConfig` so that
-   * standalone injector consumers can configure it directly.
-   * @default 't'
+   * Clear the parser cache.
+   * Call this when external state that affects parsing results has changed
+   * (e.g., predefined tokens).
    */
-  namePrefix?: string;
+  clearCache(): void;
   /**
-   * Defer stylesheet writes and apply them in one batch instead of one
-   * `insertRule()` per component. Mirrors `batchInjection` on the public
-   * `TastyConfig`.
-   * @default false
+   * Get the current units configuration.
    */
-  batchInjection?: boolean | 'always';
+  getUnits(): ParserOptions['units'];
 }
+//#endregion
+//#region src/utils/color-math.d.ts
 /**
- * Per-className usage tracking for GC.
+ * Consolidated color conversion math.
+ *
+ * Single source of truth for all color space conversions used across the
+ * library: sRGB gamma, HSL, OKLab, OKLCH, OKHSL, hex parsing, named
+ * colors, and CSS string converters.
+ *
+ * This module has zero internal imports — it is a leaf dependency.
+ *
+ * Reference: https://bottosson.github.io/posts/oklab/
  */
+type Vec3 = [number, number, number];
 /**
- * @deprecated Nothing reads this any more. Collection asks the DOM what is
- * rendered rather than tracking usage per class, so there is no usage record
- * to describe. Kept so existing imports keep type-checking.
+ * sRGB gamma to linear. Only the sRGB-to-OKLab direction needs it, so this is
+ * test-only for the same reason as {@link srgbToOkhsl} — the forward path goes
+ * through {@link srgbLinearToGamma} instead.
  */
-interface StyleUsage {
-  lastTouchedAt: number;
-}
 /**
- * Configuration for the style garbage collector.
+ * HSL to RGB.
+ * Algorithm from CSS Color 4 spec.
  *
- * GC is triggered by touch count rather than timers: every `touchInterval`
- * touches, an idle callback is scheduled to evict unused styles above
- * `capacity`, oldest first.
+ * @param h - Hue in degrees (0-360)
+ * @param s - Saturation (0-1)
+ * @param l - Lightness (0-1)
+ * @returns RGB values in 0-255 range (may have fractional values)
  */
-interface GCConfig {
-  /**
-   * How long a class is left alone after collection first notices nothing is
-   * carrying it, in milliseconds (default 10,000).
-   *
-   * Rendering is not commit-aware: a render can resolve a class and commit it a
-   * little later, and in between nothing on the page carries it. Rather than
-   * try to tell that apart from a class that is finished — which cannot be done
-   * from outside React — collection simply does not touch anything that was in
-   * use recently. A render would have to stay pending for the whole window to
-   * lose its rules, and it gets them back on its next render.
-   */
-  grace?: number;
-  /**
-   * Number of touch events between automatic GC cycles.
-   * @default 1000
-   */
-  touchInterval?: number;
-  /**
-   * Maximum number of unused styles to retain.
-   * GC evicts the oldest unused styles when this limit is exceeded.
-   * Pinned styles and DOM-live styles
-   * do not count against this limit.
-   * @default 1000
-   */
-  capacity?: number;
-}
+declare function hslToRgbValues(h: number, s: number, l: number): Vec3;
+declare function getNamedColorHex(): Map<string, string>;
 /**
- * Per-call options for inject().
- */
-interface InjectOptions {
-  root?: Document | ShadowRoot;
-  /** Reuse the class already injected for this key instead of writing again. */
-  cacheKey?: string;
-  /**
-   * Pin the injected class (default `true`). A pinned class is never evicted by
-   * `gc()`, and the returned `dispose()` releases the pin. Pass `false` when the
-   * caller keeps no handle and the DOM is the only record that the class is in
-   * use — the render path does this, because a hook-free render has no unmount
-   * signal to dispose on.
-   */
-  pin?: boolean;
-}
-/**
- * Per-call options for gc().
- */
-interface GCOptions {
-  root?: Document | ShadowRoot;
-  /** Bypass capacity threshold and remove ALL unused styles. */
-  force?: boolean;
-}
-interface RuleInfo {
-  className: string;
-  ruleIndex: number;
-  sheetIndex: number;
-  /** Dev-only: full CSS texts inserted for this class; omitted in production */
-  cssText?: string[];
-  /** Inclusive end index of the contiguous block of inserted rules for this className */
-  endRuleIndex?: number;
-  /** NEW: exact indices of all inserted rules for this className */
-  indices?: number[];
-}
-type InjectionMode = 'style-element' | 'adopted';
-interface SheetInfo {
-  /** HTMLStyleElement used in style-element mode; null in adopted mode. */
-  sheet: HTMLStyleElement | null;
-  /** Constructable CSSStyleSheet used in adopted mode (ShadowRoot targets) */
-  constructableSheet?: CSSStyleSheet;
-  ruleCount: number;
-  holes: number[];
-  /**
-   * True when this sheet is written through `textContent` instead of CSSOM.
-   * Decided once at sheet creation so a sheet is never half CSSOM / half text.
-   */
-  textMode?: boolean;
-  /**
-   * Inserted rule texts in rule-index order. Maintained only in text mode —
-   * it is what makes deletion possible there, since `textContent` cannot be
-   * edited rule-by-rule and has to be rebuilt.
-   */
-  textRules?: string[];
-}
-interface CleanupStats {
-  timestamp: number;
-  classesDeleted: number;
-  cssSize: number;
-  rulesDeleted: number;
-}
-interface CacheMetrics {
-  hits: number;
-  misses: number;
-  bulkCleanups: number;
-  totalInsertions: number;
-  totalUnused: number;
-  stylesCleanedUp: number;
-  cleanupHistory: CleanupStats[];
-  startTime: number;
-  unusedHits?: number;
-}
-interface RootRegistry {
-  sheets: SheetInfo[];
-  /** className -> outstanding `inject()` references; 0 means nobody holds a handle */
-  pinCounts: Map<string, number>;
-  rules: Map<string, RuleInfo>;
-  /** Cache key to className mapping to avoid dual storage of RuleInfo objects */
-  cacheKeyToClassName: Map<string, string>;
-  /** Deduplication set of fully materialized CSS rules inserted into sheets */
-  ruleTextSet: Set<string>;
-  /** Performance metrics (optional) */
-  metrics?: CacheMetrics;
-  /** Keyframes cache by content hash -> entry */
-  keyframesCache: Map<string, KeyframesCacheEntry>;
-  /** Keyframes name to content hash mapping for collision detection */
-  keyframesNameToContent: Map<string, string>;
-  /** Counter for generating keyframes names like k0, k1, k2... */
-  keyframesCounter: number;
-  /** Map of injected @property names to their normalized declarations for tracking */
-  injectedProperties: Map<string, string>;
-  /** Content hashes of injected @font-face rules for deduplication */
-  injectedFontFaces: Set<string>;
-  /**
-   * Injected @counter-style rules. Maps the name to whether it was injected
-   * "strong" (`true`, the default — overrides) or "weak" (`false`, global
-   * `configure()` definitions that never clobber an existing rule).
-   */
-  injectedCounterStyles: Map<string, boolean>;
-  /**
-   * Injected @function rules. Maps the CSS function name to whether it was
-   * injected "strong" (`true`, the default — overrides) or "weak" (`false`,
-   * global `configure()` definitions that never clobber an existing rule).
-   */
-  injectedFunctions: Map<string, boolean>;
-  /** Global rules tracking for index adjustment */
-  globalRules: Map<string, RuleInfo>;
-  /** Resolver for auto-inferring @property types from declaration values */
-  propertyTypeResolver: PropertyTypeResolver;
-  /**
-   * className -> when the class was first noticed to be carrying nothing:
-   * injection, or the first sweep that looked and did not find it on an
-   * element. Cleared the moment a sweep finds it rendered again.
-   *
-   * Deliberately "when it was noticed", not "when it stopped being rendered".
-   * Nothing observes the moment an element leaves, so a class that unmounted
-   * just before a sweep and one that unmounted just after the previous sweep
-   * would otherwise be treated differently — and the first would lose its
-   * grace window entirely. Starting the clock at the sighting gives every
-   * class the same full window, whenever it actually went.
-   *
-   * Written only by the sweep's own DOM scan and at injection, so rendering
-   * never pays for it.
-   */
-  unusedSince: Map<string, number>;
-  /**
-   * Local `@keyframes` a class animates, by the name they were authored under.
-   *
-   * One reference is held per distinct set of steps, however many renders ask
-   * for it, and the classes that animate it own that reference between them.
-   * The last of them to be deleted releases it, so keyframes cannot outlive
-   * every rule that referred to them, and repeat renders cannot pile up
-   * references nobody gives back.
-   */
-  localKeyframes: Map<string, {
-    name: string;
-    dispose: () => void;
-    owners: Set<string>;
-  }>;
-  /** Renders since the last scheduled sweep (per-root) */
-  touchCount: number;
-  /** How many entries from `window.__TASTY__` have been synced into this registry */
-  serverClassSyncIndex: number;
-  /** Whether `<style data-tasty-rsc>` tags have been scanned for class names */
-  rscStylesScanned: boolean;
-  /** Whether this root uses adoptedStyleSheets or <style> elements */
-  injectionMode: InjectionMode;
-  /**
-   * Lazy feature-test for `@property` support, cached per registry.
-   * - `undefined`: not yet probed.
-   * - `true`: engine supports `@property`; rejections indicate user-authored
-   *   invalid rules and should warn.
-   * - `false`: engine doesn't support `@property` (e.g., jsdom); rejections
-   *   are expected and warnings are suppressed.
-   */
-  atPropertySupported?: boolean;
-}
-type StyleRule = StyleResult;
-interface KeyframesInfo {
-  name: string;
-  sheetIndex: number;
-  ruleIndex: number;
-  /** Dev-only: full CSS text of the @keyframes rule; omitted in production */
-  cssText?: string;
-}
-type KeyframeStep = string | Record<string, string | number>;
-type KeyframesSteps = Record<string, KeyframeStep>;
-interface KeyframesResult {
-  toString(): string;
-  dispose: () => void;
-}
-interface KeyframesCacheEntry {
-  name: string;
-  refCount: number;
-  info: KeyframesInfo;
-  /**
-   * Queued sheet write, when `batchInjection` deferred the insertion. Present
-   * only between `keyframes()` and the flush; disposing in that window cancels
-   * the write instead of deleting a rule that was never inserted.
-   */
-  pending?: QueuedWrite;
-}
-/**
- * Definition for a CSS @property at-rule.
- * Used to define custom property syntax, inheritance, and initial value.
- */
-interface PropertyDefinition {
-  /** CSS syntax string (e.g., '<color>', '<angle>', '<number>') */
-  syntax?: string;
-  /** Whether the property inherits (default: true) */
-  inherits?: boolean;
-  /** Initial value for the property */
-  initialValue?: string | number;
-}
-/**
- * Options for registering a CSS `@property`.
- * Extends {@link PropertyDefinition} with an optional injection root.
- */
-interface PropertyOptions extends PropertyDefinition {
-  /** Shadow root or document to inject into */
-  root?: Document | ShadowRoot;
-}
-/**
- * A single parameter for a CSS @function at-rule.
- *
- * - `true` — a bare parameter with no type or default.
- * - `string` — a CSS type shorthand (e.g. `'<length>'`, `'<color>'`).
- * - object — full form with optional `syntax` (type) and `default` value.
- */
-type FunctionParameter = true | string | {
-  syntax?: string;
-  default?: string | number;
-};
-/**
- * Definition for a CSS @function at-rule (custom function).
- *
- * The descriptor body reads like a mini styles object: any `$name` key declares
- * a local variable (`--name`) whose value is parsed through the Tasty DSL.
- * `result` is the only required field.
- *
- * @example
- * ```ts
- * // @function --negative(--value) { result: calc(-1 * var(--value)); }
- * { args: ['$value'], result: '(-1 * $value)' }
- * ```
- */
-interface FunctionDefinition {
-  /**
-   * Ordered parameters. Array form lists bare parameter names (`['$value']`);
-   * object form maps each parameter name to its type/default.
-   */
-  args?: string[] | Record<string, FunctionParameter>;
-  /** Optional return type, e.g. `'<color>'`. */
-  returns?: string;
-  /** The `result:` descriptor value (parsed through the Tasty DSL). Required. */
-  result: string;
-  /** Local variables: any `$name` key declares `--name` in the body. */
-  [localVar: `$${string}`]: string | number | undefined;
-}
-/**
- * Descriptors for a CSS @font-face at-rule.
- */
-interface FontFaceDescriptors {
-  /** Required. URL(s) to the font file(s). */
-  src: string;
-  /** Font weight or range. Default: 'normal'. */
-  fontWeight?: string | number;
-  /** Font style. Default: 'normal'. */
-  fontStyle?: 'normal' | 'italic' | 'oblique' | (string & {});
-  /** Font stretch. Default: 'normal'. */
-  fontStretch?: string;
-  /** Loading behavior. Default: 'auto'. */
-  fontDisplay?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
-  /** Unicode range to cover. */
-  unicodeRange?: string;
-  /** Ascent metric override. */
-  ascentOverride?: string;
-  /** Descent metric override. */
-  descentOverride?: string;
-  /** Line gap metric override. */
-  lineGapOverride?: string;
-  /** Size adjustment factor. */
-  sizeAdjust?: string;
-  /** OpenType feature settings. */
-  fontFeatureSettings?: string;
-  /** Font variation axis settings. */
-  fontVariationSettings?: string;
-}
-/** Single descriptor or array of descriptors for multiple weights/styles. */
-type FontFaceInput = FontFaceDescriptors | FontFaceDescriptors[];
-/**
- * Descriptors for a CSS @counter-style at-rule.
- */
-interface CounterStyleDescriptors {
-  /** Required. Numbering algorithm. */
-  system: 'cyclic' | 'numeric' | 'alphabetic' | 'symbolic' | 'additive' | 'fixed' | (string & {});
-  /** Symbols for non-additive systems. */
-  symbols?: string;
-  /** Symbol-value pairs for additive system. */
-  additiveSymbols?: string;
-  /** String prepended to the marker. Default: "". */
-  prefix?: string;
-  /** String appended to the marker. Default: ". ". */
-  suffix?: string;
-  /** Negative-value wrapping (e.g., '"(" ")"'). */
-  negative?: string;
-  /** Counter range (e.g., 'infinite infinite'). */
-  range?: string;
-  /** Minimum marker width and pad symbol (e.g., '3 "0"'). */
-  pad?: string;
-  /** Fallback counter style name. */
-  fallback?: string;
-  /** Speech synthesis hint. */
-  speakAs?: string;
-}
-interface RawCSSResult {
-  dispose: () => void;
-}
-//#endregion
-//#region src/utils/css-types.d.ts
-interface CSSProperties extends Properties<string | number> {}
-//#endregion
-//#region src/parser/types.d.ts
-/**
- * A part within a group, representing a slash-separated segment.
- * For example, in `'2px solid #red / 4px'`, there are two parts:
- * - Part 0: `2px solid #red`
- * - Part 1: `4px`
- */
-interface StyleDetailsPart {
-  mods: string[];
-  values: string[];
-  colors: string[];
-  all: string[];
-  output: string;
-}
-/**
- * A group of style details, representing a comma-separated segment.
- * Contains aggregated values from all parts for backward compatibility,
- * plus the structured `parts` array for handlers that need slash separation.
- */
-interface StyleDetails {
-  input: string;
-  output: string;
-  /** Aggregated mods from all parts (backward compatible) */
-  mods: string[];
-  /** Aggregated values from all parts (backward compatible) */
-  values: string[];
-  /** Aggregated colors from all parts (backward compatible) */
-  colors: string[];
-  /** Aggregated all tokens from all parts (backward compatible) */
-  all: string[];
-  /** Slash-separated parts within this group */
-  parts: StyleDetailsPart[];
-}
-interface ProcessedStyle {
-  output: string;
-  groups: StyleDetails[];
-}
-type UnitHandler = (scalar: number) => string;
-interface ParserOptions {
-  functions?: Record<string, (parsed: StyleDetails[]) => string>;
-  units?: Record<string, string | UnitHandler>;
-  cacheSize?: number;
-}
-//#endregion
-//#region src/parser/parser.d.ts
-declare class StyleParser {
-  private opts;
-  private cache;
-  constructor(opts?: ParserOptions);
-  process(src: string): ProcessedStyle;
-  setFunctions(functions: Required<ParserOptions>['functions']): void;
-  setUnits(units: Required<ParserOptions>['units']): void;
-  updateOptions(patch: Partial<ParserOptions>): void;
-  /**
-   * Clear the parser cache.
-   * Call this when external state that affects parsing results has changed
-   * (e.g., predefined tokens).
-   */
-  clearCache(): void;
-  /**
-   * Get the current units configuration.
-   */
-  getUnits(): ParserOptions['units'];
-}
-//#endregion
-//#region src/utils/color-math.d.ts
-/**
- * Consolidated color conversion math.
- *
- * Single source of truth for all color space conversions used across the
- * library: sRGB gamma, HSL, OKLab, OKLCH, OKHSL, hex parsing, named
- * colors, and CSS string converters.
- *
- * This module has zero internal imports — it is a leaf dependency.
- *
- * Reference: https://bottosson.github.io/posts/oklab/
- */
-type Vec3 = [number, number, number];
-/**
- * sRGB gamma to linear. Only the sRGB-to-OKLab direction needs it, so this is
- * test-only for the same reason as {@link srgbToOkhsl} — the forward path goes
- * through {@link srgbLinearToGamma} instead.
- */
-/**
- * HSL to RGB.
- * Algorithm from CSS Color 4 spec.
- *
- * @param h - Hue in degrees (0-360)
- * @param s - Saturation (0-1)
- * @param l - Lightness (0-1)
- * @returns RGB values in 0-255 range (may have fractional values)
- */
-declare function hslToRgbValues(h: number, s: number, l: number): Vec3;
-declare function getNamedColorHex(): Map<string, string>;
-/**
- * Convert hex color string to `rgb()` CSS string.
- * Supports 3, 4, 6, and 8 character hex values (with or without `#`).
+ * Convert hex color string to `rgb()` CSS string.
+ * Supports 3, 4, 6, and 8 character hex values (with or without `#`).
  */
 declare function hexToRgb(hex: string): string | null;
 /**
@@ -1317,300 +823,794 @@ interface StylesInterface extends Omit<CSSProperties, 'color' | 'fill' | 'font'
    */
   recipe?: string;
 }
-type SuffixForSelector = '&' | '.' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
-type Selector = `${SuffixForSelector}${string}`;
-type NotSelector = Exclude<string, Selector | keyof StylesInterface>;
-/** Special style keys that should not be wrapped in StyleValue/StyleValueStateMap */
-type SpecialStyleKeys = '@keyframes' | '@property' | '@font-face' | '@counter-style' | '@function' | 'recipe';
-type StylesWithoutSelectors = { [key in keyof StylesInterface as key extends SpecialStyleKeys ? never : key]?: StyleValue<StylesInterface[key]> | StyleValueStateMap<StylesInterface[key]> };
+type SuffixForSelector = '&' | '.' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+type Selector = `${SuffixForSelector}${string}`;
+type NotSelector = Exclude<string, Selector | keyof StylesInterface>;
+/** Special style keys that should not be wrapped in StyleValue/StyleValueStateMap */
+type SpecialStyleKeys = '@keyframes' | '@property' | '@font-face' | '@counter-style' | '@function' | 'recipe';
+type StylesWithoutSelectors = { [key in keyof StylesInterface as key extends SpecialStyleKeys ? never : key]?: StyleValue<StylesInterface[key]> | StyleValueStateMap<StylesInterface[key]> };
+/**
+ * Index signature for recipe-specific arbitrary keys.
+ * Supports local predefined states (`@name`), vendor-prefixed CSS properties (`-webkit-*`),
+ * CSS custom properties (`$name`), and color tokens (`#name`).
+ * Unlike StylesIndexSignature, does NOT allow sub-element selectors (recipes are flat).
+ */
+type RecipeIndexSignature = Record<string, StyleValue<string | number | boolean | undefined> | StyleValueStateMap<string | number | boolean | undefined>>;
+/**
+ * Style type for recipe definitions.
+ * Like StylesWithoutSelectors but also allows `@keyframes`, `@property`,
+ * local predefined states, and vendor-prefixed CSS properties.
+ * Excludes `recipe` to prevent recursive references.
+ */
+type RecipeStyles = StylesWithoutSelectors & RecipeIndexSignature & {
+  '@keyframes'?: StylesInterface['@keyframes'];
+  '@property'?: StylesInterface['@property'];
+  '@font-face'?: StylesInterface['@font-face'];
+  '@counter-style'?: StylesInterface['@counter-style'];
+  '@function'?: StylesInterface['@function'];
+};
+/** Special properties that are not regular style values */
+interface SpecialStyleProperties {
+  '@keyframes'?: StylesInterface['@keyframes'];
+  '@property'?: StylesInterface['@property'];
+  '@font-face'?: StylesInterface['@font-face'];
+  '@counter-style'?: StylesInterface['@counter-style'];
+  '@function'?: StylesInterface['@function'];
+  recipe?: StylesInterface['recipe'];
+}
+/** Index signature for arbitrary style keys (sub-elements, CSS variables, etc.) */
+interface StylesIndexSignature {
+  [key: string]: StyleValue<string | number | boolean | undefined> | StyleValueStateMap<string | number | boolean | undefined> | Styles | false | StylesInterface['@keyframes'] | StylesInterface['@property'] | StylesInterface['@font-face'] | StylesInterface['@counter-style'] | StylesInterface['@function'];
+  /**
+   * Selector combinator: `undefined` (descendant, default), `'>'` (child), `'+'` (adjacent), `'~'` (sibling).
+   * Can chain with capitalized names: `'> Body > Row >'`. Spaces required around combinators.
+   */
+  $?: string;
+}
+type Styles = StylesWithoutSelectors & SpecialStyleProperties & StylesIndexSignature;
+/**
+ * Value type for design tokens passed to `configure({ tokens })`.
+ * Can be a direct value or a state map for responsive/theme-aware tokens.
+ */
+type ConfigTokenValue = string | number | boolean | Record<string, string | number | boolean | undefined | null | '@inherit'>;
+/**
+ * Design tokens injected as CSS custom properties on `:root`.
+ * Keys must start with `$` (value tokens) or `#` (color tokens).
+ *
+ * - `$name` keys become `--name` CSS custom properties
+ * - `#name` keys become `--name-color` properties
+ */
+type ConfigTokens = Record<`$${string}` | `#${string}`, ConfigTokenValue>;
+//#endregion
+//#region src/utils/is-selector.d.ts
+/** Check whether a style-object key identifies a nested CSS selector. */
+declare function isSelector(key: string): boolean;
+//#endregion
+//#region src/pipeline/conditions.d.ts
+/**
+ * ConditionNode Types and Helpers
+ *
+ * Core data structures for representing style conditions as an abstract syntax tree.
+ * Used throughout the pipeline for parsing, simplification, and CSS generation.
+ */
+/**
+ * Base interface for all state conditions (leaf nodes)
+ */
+interface BaseStateCondition {
+  kind: 'state';
+  negated: boolean;
+  raw: string;
+  uniqueId: string;
+}
+/**
+ * Modifier condition: [data-attr] or [data-attr="value"]
+ */
+interface ModifierCondition extends BaseStateCondition {
+  type: 'modifier';
+  attribute: string;
+  value?: string;
+  operator?: '=' | '^=' | '$=' | '*=';
+}
+/**
+ * Pseudo-class condition: :hover, :focus-visible
+ */
+interface PseudoCondition extends BaseStateCondition {
+  type: 'pseudo';
+  pseudo: string;
+}
+/**
+ * Numeric bound for dimension queries
+ */
+interface NumericBound {
+  value: string;
+  valueNumeric: number | null;
+  inclusive: boolean;
+}
+/**
+ * Media query condition
+ */
+interface MediaCondition extends BaseStateCondition {
+  type: 'media';
+  subtype: 'dimension' | 'feature' | 'type';
+  dimension?: 'width' | 'height' | 'inline-size' | 'block-size';
+  lowerBound?: NumericBound;
+  upperBound?: NumericBound;
+  feature?: string;
+  featureValue?: string;
+  mediaType?: 'print' | 'screen' | 'all' | 'speech';
+}
+/**
+ * Container query condition
+ */
+interface ContainerCondition extends BaseStateCondition {
+  type: 'container';
+  subtype: 'dimension' | 'style' | 'raw';
+  containerName?: string;
+  dimension?: 'width' | 'height' | 'inline-size' | 'block-size';
+  lowerBound?: NumericBound;
+  upperBound?: NumericBound;
+  property?: string;
+  propertyValue?: string;
+  rawCondition?: string;
+}
+/**
+ * Root state condition: @root(theme=dark)
+ */
+interface RootCondition extends BaseStateCondition {
+  type: 'root';
+  innerCondition: ConditionNode;
+}
+/**
+ * Parent state condition: @parent(hovered), @parent(theme=dark, >)
+ */
+interface ParentCondition extends BaseStateCondition {
+  type: 'parent';
+  innerCondition: ConditionNode;
+  direct: boolean;
+}
+/**
+ * Own state condition: @own(hovered)
+ */
+interface OwnCondition extends BaseStateCondition {
+  type: 'own';
+  innerCondition: ConditionNode;
+}
+/**
+ * Starting style condition: @starting
+ */
+interface StartingCondition extends BaseStateCondition {
+  type: 'starting';
+}
+/**
+ * Supports query condition: @supports(display: grid), @supports($, :has(*))
+ */
+interface SupportsCondition extends BaseStateCondition {
+  type: 'supports';
+  subtype: 'feature' | 'selector';
+  condition: string;
+}
+/**
+ * Union of all state condition types
+ */
+type StateCondition = ModifierCondition | PseudoCondition | MediaCondition | ContainerCondition | RootCondition | ParentCondition | OwnCondition | StartingCondition | SupportsCondition;
+/**
+ * Compound node: combines conditions with AND/OR
+ */
+interface CompoundCondition {
+  kind: 'compound';
+  operator: 'AND' | 'OR';
+  children: ConditionNode[];
+}
 /**
- * Index signature for recipe-specific arbitrary keys.
- * Supports local predefined states (`@name`), vendor-prefixed CSS properties (`-webkit-*`),
- * CSS custom properties (`$name`), and color tokens (`#name`).
- * Unlike StylesIndexSignature, does NOT allow sub-element selectors (recipes are flat).
+ * True condition (matches everything)
  */
-type RecipeIndexSignature = Record<string, StyleValue<string | number | boolean | undefined> | StyleValueStateMap<string | number | boolean | undefined>>;
+interface TrueCondition {
+  kind: 'true';
+}
 /**
- * Style type for recipe definitions.
- * Like StylesWithoutSelectors but also allows `@keyframes`, `@property`,
- * local predefined states, and vendor-prefixed CSS properties.
- * Excludes `recipe` to prevent recursive references.
+ * False condition (matches nothing - skip this rule)
  */
-type RecipeStyles = StylesWithoutSelectors & RecipeIndexSignature & {
-  '@keyframes'?: StylesInterface['@keyframes'];
-  '@property'?: StylesInterface['@property'];
-  '@font-face'?: StylesInterface['@font-face'];
-  '@counter-style'?: StylesInterface['@counter-style'];
-  '@function'?: StylesInterface['@function'];
-};
-/** Special properties that are not regular style values */
-interface SpecialStyleProperties {
-  '@keyframes'?: StylesInterface['@keyframes'];
-  '@property'?: StylesInterface['@property'];
-  '@font-face'?: StylesInterface['@font-face'];
-  '@counter-style'?: StylesInterface['@counter-style'];
-  '@function'?: StylesInterface['@function'];
-  recipe?: StylesInterface['recipe'];
+interface FalseCondition {
+  kind: 'false';
 }
-/** Index signature for arbitrary style keys (sub-elements, CSS variables, etc.) */
-interface StylesIndexSignature {
-  [key: string]: StyleValue<string | number | boolean | undefined> | StyleValueStateMap<string | number | boolean | undefined> | Styles | false | StylesInterface['@keyframes'] | StylesInterface['@property'] | StylesInterface['@font-face'] | StylesInterface['@counter-style'] | StylesInterface['@function'];
-  /**
-   * Selector combinator: `undefined` (descendant, default), `'>'` (child), `'+'` (adjacent), `'~'` (sibling).
-   * Can chain with capitalized names: `'> Body > Row >'`. Spaces required around combinators.
-   */
-  $?: string;
+/**
+ * Union of all condition node types
+ */
+type ConditionNode = StateCondition | CompoundCondition | TrueCondition | FalseCondition;
+//#endregion
+//#region src/states/index.d.ts
+/**
+ * Parsed advanced state information
+ */
+interface ParsedAdvancedState {
+  type: 'media' | 'container' | 'root' | 'parent' | 'own' | 'starting' | 'predefined' | 'modifier';
+  condition: string;
+  containerName?: string;
+  raw: string;
+  mediaType?: string;
 }
-type Styles = StylesWithoutSelectors & SpecialStyleProperties & StylesIndexSignature;
 /**
- * Value type for design tokens passed to `configure({ tokens })`.
- * Can be a direct value or a state map for responsive/theme-aware tokens.
+ * Context for state parsing operations
  */
-type ConfigTokenValue = string | number | boolean | Record<string, string | number | boolean | undefined | null | '@inherit'>;
+interface StateParserContext {
+  localPredefinedStates: Record<string, string>;
+  globalPredefinedStates: Record<string, string>;
+  isSubElement?: boolean;
+}
 /**
- * Design tokens injected as CSS custom properties on `:root`.
- * Keys must start with `$` (value tokens) or `#` (color tokens).
- *
- * - `$name` keys become `--name` CSS custom properties
- * - `#name` keys become `--name-color` properties
+ * At-rule context for CSS generation
  */
-type ConfigTokens = Record<`$${string}` | `#${string}`, ConfigTokenValue>;
+interface AtRuleContext {
+  media?: string[];
+  container?: {
+    name?: string;
+    condition: string;
+  }[];
+  startingStyle?: boolean;
+  rootStates?: string[];
+  negatedRootStates?: string[];
+}
+/**
+ * Configure global predefined states
+ */
+declare function setGlobalPredefinedStates(states: Record<string, string>): void;
+/**
+ * Get global predefined states
+ */
+declare function getGlobalPredefinedStates(): Record<string, string>;
+/**
+ * Create a state parser context from styles
+ */
+declare function createStateParserContext(styles?: Styles, isSubElement?: boolean): StateParserContext;
 //#endregion
-//#region src/pipeline/conditions.d.ts
+//#region src/pipeline/parseStateKey.d.ts
+interface ParseStateKeyOptions {
+  context?: StateParserContext;
+  isSubElement?: boolean;
+}
 /**
- * ConditionNode Types and Helpers
- *
- * Core data structures for representing style conditions as an abstract syntax tree.
- * Used throughout the pipeline for parsing, simplification, and CSS generation.
+ * Parse a state key string into a ConditionNode
  */
+declare function parseStateKey(stateKey: string, options?: ParseStateKeyOptions): ConditionNode;
+//#endregion
+//#region src/pipeline/index.d.ts
 /**
- * Base interface for all state conditions (leaf nodes)
+ * Matches the old StyleResult interface for backward compatibility
  */
-interface BaseStateCondition {
-  kind: 'state';
-  negated: boolean;
-  raw: string;
-  uniqueId: string;
+interface StyleResult {
+  selector: string;
+  declarations: string;
+  atRules?: string[];
+  needsClassName?: boolean;
+  rootPrefix?: string;
+  /** When true, declarations are wrapped in @starting-style { ... } inside the selector rule */
+  startingStyle?: boolean;
 }
 /**
- * Modifier condition: [data-attr] or [data-attr="value"]
+ * Matches the old RenderResult interface for backward compatibility
  */
-interface ModifierCondition extends BaseStateCondition {
-  type: 'modifier';
-  attribute: string;
-  value?: string;
-  operator?: '=' | '^=' | '$=' | '*=';
+interface RenderResult {
+  rules: StyleResult[];
+  className?: string;
 }
 /**
- * Pseudo-class condition: :hover, :focus-visible
+ * Options for renderStyles when using direct selector mode.
  */
-interface PseudoCondition extends BaseStateCondition {
-  type: 'pseudo';
-  pseudo: string;
+interface RenderStylesOptions {
+  /**
+   * Whether to double the class selector for increased specificity.
+   * When true, `.myClass` becomes `.myClass.myClass` for higher specificity.
+   *
+   * @default false - User-provided selectors are not doubled.
+   *
+   * Note: This only applies when a classNameOrSelector is provided.
+   * When renderStyles returns RenderResult with needsClassName=true,
+   * the injector handles doubling automatically.
+   */
+  doubleSelector?: boolean;
 }
 /**
- * Numeric bound for dimension queries
+ * Render styles to CSS rules.
+ *
+ * When called without classNameOrSelector, returns RenderResult with needsClassName=true.
+ * When called with a selector/className string, returns StyleResult[] for direct injection.
  */
-interface NumericBound {
-  value: string;
-  valueNumeric: number | null;
-  inclusive: boolean;
+declare function renderStyles(styles?: Styles, classNameOrSelector?: undefined, options?: undefined, pipelineCacheKey?: string): RenderResult;
+declare function renderStyles(styles: Styles | undefined, classNameOrSelector: string, options?: RenderStylesOptions): StyleResult[];
+//#endregion
+//#region src/properties/property-type-resolver.d.ts
+/**
+ * PropertyTypeResolver
+ *
+ * Automatically infers CSS @property types from custom property values.
+ * Supports deferred resolution for var() reference chains of arbitrary depth.
+ */
+declare class PropertyTypeResolver {
+  /** propName → the prop it depends on */
+  private pendingDeps;
+  /** propName → list of props waiting on it */
+  private reverseDeps;
+  /**
+   * Scan CSS declarations and auto-register @property for custom properties
+   * whose types can be inferred from their values.
+   */
+  scanDeclarations(declarations: string, isPropertyDefined: (name: string) => boolean, registerProperty: (name: string, syntax: string, initialValue: string) => void): void;
+  private addDependency;
+  private resolve;
+  private isComplexValue;
 }
+//#endregion
+//#region src/injector/batch.d.ts
 /**
- * Media query condition
+ * Deferred CSSOM writes ("batched injection").
+ *
+ * Every `insertRule()` on a live stylesheet invalidates style for the sheet's
+ * scope, so Blink recalculates style the next time anything reads layout or
+ * computed style. When components inject during React's render phase and other
+ * components read layout in the same pass, the two interleave:
+ *
+ *   inject -> read (forced recalc) -> inject -> read (forced recalc) -> ...
+ *
+ * Batching moves every sheet write out from between those reads. Writes are
+ * queued in FIFO order and drained in one go, so the tree is invalidated once
+ * per flush instead of once per component.
+ *
+ * ## Ordering
+ *
+ * A single queue holds *all* writes — component rules, global rules, keyframes,
+ * `@property`, `@font-face`, `@counter-style`, `@function` and raw CSS. Draining
+ * it in insertion order keeps the sheet byte-identical to unbatched output,
+ * which matters because equal-specificity rules resolve by document order.
+ *
+ * ## Batch windows — why queuing is safe
+ *
+ * Deferring a write past React's layout phase would let a `useLayoutEffect`
+ * measure an element whose rules are not in the sheet yet, reading the unstyled
+ * box. `<TastyBatchProvider>` closes that hole by opening a *window* during its
+ * render and closing it — flushing — in its `useInsertionEffect`, which React
+ * runs in the mutation phase, before any layout effect:
+ *
+ *   provider renders          -> window OPEN
+ *     children render         -> injections queued
+ *   provider insertionEffect  -> FLUSH, window CLOSED
+ *   layout effects run        -> rules are in the sheet
+ *
+ * So in the default (`batchInjection: true`) mode a write is only ever queued
+ * inside a commit whose flush is already guaranteed by that same commit. Every
+ * injection outside a window — a deep update the provider did not re-render
+ * for, a `useLayoutEffect` that injects, an event handler, an async callback —
+ * is written straight through, exactly as with batching off.
+ *
+ * `batchInjection: 'always'` opts out of the gate and queues unconditionally.
+ * That wins on more commits, at the cost of the measurement hazard above.
+ *
+ * ## Flush points (earliest wins)
+ *
+ * 1. `<TastyBatchProvider>`'s `useInsertionEffect` — closes the window.
+ * 2. A microtask — a backstop for a render that was aborted or suspended and
+ *    therefore never reached its insertion effect. An aborted render mounts
+ *    nothing, so nothing can measure what it queued. Microtasks also always
+ *    drain before paint, so styles are never visually missing.
+ * 3. `flushStyles()` — explicit, and called internally by every injector read
+ *    API (`getCSSText`, `cleanup`, `gc`, `destroy`, ...).
  */
-interface MediaCondition extends BaseStateCondition {
-  type: 'media';
-  subtype: 'dimension' | 'feature' | 'type';
-  dimension?: 'width' | 'height' | 'inline-size' | 'block-size';
-  lowerBound?: NumericBound;
-  upperBound?: NumericBound;
-  feature?: string;
-  featureValue?: string;
-  mediaType?: 'print' | 'screen' | 'all' | 'speech';
+interface QueuedWrite {
+  /** Perform the deferred sheet write. */
+  run: () => void;
+  /** Set when the owner disposed before the write happened. */
+  cancelled: boolean;
+  /** Set once the write has been applied (or skipped as cancelled). */
+  done: boolean;
 }
+/** Whether any write is still waiting to hit a stylesheet. */
+declare function hasPendingStyleWrites(): boolean;
 /**
- * Container query condition
+ * Drain every pending sheet write, in insertion order.
+ *
+ * Safe to call when the queue is empty (the common case, so the guard comes
+ * first) and safe to call re-entrantly: a nested `flushStyles()` is a no-op,
+ * and work a draining write triggers is written in place by
+ * `enqueueStyleWrite` rather than queued behind the rest of the batch.
  */
-interface ContainerCondition extends BaseStateCondition {
-  type: 'container';
-  subtype: 'dimension' | 'style' | 'raw';
-  containerName?: string;
-  dimension?: 'width' | 'height' | 'inline-size' | 'block-size';
-  lowerBound?: NumericBound;
-  upperBound?: NumericBound;
-  property?: string;
-  propertyValue?: string;
-  rawCondition?: string;
-}
+declare function flushStyles(): void;
 /**
- * Root state condition: @root(theme=dark)
+ * Drop every pending write without applying it. Test helper — production code
+ * should call `flushStyles()` instead.
  */
-interface RootCondition extends BaseStateCondition {
-  type: 'root';
-  innerCondition: ConditionNode;
+declare function resetStyleBatch(): void;
+//#endregion
+//#region src/injector/types.d.ts
+declare global {
+  interface Window {
+    __TASTY__?: string[];
+  }
 }
-/**
- * Parent state condition: @parent(hovered), @parent(theme=dark, >)
- */
-interface ParentCondition extends BaseStateCondition {
-  type: 'parent';
-  innerCondition: ConditionNode;
-  direct: boolean;
+interface InjectResult {
+  className: string;
+  dispose: () => void;
+}
+interface GlobalInjectResult {
+  dispose: () => void;
+}
+type DisposeFunction = () => void;
+interface StyleInjectorConfig {
+  nonce?: string;
+  maxRulesPerSheet?: number;
+  forceTextInjection?: boolean;
+  /** Enable development mode features: performance metrics and debug information storage */
+  devMode?: boolean;
+  /**
+   * Global predefined states for advanced state mapping.
+   * These are state aliases that can be used in any component.
+   * Example: { '@mobile': '@media(w < 920px)', '@dark': '@root(theme=dark)' }
+   */
+  states?: Record<string, string>;
+  /**
+   * Automatically infer and register CSS @property declarations
+   * from custom property values. When false, only explicit @property are used.
+   * @default true
+   */
+  autoPropertyTypes?: boolean;
+  /** Garbage collection configuration for unused styles */
+  gc?: GCConfig;
+  /**
+   * Prefix prepended to every generated identifier.
+   * Mirrors the `namePrefix` field on the public `TastyConfig` so that
+   * standalone injector consumers can configure it directly.
+   * @default 't'
+   */
+  namePrefix?: string;
+  /**
+   * Defer stylesheet writes and apply them in one batch instead of one
+   * `insertRule()` per component. Mirrors `batchInjection` on the public
+   * `TastyConfig`.
+   * @default false
+   */
+  batchInjection?: boolean | 'always';
 }
 /**
- * Own state condition: @own(hovered)
+ * Per-className usage tracking for GC.
  */
-interface OwnCondition extends BaseStateCondition {
-  type: 'own';
-  innerCondition: ConditionNode;
-}
 /**
- * Starting style condition: @starting
+ * @deprecated Nothing reads this any more. Collection asks the DOM what is
+ * rendered rather than tracking usage per class, so there is no usage record
+ * to describe. Kept so existing imports keep type-checking.
  */
-interface StartingCondition extends BaseStateCondition {
-  type: 'starting';
+interface StyleUsage {
+  lastTouchedAt: number;
 }
 /**
- * Supports query condition: @supports(display: grid), @supports($, :has(*))
+ * Configuration for the style garbage collector.
+ *
+ * GC is triggered by touch count rather than timers: every `touchInterval`
+ * touches, an idle callback is scheduled to evict unused styles above
+ * `capacity`, oldest first.
  */
-interface SupportsCondition extends BaseStateCondition {
-  type: 'supports';
-  subtype: 'feature' | 'selector';
-  condition: string;
+interface GCConfig {
+  /**
+   * How long a class is left alone after collection first notices nothing is
+   * carrying it, in milliseconds (default 10,000).
+   *
+   * Rendering is not commit-aware: a render can resolve a class and commit it a
+   * little later, and in between nothing on the page carries it. Rather than
+   * try to tell that apart from a class that is finished — which cannot be done
+   * from outside React — collection simply does not touch anything that was in
+   * use recently. A render would have to stay pending for the whole window to
+   * lose its rules, and it gets them back on its next render.
+   */
+  grace?: number;
+  /**
+   * Number of touch events between automatic GC cycles.
+   * @default 1000
+   */
+  touchInterval?: number;
+  /**
+   * Maximum number of unused styles to retain.
+   * GC evicts the oldest unused styles when this limit is exceeded.
+   * Pinned styles and DOM-live styles
+   * do not count against this limit.
+   * @default 1000
+   */
+  capacity?: number;
 }
 /**
- * Union of all state condition types
+ * Per-call options for inject().
  */
-type StateCondition = ModifierCondition | PseudoCondition | MediaCondition | ContainerCondition | RootCondition | ParentCondition | OwnCondition | StartingCondition | SupportsCondition;
+interface InjectOptions {
+  root?: Document | ShadowRoot;
+  /** Reuse the class already injected for this key instead of writing again. */
+  cacheKey?: string;
+  /**
+   * Pin the injected class (default `true`). A pinned class is never evicted by
+   * `gc()`, and the returned `dispose()` releases the pin. Pass `false` when the
+   * caller keeps no handle and the DOM is the only record that the class is in
+   * use — the render path does this, because a hook-free render has no unmount
+   * signal to dispose on.
+   */
+  pin?: boolean;
+}
 /**
- * Compound node: combines conditions with AND/OR
+ * Per-call options for gc().
  */
-interface CompoundCondition {
-  kind: 'compound';
-  operator: 'AND' | 'OR';
-  children: ConditionNode[];
+interface GCOptions {
+  root?: Document | ShadowRoot;
+  /** Bypass capacity threshold and remove ALL unused styles. */
+  force?: boolean;
+}
+interface RuleInfo {
+  className: string;
+  ruleIndex: number;
+  sheetIndex: number;
+  /** Dev-only: full CSS texts inserted for this class; omitted in production */
+  cssText?: string[];
+  /** Inclusive end index of the contiguous block of inserted rules for this className */
+  endRuleIndex?: number;
+  /** NEW: exact indices of all inserted rules for this className */
+  indices?: number[];
+}
+type InjectionMode = 'style-element' | 'adopted';
+interface SheetInfo {
+  /** HTMLStyleElement used in style-element mode; null in adopted mode. */
+  sheet: HTMLStyleElement | null;
+  /** Constructable CSSStyleSheet used in adopted mode (ShadowRoot targets) */
+  constructableSheet?: CSSStyleSheet;
+  ruleCount: number;
+  holes: number[];
+  /**
+   * True when this sheet is written through `textContent` instead of CSSOM.
+   * Decided once at sheet creation so a sheet is never half CSSOM / half text.
+   */
+  textMode?: boolean;
+  /**
+   * Inserted rule texts in rule-index order. Maintained only in text mode —
+   * it is what makes deletion possible there, since `textContent` cannot be
+   * edited rule-by-rule and has to be rebuilt.
+   */
+  textRules?: string[];
+}
+interface CleanupStats {
+  timestamp: number;
+  classesDeleted: number;
+  cssSize: number;
+  rulesDeleted: number;
+}
+interface CacheMetrics {
+  hits: number;
+  misses: number;
+  bulkCleanups: number;
+  totalInsertions: number;
+  totalUnused: number;
+  stylesCleanedUp: number;
+  cleanupHistory: CleanupStats[];
+  startTime: number;
+  unusedHits?: number;
+}
+interface RootRegistry {
+  sheets: SheetInfo[];
+  /** className -> outstanding `inject()` references; 0 means nobody holds a handle */
+  pinCounts: Map<string, number>;
+  rules: Map<string, RuleInfo>;
+  /** Cache key to className mapping to avoid dual storage of RuleInfo objects */
+  cacheKeyToClassName: Map<string, string>;
+  /** Deduplication set of fully materialized CSS rules inserted into sheets */
+  ruleTextSet: Set<string>;
+  /** Performance metrics (optional) */
+  metrics?: CacheMetrics;
+  /** Keyframes cache by content hash -> entry */
+  keyframesCache: Map<string, KeyframesCacheEntry>;
+  /** Keyframes name to content hash mapping for collision detection */
+  keyframesNameToContent: Map<string, string>;
+  /** Counter for generating keyframes names like k0, k1, k2... */
+  keyframesCounter: number;
+  /** Map of injected @property names to their normalized declarations for tracking */
+  injectedProperties: Map<string, string>;
+  /** Content hashes of injected @font-face rules for deduplication */
+  injectedFontFaces: Set<string>;
+  /**
+   * Injected @counter-style rules. Maps the name to whether it was injected
+   * "strong" (`true`, the default — overrides) or "weak" (`false`, global
+   * `configure()` definitions that never clobber an existing rule).
+   */
+  injectedCounterStyles: Map<string, boolean>;
+  /**
+   * Injected @function rules. Maps the CSS function name to whether it was
+   * injected "strong" (`true`, the default — overrides) or "weak" (`false`,
+   * global `configure()` definitions that never clobber an existing rule).
+   */
+  injectedFunctions: Map<string, boolean>;
+  /** Global rules tracking for index adjustment */
+  globalRules: Map<string, RuleInfo>;
+  /** Resolver for auto-inferring @property types from declaration values */
+  propertyTypeResolver: PropertyTypeResolver;
+  /**
+   * className -> when the class was first noticed to be carrying nothing:
+   * injection, or the first sweep that looked and did not find it on an
+   * element. Cleared the moment a sweep finds it rendered again.
+   *
+   * Deliberately "when it was noticed", not "when it stopped being rendered".
+   * Nothing observes the moment an element leaves, so a class that unmounted
+   * just before a sweep and one that unmounted just after the previous sweep
+   * would otherwise be treated differently — and the first would lose its
+   * grace window entirely. Starting the clock at the sighting gives every
+   * class the same full window, whenever it actually went.
+   *
+   * Written only by the sweep's own DOM scan and at injection, so rendering
+   * never pays for it.
+   */
+  unusedSince: Map<string, number>;
+  /**
+   * Local `@keyframes` a class animates, by the name they were authored under.
+   *
+   * One reference is held per distinct set of steps, however many renders ask
+   * for it, and the classes that animate it own that reference between them.
+   * The last of them to be deleted releases it, so keyframes cannot outlive
+   * every rule that referred to them, and repeat renders cannot pile up
+   * references nobody gives back.
+   */
+  localKeyframes: Map<string, {
+    name: string;
+    dispose: () => void;
+    owners: Set<string>;
+  }>;
+  /** Renders since the last scheduled sweep (per-root) */
+  touchCount: number;
+  /** How many entries from `window.__TASTY__` have been synced into this registry */
+  serverClassSyncIndex: number;
+  /** Whether `<style data-tasty-rsc>` tags have been scanned for class names */
+  rscStylesScanned: boolean;
+  /** Whether this root uses adoptedStyleSheets or <style> elements */
+  injectionMode: InjectionMode;
+  /**
+   * Lazy feature-test for `@property` support, cached per registry.
+   * - `undefined`: not yet probed.
+   * - `true`: engine supports `@property`; rejections indicate user-authored
+   *   invalid rules and should warn.
+   * - `false`: engine doesn't support `@property` (e.g., jsdom); rejections
+   *   are expected and warnings are suppressed.
+   */
+  atPropertySupported?: boolean;
 }
-/**
- * True condition (matches everything)
- */
-interface TrueCondition {
-  kind: 'true';
+type StyleRule = StyleResult;
+interface KeyframesInfo {
+  name: string;
+  sheetIndex: number;
+  ruleIndex: number;
+  /** Dev-only: full CSS text of the @keyframes rule; omitted in production */
+  cssText?: string;
 }
-/**
- * False condition (matches nothing - skip this rule)
- */
-interface FalseCondition {
-  kind: 'false';
+type KeyframeStep = string | Record<string, string | number>;
+type KeyframesSteps = Record<string, KeyframeStep>;
+interface KeyframesResult {
+  toString(): string;
+  dispose: () => void;
 }
-/**
- * Union of all condition node types
- */
-type ConditionNode = StateCondition | CompoundCondition | TrueCondition | FalseCondition;
-//#endregion
-//#region src/states/index.d.ts
-/**
- * Parsed advanced state information
- */
-interface ParsedAdvancedState {
-  type: 'media' | 'container' | 'root' | 'parent' | 'own' | 'starting' | 'predefined' | 'modifier';
-  condition: string;
-  containerName?: string;
-  raw: string;
-  mediaType?: string;
+interface KeyframesCacheEntry {
+  name: string;
+  refCount: number;
+  info: KeyframesInfo;
+  /**
+   * Queued sheet write, when `batchInjection` deferred the insertion. Present
+   * only between `keyframes()` and the flush; disposing in that window cancels
+   * the write instead of deleting a rule that was never inserted.
+   */
+  pending?: QueuedWrite;
 }
 /**
- * Context for state parsing operations
+ * Definition for a CSS @property at-rule.
+ * Used to define custom property syntax, inheritance, and initial value.
  */
-interface StateParserContext {
-  localPredefinedStates: Record<string, string>;
-  globalPredefinedStates: Record<string, string>;
-  isSubElement?: boolean;
+interface PropertyDefinition {
+  /** CSS syntax string (e.g., '<color>', '<angle>', '<number>') */
+  syntax?: string;
+  /** Whether the property inherits (default: true) */
+  inherits?: boolean;
+  /** Initial value for the property */
+  initialValue?: string | number;
 }
 /**
- * At-rule context for CSS generation
+ * Options for registering a CSS `@property`.
+ * Extends {@link PropertyDefinition} with an optional injection root.
  */
-interface AtRuleContext {
-  media?: string[];
-  container?: {
-    name?: string;
-    condition: string;
-  }[];
-  startingStyle?: boolean;
-  rootStates?: string[];
-  negatedRootStates?: string[];
+interface PropertyOptions extends PropertyDefinition {
+  /** Shadow root or document to inject into */
+  root?: Document | ShadowRoot;
 }
 /**
- * Configure global predefined states
- */
-declare function setGlobalPredefinedStates(states: Record<string, string>): void;
-/**
- * Get global predefined states
+ * A single parameter for a CSS @function at-rule.
+ *
+ * - `true` — a bare parameter with no type or default.
+ * - `string` — a CSS type shorthand (e.g. `'<length>'`, `'<color>'`).
+ * - object — full form with optional `syntax` (type) and `default` value.
  */
-declare function getGlobalPredefinedStates(): Record<string, string>;
+type FunctionParameter = true | string | {
+  syntax?: string;
+  default?: string | number;
+};
 /**
- * Create a state parser context from styles
+ * Definition for a CSS @function at-rule (custom function).
+ *
+ * The descriptor body reads like a mini styles object: any `$name` key declares
+ * a local variable (`--name`) whose value is parsed through the Tasty DSL.
+ * `result` is the only required field.
+ *
+ * @example
+ * ```ts
+ * // @function --negative(--value) { result: calc(-1 * var(--value)); }
+ * { args: ['$value'], result: '(-1 * $value)' }
+ * ```
  */
-declare function createStateParserContext(styles?: Styles, isSubElement?: boolean): StateParserContext;
-//#endregion
-//#region src/pipeline/parseStateKey.d.ts
-interface ParseStateKeyOptions {
-  context?: StateParserContext;
-  isSubElement?: boolean;
+interface FunctionDefinition {
+  /**
+   * Ordered parameters. Array form lists bare parameter names (`['$value']`);
+   * object form maps each parameter name to its type/default.
+   */
+  args?: string[] | Record<string, FunctionParameter>;
+  /** Optional return type, e.g. `'<color>'`. */
+  returns?: string;
+  /** The `result:` descriptor value (parsed through the Tasty DSL). Required. */
+  result: string;
+  /** Local variables: any `$name` key declares `--name` in the body. */
+  [localVar: `$${string}`]: string | number | undefined;
 }
 /**
- * Parse a state key string into a ConditionNode
- */
-declare function parseStateKey(stateKey: string, options?: ParseStateKeyOptions): ConditionNode;
-//#endregion
-//#region src/pipeline/index.d.ts
-/**
- * Matches the old StyleResult interface for backward compatibility
+ * Descriptors for a CSS @font-face at-rule.
  */
-interface StyleResult {
-  selector: string;
-  declarations: string;
-  atRules?: string[];
-  needsClassName?: boolean;
-  rootPrefix?: string;
-  /** When true, declarations are wrapped in @starting-style { ... } inside the selector rule */
-  startingStyle?: boolean;
+interface FontFaceDescriptors {
+  /** Required. URL(s) to the font file(s). */
+  src: string;
+  /** Font weight or range. Default: 'normal'. */
+  fontWeight?: string | number;
+  /** Font style. Default: 'normal'. */
+  fontStyle?: 'normal' | 'italic' | 'oblique' | (string & {});
+  /** Font stretch. Default: 'normal'. */
+  fontStretch?: string;
+  /** Loading behavior. Default: 'auto'. */
+  fontDisplay?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+  /** Unicode range to cover. */
+  unicodeRange?: string;
+  /** Ascent metric override. */
+  ascentOverride?: string;
+  /** Descent metric override. */
+  descentOverride?: string;
+  /** Line gap metric override. */
+  lineGapOverride?: string;
+  /** Size adjustment factor. */
+  sizeAdjust?: string;
+  /** OpenType feature settings. */
+  fontFeatureSettings?: string;
+  /** Font variation axis settings. */
+  fontVariationSettings?: string;
 }
+/** Single descriptor or array of descriptors for multiple weights/styles. */
+type FontFaceInput = FontFaceDescriptors | FontFaceDescriptors[];
 /**
- * Matches the old RenderResult interface for backward compatibility
+ * Descriptors for a CSS @counter-style at-rule.
  */
-interface RenderResult {
-  rules: StyleResult[];
-  className?: string;
+interface CounterStyleDescriptors {
+  /** Required. Numbering algorithm. */
+  system: 'cyclic' | 'numeric' | 'alphabetic' | 'symbolic' | 'additive' | 'fixed' | (string & {});
+  /** Symbols for non-additive systems. */
+  symbols?: string;
+  /** Symbol-value pairs for additive system. */
+  additiveSymbols?: string;
+  /** String prepended to the marker. Default: "". */
+  prefix?: string;
+  /** String appended to the marker. Default: ". ". */
+  suffix?: string;
+  /** Negative-value wrapping (e.g., '"(" ")"'). */
+  negative?: string;
+  /** Counter range (e.g., 'infinite infinite'). */
+  range?: string;
+  /** Minimum marker width and pad symbol (e.g., '3 "0"'). */
+  pad?: string;
+  /** Fallback counter style name. */
+  fallback?: string;
+  /** Speech synthesis hint. */
+  speakAs?: string;
 }
-/**
- * Check if a key is a CSS selector
- */
-declare function isSelector(key: string): boolean;
-/**
- * Options for renderStyles when using direct selector mode.
- */
-interface RenderStylesOptions {
-  /**
-   * Whether to double the class selector for increased specificity.
-   * When true, `.myClass` becomes `.myClass.myClass` for higher specificity.
-   *
-   * @default false - User-provided selectors are not doubled.
-   *
-   * Note: This only applies when a classNameOrSelector is provided.
-   * When renderStyles returns RenderResult with needsClassName=true,
-   * the injector handles doubling automatically.
-   */
-  doubleSelector?: boolean;
+interface RawCSSResult {
+  dispose: () => void;
 }
-/**
- * Render styles to CSS rules.
- *
- * When called without classNameOrSelector, returns RenderResult with needsClassName=true.
- * When called with a selector/className string, returns StyleResult[] for direct injection.
- */
-declare function renderStyles(styles?: Styles, classNameOrSelector?: undefined, options?: undefined, pipelineCacheKey?: string): RenderResult;
-declare function renderStyles(styles: Styles | undefined, classNameOrSelector: string, options?: RenderStylesOptions): StyleResult[];
 //#endregion
-export { StyleParser as $, ParsedColor as A, StyleRule as At, StyleValueStateMap as B, SuffixForSelector as C, PropertyDefinition as Ct, CSSMap as D, RuleInfo as Dt, AnyStyleHandler as E, RootRegistry as Et, StyleHandlerProps as F, resetStyleBatch as Ft, parseColor as G, getGlobalParser as H, StyleHandlerResult as I, getNamedColorHex as J, parseStyle as K, StyleMap as L, ResolvedStyleValue as M, QueuedWrite as Mt, StyleHandler as N, flushStyles as Nt, CUSTOM_UNITS as O, SheetInfo as Ot, StyleHandlerDefinition as P, hasPendingStyleWrites as Pt, strToRgb as Q, StylePropValue as R, StylesWithoutSelectors as S, KeyframesSteps as St, TastyPresetNames as T, RawCSSResult as Tt, getGlobalPredefinedTokens as U, filterMods as V, normalizeColorTokenValue as W, hexToRgb as X, getRgbValuesFromRgbaString as Y, hslToRgbValues as Z, NotSelector as _, InjectResult as _t, ParseStateKeyOptions as a, CSSProperties as at, Styles as b, KeyframesInfo as bt, ParsedAdvancedState as c, DisposeFunction as ct, getGlobalPredefinedStates as d, FunctionDefinition as dt, ParserOptions as et, setGlobalPredefinedStates as f, FunctionParameter as ft, NoType as g, InjectOptions as gt, ConfigTokens as h, GlobalInjectResult as ht, renderStyles as i, UnitHandler as it, RawStyleHandler as j, StyleUsage as jt, DIRECTIONS as k, StyleInjectorConfig as kt, StateParserContext as l, FontFaceDescriptors as lt, ConfigTokenValue as m, GCOptions as mt, StyleResult as n, StyleDetails as nt, parseStateKey as o, CacheMetrics as ot, ConditionNode as p, GCConfig as pt, stringifyStyles as q, isSelector as r, StyleDetailsPart as rt, AtRuleContext as s, CounterStyleDescriptors as st, RenderResult as t, ProcessedStyle as tt, createStateParserContext as u, FontFaceInput as ut, RecipeStyles as v, InjectionMode as vt, TastyNamedColors as w, PropertyOptions as wt, StylesInterface as x, KeyframesResult as xt, Selector as y, KeyframesCacheEntry as yt, StyleValue as z };
-//# sourceMappingURL=index-DBjd4MAb.d.ts.map
+export { SuffixForSelector as $, resetStyleBatch as A, ParserOptions as At, getGlobalPredefinedStates as B, SheetInfo as C, stringifyStyles as Ct, QueuedWrite as D, hslToRgbValues as Dt, StyleUsage as E, hexToRgb as Et, parseStateKey as F, CSSProperties as Ft, ConfigTokens as G, ConditionNode as H, AtRuleContext as I, RecipeStyles as J, NoType as K, ParsedAdvancedState as L, StyleResult as M, StyleDetails as Mt, renderStyles as N, StyleDetailsPart as Nt, flushStyles as O, strToRgb as Ot, ParseStateKeyOptions as P, UnitHandler as Pt, StylesWithoutSelectors as Q, StateParserContext as R, RuleInfo as S, parseStyle as St, StyleRule as T, getRgbValuesFromRgbaString as Tt, isSelector as U, setGlobalPredefinedStates as V, ConfigTokenValue as W, Styles as X, Selector as Y, StylesInterface as Z, KeyframesSteps as _, filterMods as _t, FontFaceInput as a, DIRECTIONS as at, RawCSSResult as b, normalizeColorTokenValue as bt, GCConfig as c, ResolvedStyleValue as ct, InjectOptions as d, StyleHandlerProps as dt, TastyNamedColors as et, InjectResult as f, StyleHandlerResult as ft, KeyframesResult as g, StyleValueStateMap as gt, KeyframesInfo as h, StyleValue as ht, FontFaceDescriptors as i, CUSTOM_UNITS as it, RenderResult as j, ProcessedStyle as jt, hasPendingStyleWrites as k, StyleParser as kt, GCOptions as l, StyleHandler as lt, KeyframesCacheEntry as m, StylePropValue as mt, CounterStyleDescriptors as n, AnyStyleHandler as nt, FunctionDefinition as o, ParsedColor as ot, InjectionMode as p, StyleMap as pt, NotSelector as q, DisposeFunction as r, CSSMap as rt, FunctionParameter as s, RawStyleHandler as st, CacheMetrics as t, TastyPresetNames as tt, GlobalInjectResult as u, StyleHandlerDefinition as ut, PropertyDefinition as v, getGlobalParser as vt, StyleInjectorConfig as w, getNamedColorHex as wt, RootRegistry as x, parseColor as xt, PropertyOptions as y, getGlobalPredefinedTokens as yt, createStateParserContext as z };
+//# sourceMappingURL=types-jKZNpias.d.ts.map