@tenphi/tasty 0.0.0-snapshot.1d29633 → 0.0.0-snapshot.1f1c00a

package/dist/{index-LC3O3Jj4.d.ts → types-JEY8PVYP.d.ts}

@@ -1,648 +1,164 @@
 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/styles.d.ts
+type StyleValue<T = string> = T | boolean | number | null | undefined;
 /**
- * Per-className usage tracking for GC.
+ * Normalize a color token value.
+ * - Boolean `true` is converted to `'transparent'`
+ * - Boolean `false` returns `null` (signals the token should be skipped)
+ * - Other values are returned as-is
+ *
+ * @param value - The raw token value
+ * @returns Normalized value or null if the token should be skipped
  */
-interface StyleUsage {
-  lastTouchedAt: number;
-}
+declare function normalizeColorTokenValue<T>(value: T | boolean): T | 'transparent' | null;
+type StyleValueStateMap<T = string> = Record<string, StyleValue<T> | '@inherit'>;
 /**
- * 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.
+ * Combined type for style values that can be either a direct value or a state map.
+ * Use this for component props that accept style values.
  */
-interface GCConfig {
-  /**
-   * Number of touch events between GC cycles.
-   * @default 1000
-   */
-  touchInterval?: number;
-  /**
-   * Maximum number of unused styles to retain.
-   * GC evicts the oldest unused styles when this limit is exceeded.
-   * Actively referenced styles (refCount > 0) and DOM-live styles
-   * do not count against this limit.
-   * @default 1000
-   */
-  capacity?: number;
-}
+type StylePropValue<T = string> = StyleValue<T> | StyleValueStateMap<T>;
 /**
- * Per-call options for gc().
+ * One dependency value as a style handler receives it: already resolved for a
+ * single state, but still the **raw authored DSL string** (`'2x'`, `'#purple.5'`).
+ * Handlers parse it themselves via {@link parseStyle} / {@link parseColor}.
  */
-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[];
-  refCounts: 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;
-  /** Per-className usage tracking for GC */
-  usageMap: Map<string, StyleUsage>;
-  /** Touch counter for scheduling GC (per-root) */
-  touchCount: number;
-  /**
-   * Millisecond that `touchedTick` refers to. `touch()` only ever stamps
-   * `lastTouchedAt` with the current millisecond, so a repeat touch of the same
-   * class name inside one millisecond is a no-op worth skipping.
-   */
-  touchTick: number;
-  /** Class-name strings already touched during `touchTick`. */
-  touchedTick: Set<string>;
-  /** 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;
-}
+type ResolvedStyleValue = StyleValue<string>;
 /**
- * Definition for a CSS @property at-rule.
- * Used to define custom property syntax, inheritance, and initial value.
+ * The dependency map a handler receives — one resolved value per style name in
+ * its `__lookupStyles`.
  */
-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;
-}
+type StyleHandlerProps<TDeps extends string = string> = Partial<Record<TDeps, ResolvedStyleValue>>;
 /**
- * Options for registering a CSS `@property`.
- * Extends {@link PropertyDefinition} with an optional injection root.
+ * One set of CSS declarations returned by a style handler.
+ *
+ * Keys are **kebab-case** CSS property names (`'background-color'`, not
+ * `backgroundColor`) or `--custom-property` names. Values are stringified, so
+ * numbers are accepted. `$` is reserved as a selector suffix.
  */
-interface PropertyOptions extends PropertyDefinition {
-  /** Shadow root or document to inject into */
-  root?: Document | ShadowRoot;
-}
+type CSSMap = {
+  /** Selector suffix (or suffixes) these declarations apply to, e.g. `'& > *'`. */
+  $?: string | string[];
+} & Record<string, string | number | (string | number)[] | undefined>;
+type StyleHandlerResult = CSSMap | CSSMap[] | null | void;
+type RawStyleHandler<TProps extends object = StyleHandlerProps> = (props: TProps) => StyleHandlerResult;
+type StyleHandler<TProps extends object = StyleHandlerProps> = RawStyleHandler<TProps> & {
+  __lookupStyles: string[];
+};
 /**
- * A single parameter for a CSS @function at-rule.
+ * The handler type used by the registry (`STYLE_HANDLER_MAP`), with parameter
+ * variance erased.
  *
- * - `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.
+ * Handlers declare narrow, hand-written dependency types — `({ fill }: { fill?:
+ * string }) => …` — which under `strictFunctionTypes` are not assignable to a
+ * wider parameter type. The registry stores handlers of many different dependency
+ * shapes together, so it needs the erased form. Prefer {@link StyleHandler} (or
+ * {@link defineHandler}) when writing a handler; this type is for code that
+ * inspects the registry.
  */
