@tenphi/tasty 2.0.2 → 2.0.4

package/dist/{styles/types.d.ts → index-PzENbpAq.d.ts}

@@ -1,7 +1,467 @@
-import { CounterStyleDescriptors, FontFaceInput, KeyframesSteps, PropertyDefinition } from "../injector/types.js";
-import { CSSProperties } from "../utils/css-types.js";
-import { StyleValue, StyleValueStateMap } from "../utils/styles.js";
+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;
+}
+//#endregion
+//#region src/injector/types.d.ts
+declare global {
+  interface Window {
+    __TASTY__?: string[];
+  }
+}
+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 @properties are used.
+   * @default true
+   */
+  autoPropertyTypes?: boolean;
+  /** Garbage collection configuration for unused styles */
+  gc?: GCConfig;
+}
+/**
+ * Per-className usage tracking for GC.
+ */
+interface StyleUsage {
+  lastTouchedAt: number;
+}
+/**
+ * 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 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;
+}
+/**
+ * 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[];
+}
+interface SheetInfo {
+  sheet: HTMLStyleElement;
+  ruleCount: number;
+  holes: number[];
+}
+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>;
+  /** Names of injected @counter-style rules for deduplication */
+  injectedCounterStyles: Set<string>;
+  /** 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;
+  /** 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;
+}
+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;
+}
+/**
+ * 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;
+}
+/**
+ * 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
+declare enum Bucket {
+  Color = 0,
+  Value = 1,
+  Mod = 2
+}
+/**
+ * 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 {
+  funcs?: 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;
+  setFuncs(funcs: Required<ParserOptions>['funcs']): 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()`, `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>;
+type CSSMap = {
+  $?: string | string[];
+} & Record<string, string | string[]>;
+type StyleHandlerResult = CSSMap | CSSMap[] | null | void;
+type RawStyleHandler = (value: StyleValueStateMap) => StyleHandlerResult;
+type StyleHandler = RawStyleHandler & {
+  __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]
+ */
+type StyleHandlerDefinition = RawStyleHandler | [string, RawStyleHandler] | [string[], RawStyleHandler];
+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[];
+declare function customFunc(name: string, fn: (groups: StyleDetails[]) => string): void;
+/**
+ * Get the global StyleParser instance.
+ * Used by configure() to apply parser configuration.
+ */
+declare function getGlobalParser(): StyleParser;
+/**
+ * Get the current custom functions registry.
+ * Used by configure() to merge with new functions.
+ */
+declare function getGlobalFuncs(): Record<string, (groups: StyleDetails[]) => string>;
+/**
+ * Set global predefined tokens.
+ * Called from configure() after processing token values.
+ * Merges with existing tokens (new tokens override existing ones with same key).
+ * Keys are normalized to lowercase (parser lowercases input before classification).
+ * @internal
+ */
+declare function setGlobalPredefinedTokens(tokens: Record<string, string>): void;
+/**
+ * Get the current global predefined tokens.
+ * Returns null if no tokens are configured.
+ */
+declare function getGlobalPredefinedTokens(): Record<string, string> | null;
+/**
+ * Reset global predefined tokens.
+ * Used for testing.
+ * @internal
+ */
+declare function resetGlobalPredefinedTokens(): void;
+/**
+ *
+ * @param {String} value
+ * @param {Number} mode
+ * @returns {Object<String,String|Array>}
+ */
+declare function parseStyle(value: StyleValue): ProcessedStyle;
+/**
+ * Parse color. Find it value, name and opacity.
+ * 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 stringifyStyles(styles: unknown): string;
+//#endregion
 //#region src/styles/types.d.ts
 /**
  * Extensible interface for named color tokens.
@@ -560,5 +1020,241 @@ type ConfigTokenValue = string | number | boolean | Record<string, string | numb
  */
 type ConfigTokens = Record<`$${string}` | `#${string}`, ConfigTokenValue>;
 //#endregion
-export { ConfigTokenValue, ConfigTokens, NoType, NotSelector, RecipeStyles, Selector, Styles, StylesInterface, StylesWithoutSelectors, SuffixForSelector, TastyNamedColors, TastyPresetNames };
-//# sourceMappingURL=types.d.ts.map
+//#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;
+}
+/**
+ * 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;
+}
+/**
+ * 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 { strToRgb as $, RawStyleHandler as A, getGlobalFuncs as B, SuffixForSelector as C, RootRegistry as Ct, CUSTOM_UNITS as D, StyleRule as Dt, CSSMap as E, StyleInjectorConfig as Et, StylePropValue as F, parseStyle as G, getGlobalPredefinedTokens as H, StyleValue as I, stringifyStyles as J, resetGlobalPredefinedTokens as K, StyleValueStateMap as L, StyleHandlerDefinition as M, StyleHandlerResult as N, DIRECTIONS as O, StyleUsage as Ot, StyleMap as P, hslToRgbValues as Q, customFunc as R, StylesWithoutSelectors as S, RawCSSResult as St, TastyPresetNames as T, SheetInfo as Tt, normalizeColorTokenValue as U, getGlobalParser as V, parseColor as W, getRgbValuesFromRgbaString as X, getNamedColorHex as Y, hexToRgb as Z, NotSelector as _, KeyframesCacheEntry as _t, ParseStateKeyOptions as a, StyleDetailsPart as at, Styles as b, KeyframesSteps as bt, ParsedAdvancedState as c, CacheMetrics as ct, getGlobalPredefinedStates as d, FontFaceDescriptors as dt, StyleParser as et, setGlobalPredefinedStates as f, FontFaceInput as ft, NoType as g, InjectResult as gt, ConfigTokens as h, GlobalInjectResult as ht, renderStyles as i, StyleDetails as it, StyleHandler as j, ParsedColor as k, StateParserContext as l, CounterStyleDescriptors as lt, ConfigTokenValue as m, GCOptions as mt, StyleResult as n, ParserOptions as nt, parseStateKey as o, UnitHandler as ot, ConditionNode as p, GCConfig as pt, setGlobalPredefinedTokens as q, isSelector as r, ProcessedStyle as rt, AtRuleContext as s, CSSProperties as st, RenderResult as t, Bucket as tt, createStateParserContext as u, DisposeFunction as ut, RecipeStyles as v, KeyframesInfo as vt, TastyNamedColors as w, RuleInfo as wt, StylesInterface as x, PropertyDefinition as xt, Selector as y, KeyframesResult as yt, filterMods as z };
+//# sourceMappingURL=index-PzENbpAq.d.ts.map