-type FunctionParameter = true | string | {
-  syntax?: string;
-  default?: string | number;
+type AnyStyleHandler = ((props: any) => StyleHandlerResult) & {
+  __lookupStyles: string[];
 };
 /**
- * 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.
+ * Handler definition forms for configure() and plugins.
+ * - Function only: lookup styles inferred from key name
+ * - Single property tuple: ['styleName', handler]
+ * - Multi-property tuple: [['style1', 'style2'], handler]
  *
- * @example
- * ```ts
- * // @function --negative(--value) { result: calc(-1 * var(--value)); }
- * { args: ['$value'], result: '(-1 * $value)' }
- * ```
+ * Use {@link defineHandler} to have the dependency names inferred into the
+ * handler's parameter type instead of annotating it by hand.
  */
-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;
+type StyleHandlerDefinition<TDeps extends string = string> = RawStyleHandler<StyleHandlerProps<TDeps>> | [TDeps, RawStyleHandler<StyleHandlerProps<TDeps>>] | [readonly TDeps[], RawStyleHandler<StyleHandlerProps<TDeps>>];
+interface ParsedColor {
+  color?: string;
+  name?: string;
+  opacity?: number;
 }
+type StyleMap = Record<string, StyleValue | StyleValueStateMap>;
+declare const CUSTOM_UNITS: {
+  r: string;
+  cr: string;
+  bw: string;
+  ow: string;
+  x: string;
+  sf: (num: number) => string;
+};
+declare const DIRECTIONS: string[];
 /**
- * Descriptors for a CSS @font-face at-rule.
+ * Get the global StyleParser instance.
+ * Used by configure() to apply parser configuration.
  */
-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[];
+declare function getGlobalParser(): StyleParser;
 /**
- * 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];
-/**
- * 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 `#`).
- */
-declare function hexToRgb(hex: string): string | null;
-/**
- * Extract RGB values from an `rgb()`/`rgba()` string.
- * Supports comma-separated, space-separated, fractional, percentage,
- * and slash alpha notation.
- *
- * @returns Array of RGB values (0-255 range), converting percentages as needed.
- */
-declare function getRgbValuesFromRgbaString(str: string): number[];
-/**
- * Convert any recognized color string to an `rgb()` CSS string.
- * Handles hex, `okhsl()`, `okhst()`, `hsl()`/`hsla()`, named CSS colors,
- * and `rgb()`/`rgba()` pass-through.
- */
-declare function strToRgb(color: string, _ignoreAlpha?: boolean): string | null | undefined;
-//#endregion
-//#region src/utils/styles.d.ts
-type StyleValue<T = string> = T | boolean | number | null | undefined;
-/**
- * Normalize a color token value.
- * - Boolean `true` is converted to `'transparent'`
- * - Boolean `false` returns `null` (signals the token should be skipped)
- * - Other values are returned as-is
- *
- * @param value - The raw token value
- * @returns Normalized value or null if the token should be skipped
- */
-declare function normalizeColorTokenValue<T>(value: T | boolean): T | 'transparent' | null;
-type StyleValueStateMap<T = string> = Record<string, StyleValue<T> | '@inherit'>;
-/**
- * Combined type for style values that can be either a direct value or a state map.
- * Use this for component props that accept style values.
- */
-type StylePropValue<T = string> = StyleValue<T> | StyleValueStateMap<T>;
-/**
- * One dependency value as a style handler receives it: already resolved for a
- * single state, but still the **raw authored DSL string** (`'2x'`, `'#purple.5'`).
- * Handlers parse it themselves via {@link parseStyle} / {@link parseColor}.
- */
-type ResolvedStyleValue = StyleValue<string>;
-/**
- * The dependency map a handler receives — one resolved value per style name in
- * its `__lookupStyles`.
- */
-type StyleHandlerProps<TDeps extends string = string> = Partial<Record<TDeps, ResolvedStyleValue>>;
-/**
- * One set of CSS declarations returned by a style handler.
- *
- * Keys are **kebab-case** CSS property names (`'background-color'`, not
- * `backgroundColor`) or `--custom-property` names. Values are stringified, so
- * numbers are accepted. `$` is reserved as a selector suffix.
- */
-type CSSMap = {
-  /** Selector suffix (or suffixes) these declarations apply to, e.g. `'& > *'`. */$?: string | string[];
-} & Record<string, string | number | (string | number)[] | undefined>;
-type StyleHandlerResult = CSSMap | CSSMap[] | null | void;
-type RawStyleHandler<TProps extends object = StyleHandlerProps> = (props: TProps) => StyleHandlerResult;
-type StyleHandler<TProps extends object = StyleHandlerProps> = RawStyleHandler<TProps> & {
-  __lookupStyles: string[];
-};
-/**
- * The handler type used by the registry (`STYLE_HANDLER_MAP`), with parameter
- * variance erased.
- *
- * Handlers declare narrow, hand-written dependency types — `({ fill }: { fill?:
- * string }) => …` — which under `strictFunctionTypes` are not assignable to a
- * wider parameter type. The registry stores handlers of many different dependency
- * shapes together, so it needs the erased form. Prefer {@link StyleHandler} (or
- * {@link defineHandler}) when writing a handler; this type is for code that
- * inspects the registry.
- */
-type AnyStyleHandler = ((props: any) => StyleHandlerResult) & {
-  __lookupStyles: string[];
-};
-/**
- * Handler definition forms for configure() and plugins.
- * - Function only: lookup styles inferred from key name
- * - Single property tuple: ['styleName', handler]
- * - Multi-property tuple: [['style1', 'style2'], handler]
- *
- * Use {@link defineHandler} to have the dependency names inferred into the
- * handler's parameter type instead of annotating it by hand.
- */
-type StyleHandlerDefinition<TDeps extends string = string> = RawStyleHandler<StyleHandlerProps<TDeps>> | [TDeps, RawStyleHandler<StyleHandlerProps<TDeps>>] | [readonly TDeps[], RawStyleHandler<StyleHandlerProps<TDeps>>];
-interface ParsedColor {
-  color?: string;
-  name?: string;
-  opacity?: number;
-}
-type StyleMap = Record<string, StyleValue | StyleValueStateMap>;
-declare const CUSTOM_UNITS: {
-  r: string;
-  cr: string;
-  bw: string;
-  ow: string;
-  x: string;
-  sf: (num: number) => string;
-};
-declare const DIRECTIONS: string[];
-/**
- * Get the global StyleParser instance.
- * Used by configure() to apply parser configuration.
- */
-declare function getGlobalParser(): StyleParser;
-/**
- * Get the current global predefined tokens.
- * Returns null if no tokens are configured.
+ * Get the current global predefined tokens.
+ * Returns null if no tokens are configured.
  */
 declare function getGlobalPredefinedTokens(): Record<string, string> | null;
 /**
@@ -657,7 +173,7 @@ declare function parseStyle(value: StyleValue): ProcessedStyle;
  * Optimized to avoid heavy parseStyle calls for simple color patterns.
  */
 declare function parseColor(val: string, ignoreError?: boolean): ParsedColor;
-declare function filterMods(mods: string[], allowedMods: string[]): string[];
+declare function filterMods(mods: string[], allowedMods: readonly string[]): string[];
 declare function stringifyStyles(styles: unknown): string;
 //#endregion
 //#region src/styles/types.d.ts
@@ -700,7 +216,11 @@ type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 type OpaquePercentage = '' | `.${Digit}` | `.${Digit}${Digit}` | '.100';
 type ColorValue = `#${NamedColor}${OpaquePercentage}` | `rgb(${string})` | `hsl(${string})` | `okhsl(${string})` | `oklch(${string})` | (string & {});
 type NoType = false | null | undefined;
-interface StylesInterface extends Omit<CSSProperties, 'color' | 'fill' | 'font' | 'outline' | 'type' | 'gap' | 'padding' | 'margin' | 'width' | 'height' | 'border' | 'transition' | 'placeContent' | 'placeItems' | 'scrollMargin' | 'scrollMarginTop' | 'scrollMarginRight' | 'scrollMarginBottom' | 'scrollMarginLeft' | 'scrollMarginBlock' | 'scrollMarginInline'> {
+interface StylesInterface extends Omit<CSSProperties, 'color' | 'fill' | 'font' | 'outline' | 'type' | 'gap' | 'padding' | 'margin' | 'width' | 'height' | 'blockSize' | 'inlineSize' | 'border' | 'transition' | 'placeContent' | 'placeItems' | 'scrollMargin' | 'scrollMarginTop' | 'scrollMarginRight' | 'scrollMarginBottom' | 'scrollMarginLeft' | 'scrollPadding' | 'scrollPaddingTop' | 'scrollPaddingRight' | 'scrollPaddingBottom' | 'scrollPaddingLeft' | 'overscrollBehaviorBlock' | 'overscrollBehaviorInline' | 'overscrollBehaviorX' | 'overscrollBehaviorY'> {
+  overscrollBehaviorBlock?: CSSProperties['overscrollBehaviorBlock'] | 'chain';
+  overscrollBehaviorInline?: CSSProperties['overscrollBehaviorInline'] | 'chain';
+  overscrollBehaviorX?: CSSProperties['overscrollBehaviorX'] | 'chain';
+  overscrollBehaviorY?: CSSProperties['overscrollBehaviorY'] | 'chain';
   /**
    * @deprecated Use `flow` style instead.
    */
@@ -852,6 +372,10 @@ interface StylesInterface extends Omit<CSSProperties, 'color' | 'fill' | 'font'
    * - `padding={true}` // default padding on all sides
    */
   padding?: CSSProperties['padding'] | string | boolean;
+  /** Logical block-axis padding with `start`/`end` modifiers. */
+  blockPadding?: CSSProperties['paddingBlock'] | string | boolean;
+  /** Logical inline-axis padding with `start`/`end` modifiers. */
+  inlinePadding?: CSSProperties['paddingInline'] | string | boolean;
   /**
    * Shorthand for element margin. Supports custom units, directional modifiers, and design-system-driven defaults.
    *
@@ -866,6 +390,10 @@ interface StylesInterface extends Omit<CSSProperties, 'color' | 'fill' | 'font'
    * - `margin={true}` // default margin on all sides
    */
   margin?: CSSProperties['margin'] | string | boolean;
+  /** Logical block-axis margin with `start`/`end` modifiers. */
+  blockMargin?: CSSProperties['marginBlock'] | string | boolean;
+  /** Logical inline-axis margin with `start`/`end` modifiers. */
+  inlineMargin?: CSSProperties['marginInline'] | string | boolean;
   /**
    * Concise shorthand for setting element width, including min-width and max-width. Supports custom units and advanced sizing keywords.
    *
@@ -897,6 +425,16 @@ interface StylesInterface extends Omit<CSSProperties, 'color' | 'fill' | 'font'
    * - `height={true}` // height: auto
    */
   height?: CSSProperties['height'] | string | boolean;
+  /**
+   * Logical block size with the same enhanced min/max/fixed syntax as `width`.
+   * Emits native `block-size`, `min-block-size`, and `max-block-size` declarations.
+   */
+  blockSize?: CSSProperties['blockSize'] | string | boolean;
+  /**
+   * Logical inline size with the same enhanced min/max/fixed syntax as `width`.
+   * Emits native `inline-size`, `min-inline-size`, and `max-inline-size` declarations.
+   */
+  inlineSize?: CSSProperties['inlineSize'] | string | boolean;
   /**
    * Shorthand for border width, style, and color. Supports directional modifiers and design-system defaults.
    *
@@ -918,6 +456,10 @@ interface StylesInterface extends Omit<CSSProperties, 'color' | 'fill' | 'font'
    * custom property directly, name it `$name-color`.
    */
   border?: CSSProperties['border'] | string | boolean;
+  /** Logical block-axis border with `start`/`end` modifiers. */
+  blockBorder?: CSSProperties['borderBlock'] | string | boolean;
+  /** Logical inline-axis border with `start`/`end` modifiers. */
+  inlineBorder?: CSSProperties['borderInline'] | string | boolean;
   /**
    * Powerful shorthand for CSS transitions using semantic names and design tokens. Supports grouped transitions for common UI effects.
    *
@@ -925,10 +467,10 @@ interface StylesInterface extends Omit<CSSProperties, 'color' | 'fill' | 'font'
    * Multiple transitions: separated by commas
    *
    * Examples:
-   * - `transition="fill 0.2s, radius 0.3s"` // transitions background-color and border-radius
-   * - `transition="fade 0.15s ease-in"` // transitions mask with easing
-   * - `transition="theme 0.3s"` // transitions all theme-related properties
-   * - `transition="preset 0.2s"` // transitions typography properties
+   * - `transition="fill, radius"` // transitions background-color and border-radius
+   * - `transition="fade $transition ease-in"` // transitions mask with explicit timing token
+   * - `transition="theme"` // transitions all theme-related properties
+   * - `transition="preset"` // transitions typography properties
    */
   transition?: CSSProperties['transition'] | string;
   /**
@@ -1123,8 +665,23 @@ interface StylesInterface extends Omit<CSSProperties, 'color' | 'fill' | 'font'
   scrollMarginRight?: string | number | boolean;
   scrollMarginBottom?: string | number | boolean;
   scrollMarginLeft?: string | number | boolean;
-  scrollMarginBlock?: string | number | boolean;
-  scrollMarginInline?: string | number | boolean;
+  /** Logical block-axis scroll margin with `start`/`end` modifiers. */
+  blockScrollMargin?: CSSProperties['scrollMarginBlock'] | string | boolean;
+  /** Logical inline-axis scroll margin with `start`/`end` modifiers. */
+  inlineScrollMargin?: CSSProperties['scrollMarginInline'] | string | boolean;
+  /**
+   * Shorthand for physical scroll padding. Supports custom units and the same
+   * physical direction modifiers as `padding`.
+   */
+  scrollPadding?: CSSProperties['scrollPadding'] | string | boolean;
+  scrollPaddingTop?: string | number | boolean;
+  scrollPaddingRight?: string | number | boolean;
+  scrollPaddingBottom?: string | number | boolean;
+  scrollPaddingLeft?: string | number | boolean;
+  /** Logical block-axis scroll padding with `start`/`end` modifiers. */
+  blockScrollPadding?: CSSProperties['scrollPaddingBlock'] | string | boolean;
+  /** Logical inline-axis scroll padding with `start`/`end` modifiers. */
+  inlineScrollPadding?: CSSProperties['scrollPaddingInline'] | string | boolean;
   /**
    * Shorthand for `top`, `right`, `bottom`, and `left` offsets. Supports custom units, directional modifiers, and positioning.
    *
@@ -1146,6 +703,10 @@ interface StylesInterface extends Omit<CSSProperties, 'color' | 'fill' | 'font'
    * insets the sides by `4x`. Without `dock` a second value is ignored.
    */
   inset?: 'top' | 'right' | 'bottom' | 'left' | 'dock' | string | CSSProperties['inset'];
+  /** Logical block-axis inset with `start`/`end` modifiers. */
+  blockInset?: CSSProperties['insetBlock'] | string | boolean;
+  /** Logical inline-axis inset with `start`/`end` modifiers. */
+  inlineInset?: CSSProperties['insetInline'] | string | boolean;
   /**
    * Local keyframes definitions for this component.
    * Keys are animation names, values are keyframes step definitions.
@@ -1222,7 +783,7 @@ 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 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-*`),
@@ -1272,245 +833,735 @@ type ConfigTokenValue = string | number | boolean | Record<string, string | numb
  * Keys must start with `$` (value tokens) or `#` (color tokens).
  *
  * - `$name` keys become `--name` CSS custom properties
- * - `#name` keys become `--name-color` and `--name-color-{colorSpace}` properties
+ * - `#name` keys become `--name-color` properties
+ */
+type ConfigTokens = Record<`$${string}` | `#${string}`, ConfigTokenValue>;
+//#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[];
+}
+/**
+ * True condition (matches everything)
+ */
+interface TrueCondition {
+  kind: 'true';
+}
+/**
+ * False condition (matches nothing - skip this rule)
+ */
+interface FalseCondition {
+  kind: 'false';
+}
+/**
+ * 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;
+}
+/**
+ * Context for state parsing operations
+ */
+interface StateParserContext {
+  localPredefinedStates: Record<string, string>;
+  globalPredefinedStates: Record<string, string>;
+  isSubElement?: boolean;
+}
+/**
+ * At-rule context for CSS generation
+ */
+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/parseStateKey.d.ts
+interface ParseStateKeyOptions {
+  context?: StateParserContext;
+  isSubElement?: boolean;
+}
+/**
+ * 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
+ */
+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;
+}
+/**
+ * Matches the old RenderResult interface for backward compatibility
+ */
+interface RenderResult {
+  rules: StyleResult[];
+  className?: string;
+}
+/**
+ * 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;
+}
+/**
+ * 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
+//#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
+/**
+ * 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`, ...).
  */
-type ConfigTokens = Record<`$${string}` | `#${string}`, ConfigTokenValue>;
-//#endregion
-//#region src/pipeline/conditions.d.ts
+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;
 /**
- * ConditionNode Types and Helpers
+ * Drain every pending sheet write, in insertion order.
  *
- * Core data structures for representing style conditions as an abstract syntax tree.
- * Used throughout the pipeline for parsing, simplification, and CSS generation.
+ * 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;
 /**
- * Base interface for all state conditions (leaf nodes)
+ * Drop every pending write without applying it. Test helper — production code
+ * should call `flushStyles()` instead.
  */
-interface BaseStateCondition {
-  kind: 'state';
-  negated: boolean;
-  raw: string;
-  uniqueId: string;
+declare function resetStyleBatch(): void;
+//#endregion
+//#region src/injector/types.d.ts
+declare global {
+  interface Window {
+    __TASTY__?: string[];
+  }
 }
-/**
- * Modifier condition: [data-attr] or [data-attr="value"]
- */
-interface ModifierCondition extends BaseStateCondition {
-  type: 'modifier';
-  attribute: string;
-  value?: string;
-  operator?: '=' | '^=' | '$=' | '*=';
+interface InjectResult {
+  className: string;
+  dispose: () => void;
 }
-/**
- * Pseudo-class condition: :hover, :focus-visible
- */
-interface PseudoCondition extends BaseStateCondition {
-  type: 'pseudo';
-  pseudo: string;
+interface GlobalInjectResult {
+  dispose: () => void;
 }
-/**
- * Numeric bound for dimension queries
- */
-interface NumericBound {
-  value: string;
-  valueNumeric: number | null;
-  inclusive: boolean;
+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';
 }
 /**
- * Media query condition
+ * Per-className usage tracking for GC.
  */
-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
+ * @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 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;
+interface StyleUsage {
+  lastTouchedAt: number;
 }
 /**
- * Root state condition: @root(theme=dark)
+ * 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 RootCondition extends BaseStateCondition {
-  type: 'root';
-  innerCondition: ConditionNode;
+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;
 }
 /**
- * Parent state condition: @parent(hovered), @parent(theme=dark, >)
+ * Per-call options for inject().
  */
-interface ParentCondition extends BaseStateCondition {
-  type: 'parent';
-  innerCondition: ConditionNode;
-  direct: boolean;
+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;
 }
 /**
- * Own state condition: @own(hovered)
+ * Per-call options for gc().
  */
-interface OwnCondition extends BaseStateCondition {
-  type: 'own';
-  innerCondition: ConditionNode;
+interface GCOptions {
+  root?: Document | ShadowRoot;
+  /** Bypass capacity threshold and remove ALL unused styles. */
+  force?: boolean;
 }
-/**
- * Starting style condition: @starting
- */
-interface StartingCondition extends BaseStateCondition {
-  type: 'starting';
+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[];
 }
-/**
- * Supports query condition: @supports(display: grid), @supports($, :has(*))
- */
-interface SupportsCondition extends BaseStateCondition {
-  type: 'supports';
-  subtype: 'feature' | 'selector';
-  condition: string;
+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[];
 }
-/**
- * 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[];
+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, StyleUsage as At, StyleValueStateMap as B, SuffixForSelector as C, PropertyOptions as Ct, CSSMap as D, SheetInfo as Dt, AnyStyleHandler as E, RuleInfo as Et, StyleHandlerProps as F, parseColor as G, getGlobalParser as H, StyleHandlerResult as I, getNamedColorHex as J, parseStyle as K, StyleMap as L, ResolvedStyleValue as M, flushStyles as Mt, StyleHandler as N, hasPendingStyleWrites as Nt, CUSTOM_UNITS as O, StyleInjectorConfig as Ot, StyleHandlerDefinition as P, resetStyleBatch as Pt, strToRgb as Q, StylePropValue as R, StylesWithoutSelectors as S, PropertyDefinition as St, TastyPresetNames as T, RootRegistry as Tt, getGlobalPredefinedTokens as U, filterMods as V, normalizeColorTokenValue as W, hexToRgb as X, getRgbValuesFromRgbaString as Y, hslToRgbValues as Z, NotSelector as _, InjectionMode as _t, ParseStateKeyOptions as a, CSSProperties as at, Styles as b, KeyframesResult 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, InjectResult as gt, ConfigTokens as h, GlobalInjectResult as ht, renderStyles as i, UnitHandler as it, RawStyleHandler as j, QueuedWrite as jt, DIRECTIONS as k, StyleRule 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, KeyframesCacheEntry as vt, TastyNamedColors as w, RawCSSResult as wt, StylesInterface as x, KeyframesSteps as xt, Selector as y, KeyframesInfo as yt, StyleValue as z };
-//# sourceMappingURL=index-LC3O3Jj4.d.ts.map
+export { TastyNamedColors as $, resetStyleBatch as A, getGlobalPredefinedStates as B, SheetInfo as C, StyleParser as Ct, QueuedWrite as D, StyleDetailsPart as Dt, StyleUsage as E, StyleDetails as Et, parseStateKey as F, NoType as G, ConditionNode as H, AtRuleContext as I, Selector as J, NotSelector as K, ParsedAdvancedState as L, StyleResult as M, renderStyles as N, flushStyles as O, UnitHandler as Ot, ParseStateKeyOptions as P, SuffixForSelector as Q, StateParserContext as R, RuleInfo as S, stringifyStyles as St, StyleRule as T, ProcessedStyle as Tt, ConfigTokenValue as U, setGlobalPredefinedStates as V, ConfigTokens as W, StylesInterface as X, Styles as Y, StylesWithoutSelectors as Z, KeyframesSteps as _, getGlobalParser as _t, FontFaceInput as a, ParsedColor as at, RawCSSResult as b, parseColor as bt, GCConfig as c, StyleHandler as ct, InjectOptions as d, StyleHandlerResult as dt, TastyPresetNames as et, InjectResult as f, StyleMap as ft, KeyframesResult as g, filterMods as gt, KeyframesInfo as h, StyleValueStateMap as ht, FontFaceDescriptors as i, DIRECTIONS as it, RenderResult as j, hasPendingStyleWrites as k, CSSProperties as kt, GCOptions as l, StyleHandlerDefinition as lt, KeyframesCacheEntry as m, StyleValue as mt, CounterStyleDescriptors as n, CSSMap as nt, FunctionDefinition as o, RawStyleHandler as ot, InjectionMode as p, StylePropValue as pt, RecipeStyles as q, DisposeFunction as r, CUSTOM_UNITS as rt, FunctionParameter as s, ResolvedStyleValue as st, CacheMetrics as t, AnyStyleHandler as tt, GlobalInjectResult as u, StyleHandlerProps as ut, PropertyDefinition as v, getGlobalPredefinedTokens as vt, StyleInjectorConfig as w, ParserOptions as wt, RootRegistry as x, parseStyle as xt, PropertyOptions as y, normalizeColorTokenValue as yt, createStateParserContext as z };
+//# sourceMappingURL=types-JEY8PVYP.d.ts.map