@tachui/core 0.7.0-alpha1

package/dist/gradients/reactive.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Reactive Signal Integration for TachUI Gradients
+ *
+ * Enables dynamic gradients that update based on reactive signals,
+ * allowing for animated and data-driven gradient effects.
+ */
+interface Signal<T> {
+    readonly value: T;
+    subscribe(callback: () => void): () => void;
+}
+import type { Asset } from '../assets/types';
+import { Asset as AssetClass } from '../assets/Asset';
+import type { GradientDefinition, LinearGradientOptions, RadialGradientOptions, AngularGradientOptions, StateGradientOptions, StatefulBackgroundValue } from './types';
+import { StateGradientAsset } from './state-gradient-asset';
+/**
+ * Reactive gradient options supporting signal-based values
+ */
+export interface ReactiveLinearGradientOptions {
+    colors: (string | Asset | Signal<string>)[];
+    stops?: (number | Signal<number>)[];
+    startPoint: LinearGradientOptions['startPoint'] | Signal<LinearGradientOptions['startPoint']>;
+    endPoint: LinearGradientOptions['endPoint'] | Signal<LinearGradientOptions['endPoint']>;
+    angle?: number | Signal<number>;
+}
+export interface ReactiveRadialGradientOptions {
+    colors: (string | Asset | Signal<string>)[];
+    stops?: (number | Signal<number>)[];
+    center: RadialGradientOptions['center'] | Signal<RadialGradientOptions['center']>;
+    startRadius: number | Signal<number>;
+    endRadius: number | Signal<number>;
+    shape?: RadialGradientOptions['shape'] | Signal<RadialGradientOptions['shape']>;
+}
+export interface ReactiveAngularGradientOptions {
+    colors: (string | Asset | Signal<string>)[];
+    stops?: (number | Signal<number>)[];
+    center: AngularGradientOptions['center'] | Signal<AngularGradientOptions['center']>;
+    startAngle: number | Signal<number>;
+    endAngle: number | Signal<number>;
+}
+/**
+ * Reactive gradient definition
+ */
+export interface ReactiveGradientDefinition {
+    type: GradientDefinition['type'];
+    options: ReactiveLinearGradientOptions | ReactiveRadialGradientOptions | ReactiveAngularGradientOptions;
+    __reactive: true;
+}
+/**
+ * Reactive gradient asset that updates when signals change
+ */
+export declare class ReactiveGradientAsset extends AssetClass<string> {
+    private reactiveDefinition;
+    private currentGradient;
+    private subscriptions;
+    private updateCallback?;
+    constructor(name: string, reactiveDefinition: ReactiveGradientDefinition, updateCallback?: () => void);
+    /**
+     * Resolve current gradient to CSS
+     */
+    resolve(): string;
+    /**
+     * Get current static gradient (resolved from signals)
+     */
+    getCurrentGradient(): GradientDefinition;
+    /**
+     * Update the reactive definition and re-subscribe to signals
+     */
+    updateDefinition(newDefinition: ReactiveGradientDefinition): void;
+    /**
+     * Clean up signal subscriptions
+     */
+    cleanup(): void;
+    private resolveStaticGradient;
+    private resolveLinearOptions;
+    private resolveRadialOptions;
+    private resolveAngularOptions;
+    private resolveValue;
+    private isSignal;
+    private setupSignalSubscriptions;
+    private subscribeToSignalsInOptions;
+    private handleSignalChange;
+    private notifyUpdate;
+    private gradientToCSS;
+}
+/**
+ * Reactive state gradient asset with signal support
+ */
+export declare class ReactiveStateGradientAsset extends StateGradientAsset {
+    private reactiveStateGradients;
+    private updateCallback?;
+    private reactiveSubscriptions;
+    constructor(name: string, reactiveStateGradients: {
+        default: StatefulBackgroundValue | Signal<StatefulBackgroundValue>;
+        hover?: StatefulBackgroundValue | Signal<StatefulBackgroundValue>;
+        active?: StatefulBackgroundValue | Signal<StatefulBackgroundValue>;
+        focus?: StatefulBackgroundValue | Signal<StatefulBackgroundValue>;
+        disabled?: StatefulBackgroundValue | Signal<StatefulBackgroundValue>;
+        animation?: StateGradientOptions['animation'];
+    }, updateCallback?: (() => void) | undefined);
+    /**
+     * Update reactive state configuration
+     */
+    updateReactiveState(newState: ReactiveStateGradientAsset['reactiveStateGradients']): void;
+    /**
+     * Clean up signal subscriptions
+     */
+    cleanupStateSubscriptions(): void;
+    private static resolveStateOptions;
+    private static resolveValue;
+    private static isSignal;
+    private setupStateSignalSubscriptions;
+    private handleStateSignalChange;
+    private notifyStateUpdate;
+}
+/**
+ * Factory functions for creating reactive gradients
+ */
+export declare const ReactiveGradients: {
+    /**
+     * Create a reactive linear gradient
+     */
+    readonly linear: (options: ReactiveLinearGradientOptions, updateCallback?: () => void) => ReactiveGradientAsset;
+    /**
+     * Create a reactive radial gradient
+     */
+    readonly radial: (options: ReactiveRadialGradientOptions, updateCallback?: () => void) => ReactiveGradientAsset;
+    /**
+     * Create a reactive angular gradient
+     */
+    readonly angular: (options: ReactiveAngularGradientOptions, updateCallback?: () => void) => ReactiveGradientAsset;
+    /**
+     * Create a reactive state gradient
+     */
+    readonly state: (name: string, options: ReactiveStateGradientAsset["reactiveStateGradients"], updateCallback?: () => void) => ReactiveStateGradientAsset;
+};
+/**
+ * Utility functions for working with reactive gradients
+ */
+export declare const ReactiveGradientUtils: {
+    /**
+     * Create an animated gradient that cycles through colors
+     */
+    readonly createAnimatedGradient: (colors: string[], _duration?: number) => ReactiveGradientAsset;
+    /**
+     * Create a progress gradient that fills based on a signal
+     */
+    readonly createProgressGradient: (progressSignal: Signal<number>, color?: string) => ReactiveGradientAsset;
+    /**
+     * Create a data-driven gradient that reflects numeric values
+     */
+    readonly createDataGradient: (_valueSignal: Signal<number>, _minValue: number, _maxValue: number, colorScale?: string[]) => ReactiveGradientAsset;
+};
+/**
+ * Enhanced background modifier support for reactive gradients
+ */
+export declare const ReactiveBackgroundUtils: {
+    /**
+     * Check if a background value is reactive
+     */
+    readonly isReactiveBackground: (value: unknown) => value is ReactiveGradientAsset | ReactiveStateGradientAsset;
+    /**
+     * Create a reactive background from a signal
+     */
+    readonly fromSignal: (backgroundSignal: Signal<StatefulBackgroundValue>) => ReactiveStateGradientAsset;
+};
+export {};
+//# sourceMappingURL=reactive.d.ts.map

package/dist/gradients/reactive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive.d.ts","sourceRoot":"","sources":["../../src/gradients/reactive.ts"],"names":[],"mappings":"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"}

package/dist/gradients/reactive.js

@@ -0,0 +1,239 @@
+import { Asset as c } from "../assets/Asset.js";
+import { AngularGradient as h, RadialGradient as d, LinearGradient as p } from "./index.js";
+import { StateGradientAsset as b } from "./state-gradient-asset.js";
+var f = Object.defineProperty, g = (i, e, t) => e in i ? f(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, n = (i, e, t) => g(i, typeof e != "symbol" ? e + "" : e, t);
+class l extends c {
+  constructor(e, t, s) {
+    super(e), this.reactiveDefinition = t, n(this, "currentGradient"), n(this, "subscriptions", []), n(this, "updateCallback"), this.updateCallback = s, this.currentGradient = this.resolveStaticGradient(), this.setupSignalSubscriptions();
+  }
+  /**
+   * Resolve current gradient to CSS
+   */
+  resolve() {
+    return this.gradientToCSS(this.currentGradient);
+  }
+  /**
+   * Get current static gradient (resolved from signals)
+   */
+  getCurrentGradient() {
+    return this.currentGradient;
+  }
+  /**
+   * Update the reactive definition and re-subscribe to signals
+   */
+  updateDefinition(e) {
+    this.cleanup(), this.reactiveDefinition = e, this.currentGradient = this.resolveStaticGradient(), this.setupSignalSubscriptions(), this.notifyUpdate();
+  }
+  /**
+   * Clean up signal subscriptions
+   */
+  cleanup() {
+    this.subscriptions.forEach((e) => e()), this.subscriptions = [];
+  }
+  resolveStaticGradient() {
+    const { type: e, options: t } = this.reactiveDefinition;
+    switch (e) {
+      case "linear":
+        return p(this.resolveLinearOptions(t));
+      case "radial":
+        return d(this.resolveRadialOptions(t));
+      case "angular":
+      case "conic":
+        return h(this.resolveAngularOptions(t));
+      default:
+        throw new Error(`Unsupported reactive gradient type: ${e}`);
+    }
+  }
+  resolveLinearOptions(e) {
+    return {
+      colors: e.colors.map((t) => this.resolveValue(t)),
+      stops: e.stops?.map((t) => this.resolveValue(t)),
+      startPoint: this.resolveValue(e.startPoint),
+      endPoint: this.resolveValue(e.endPoint),
+      angle: e.angle ? this.resolveValue(e.angle) : void 0
+    };
+  }
+  resolveRadialOptions(e) {
+    return {
+      colors: e.colors.map((t) => this.resolveValue(t)),
+      stops: e.stops?.map((t) => this.resolveValue(t)),
+      center: this.resolveValue(e.center),
+      startRadius: this.resolveValue(e.startRadius),
+      endRadius: this.resolveValue(e.endRadius),
+      shape: e.shape ? this.resolveValue(e.shape) : void 0
+    };
+  }
+  resolveAngularOptions(e) {
+    return {
+      colors: e.colors.map((t) => this.resolveValue(t)),
+      stops: e.stops?.map((t) => this.resolveValue(t)),
+      center: this.resolveValue(e.center),
+      startAngle: this.resolveValue(e.startAngle),
+      endAngle: this.resolveValue(e.endAngle)
+    };
+  }
+  resolveValue(e) {
+    return this.isSignal(e) ? e.value : e;
+  }
+  isSignal(e) {
+    return e !== null && typeof e == "object" && "value" in e && "subscribe" in e;
+  }
+  setupSignalSubscriptions() {
+    this.subscribeToSignalsInOptions(this.reactiveDefinition.options);
+  }
+  subscribeToSignalsInOptions(e) {
+    for (const [t, s] of Object.entries(e))
+      if (Array.isArray(s))
+        s.forEach((a) => {
+          if (this.isSignal(a)) {
+            const u = a.subscribe(() => this.handleSignalChange());
+            this.subscriptions.push(u);
+          }
+        });
+      else if (this.isSignal(s)) {
+        const a = s.subscribe(() => this.handleSignalChange());
+        this.subscriptions.push(a);
+      }
+  }
+  handleSignalChange() {
+    this.currentGradient = this.resolveStaticGradient(), this.notifyUpdate();
+  }
+  notifyUpdate() {
+    this.updateCallback && this.updateCallback();
+  }
+  gradientToCSS(e) {
+    const { gradientToCSS: t } = require("./css-generator");
+    return t(e);
+  }
+}
+class r extends b {
+  constructor(e, t, s) {
+    const a = r.resolveStateOptions(t);
+    super(e, a), this.reactiveStateGradients = t, this.updateCallback = s, n(this, "reactiveSubscriptions", []), this.setupStateSignalSubscriptions();
+  }
+  /**
+   * Update reactive state configuration
+   */
+  updateReactiveState(e) {
+    this.cleanupStateSubscriptions(), this.reactiveStateGradients = e;
+    const t = r.resolveStateOptions(e);
+    this.updateStateGradients(t), this.setupStateSignalSubscriptions(), this.notifyStateUpdate();
+  }
+  /**
+   * Clean up signal subscriptions
+   */
+  cleanupStateSubscriptions() {
+    this.reactiveSubscriptions.forEach((e) => e()), this.reactiveSubscriptions = [];
+  }
+  static resolveStateOptions(e) {
+    const t = {
+      default: r.resolveValue(e.default),
+      animation: e.animation
+    };
+    return e.hover && (t.hover = r.resolveValue(e.hover)), e.active && (t.active = r.resolveValue(e.active)), e.focus && (t.focus = r.resolveValue(e.focus)), e.disabled && (t.disabled = r.resolveValue(e.disabled)), t;
+  }
+  static resolveValue(e) {
+    return e !== null && typeof e == "object" && "value" in e && "subscribe" in e ? e.value : e;
+  }
+  static isSignal(e) {
+    return e !== null && typeof e == "object" && "value" in e && "subscribe" in e;
+  }
+  setupStateSignalSubscriptions() {
+    Object.entries(this.reactiveStateGradients).forEach(([e, t]) => {
+      if (e !== "animation" && r.isSignal(t)) {
+        const s = t.subscribe(() => this.handleStateSignalChange());
+        this.reactiveSubscriptions.push(s);
+      }
+    });
+  }
+  handleStateSignalChange() {
+    const e = r.resolveStateOptions(this.reactiveStateGradients);
+    this.updateStateGradients(e), this.notifyStateUpdate();
+  }
+  notifyStateUpdate() {
+    this.updateCallback && this.updateCallback();
+  }
+}
+const o = {
+  /**
+   * Create a reactive linear gradient
+   */
+  linear: (i, e) => new l(
+    "reactive-linear",
+    { type: "linear", options: i, __reactive: !0 },
+    e
+  ),
+  /**
+   * Create a reactive radial gradient
+   */
+  radial: (i, e) => new l(
+    "reactive-radial",
+    { type: "radial", options: i, __reactive: !0 },
+    e
+  ),
+  /**
+   * Create a reactive angular gradient
+   */
+  angular: (i, e) => new l(
+    "reactive-angular",
+    { type: "angular", options: i, __reactive: !0 },
+    e
+  ),
+  /**
+   * Create a reactive state gradient
+   */
+  state: (i, e, t) => new r(i, e, t)
+}, m = {
+  /**
+   * Create an animated gradient that cycles through colors
+   */
+  createAnimatedGradient: (i, e = 3e3) => {
+    const t = {
+      value: i[0],
+      subscribe: (s) => () => {
+      }
+    };
+    return o.linear({
+      colors: [t, i[1]],
+      startPoint: "top",
+      endPoint: "bottom"
+    });
+  },
+  /**
+   * Create a progress gradient that fills based on a signal
+   */
+  createProgressGradient: (i, e = "#007AFF") => o.linear({
+    colors: [e, "transparent"],
+    stops: [i, i],
+    // Both stops use the same signal
+    startPoint: "leading",
+    endPoint: "trailing"
+  }),
+  /**
+   * Create a data-driven gradient that reflects numeric values
+   */
+  createDataGradient: (i, e, t, s = ["#ff0000", "#ffff00", "#00ff00"]) => o.linear({
+    colors: s,
+    startPoint: "top",
+    endPoint: "bottom"
+  })
+}, G = {
+  /**
+   * Check if a background value is reactive
+   */
+  isReactiveBackground: (i) => i instanceof l || i instanceof r,
+  /**
+   * Create a reactive background from a signal
+   */
+  fromSignal: (i) => o.state("signal-background", {
+    default: i
+  })
+};
+export {
+  G as ReactiveBackgroundUtils,
+  l as ReactiveGradientAsset,
+  m as ReactiveGradientUtils,
+  o as ReactiveGradients,
+  r as ReactiveStateGradientAsset
+};
+//# sourceMappingURL=reactive.js.map

package/dist/gradients/reactive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive.js","sources":["../../src/gradients/reactive.ts"],"sourcesContent":["/**\n * Reactive Signal Integration for TachUI Gradients\n * \n * Enables dynamic gradients that update based on reactive signals,\n * allowing for animated and data-driven gradient effects.\n */\n\n// Define Signal interface for gradients\ninterface Signal<T> {\n  readonly value: T\n  subscribe(callback: () => void): () => void\n}\nimport type { Asset } from '../assets/types'\nimport { Asset as AssetClass } from '../assets/Asset'\nimport type {\n  GradientDefinition,\n  LinearGradientOptions,\n  RadialGradientOptions,\n  AngularGradientOptions,\n  StateGradientOptions,\n  StatefulBackgroundValue\n} from './types'\nimport { LinearGradient, RadialGradient, AngularGradient } from './index'\nimport { StateGradientAsset } from './state-gradient-asset'\n\n/**\n * Reactive gradient options supporting signal-based values\n */\nexport interface ReactiveLinearGradientOptions {\n  colors: (string | Asset | Signal<string>)[]\n  stops?: (number | Signal<number>)[]\n  startPoint: LinearGradientOptions['startPoint'] | Signal<LinearGradientOptions['startPoint']>\n  endPoint: LinearGradientOptions['endPoint'] | Signal<LinearGradientOptions['endPoint']>\n  angle?: number | Signal<number>\n}\n\nexport interface ReactiveRadialGradientOptions {\n  colors: (string | Asset | Signal<string>)[]\n  stops?: (number | Signal<number>)[]\n  center: RadialGradientOptions['center'] | Signal<RadialGradientOptions['center']>\n  startRadius: number | Signal<number>\n  endRadius: number | Signal<number>\n  shape?: RadialGradientOptions['shape'] | Signal<RadialGradientOptions['shape']>\n}\n\nexport interface ReactiveAngularGradientOptions {\n  colors: (string | Asset | Signal<string>)[]\n  stops?: (number | Signal<number>)[]\n  center: AngularGradientOptions['center'] | Signal<AngularGradientOptions['center']>\n  startAngle: number | Signal<number>\n  endAngle: number | Signal<number>\n}\n\n/**\n * Reactive gradient definition\n */\nexport interface ReactiveGradientDefinition {\n  type: GradientDefinition['type']\n  options: ReactiveLinearGradientOptions | ReactiveRadialGradientOptions | ReactiveAngularGradientOptions\n  __reactive: true\n}\n\n/**\n * Reactive gradient asset that updates when signals change\n */\nexport class ReactiveGradientAsset extends AssetClass<string> {\n  private currentGradient: GradientDefinition\n  private subscriptions: (() => void)[] = []\n  private updateCallback?: () => void\n\n  constructor(\n    name: string,\n    private reactiveDefinition: ReactiveGradientDefinition,\n    updateCallback?: () => void\n  ) {\n    super(name)\n    this.updateCallback = updateCallback\n    this.currentGradient = this.resolveStaticGradient()\n    this.setupSignalSubscriptions()\n  }\n\n  /**\n   * Resolve current gradient to CSS\n   */\n  resolve(): string {\n    return this.gradientToCSS(this.currentGradient)\n  }\n\n  /**\n   * Get current static gradient (resolved from signals)\n   */\n  getCurrentGradient(): GradientDefinition {\n    return this.currentGradient\n  }\n\n  /**\n   * Update the reactive definition and re-subscribe to signals\n   */\n  updateDefinition(newDefinition: ReactiveGradientDefinition): void {\n    this.cleanup()\n    this.reactiveDefinition = newDefinition\n    this.currentGradient = this.resolveStaticGradient()\n    this.setupSignalSubscriptions()\n    this.notifyUpdate()\n  }\n\n  /**\n   * Clean up signal subscriptions\n   */\n  cleanup(): void {\n    this.subscriptions.forEach(unsubscribe => unsubscribe())\n    this.subscriptions = []\n  }\n\n  private resolveStaticGradient(): GradientDefinition {\n    const { type, options } = this.reactiveDefinition\n\n    switch (type) {\n      case 'linear':\n        return LinearGradient(this.resolveLinearOptions(options as ReactiveLinearGradientOptions))\n      case 'radial':\n        return RadialGradient(this.resolveRadialOptions(options as ReactiveRadialGradientOptions))\n      case 'angular':\n      case 'conic':\n        return AngularGradient(this.resolveAngularOptions(options as ReactiveAngularGradientOptions))\n      default:\n        throw new Error(`Unsupported reactive gradient type: ${type}`)\n    }\n  }\n\n  private resolveLinearOptions(options: ReactiveLinearGradientOptions): LinearGradientOptions {\n    return {\n      colors: options.colors.map(color => this.resolveValue(color)),\n      stops: options.stops?.map(stop => this.resolveValue(stop)),\n      startPoint: this.resolveValue(options.startPoint),\n      endPoint: this.resolveValue(options.endPoint),\n      angle: options.angle ? this.resolveValue(options.angle) : undefined\n    }\n  }\n\n  private resolveRadialOptions(options: ReactiveRadialGradientOptions): RadialGradientOptions {\n    return {\n      colors: options.colors.map(color => this.resolveValue(color)),\n      stops: options.stops?.map(stop => this.resolveValue(stop)),\n      center: this.resolveValue(options.center),\n      startRadius: this.resolveValue(options.startRadius),\n      endRadius: this.resolveValue(options.endRadius),\n      shape: options.shape ? this.resolveValue(options.shape) : undefined\n    }\n  }\n\n  private resolveAngularOptions(options: ReactiveAngularGradientOptions): AngularGradientOptions {\n    return {\n      colors: options.colors.map(color => this.resolveValue(color)),\n      stops: options.stops?.map(stop => this.resolveValue(stop)),\n      center: this.resolveValue(options.center),\n      startAngle: this.resolveValue(options.startAngle),\n      endAngle: this.resolveValue(options.endAngle)\n    }\n  }\n\n  private resolveValue<T>(value: T | Signal<T>): T {\n    if (this.isSignal(value)) {\n      return (value as Signal<T>).value\n    }\n    return value as T\n  }\n\n  private isSignal<T>(value: T | Signal<T>): value is Signal<T> {\n    return value !== null && \n           typeof value === 'object' && \n           'value' in value && \n           'subscribe' in value\n  }\n\n  private setupSignalSubscriptions(): void {\n    this.subscribeToSignalsInOptions(this.reactiveDefinition.options)\n  }\n\n  private subscribeToSignalsInOptions(options: any): void {\n    for (const [_key, value] of Object.entries(options)) {\n      if (Array.isArray(value)) {\n        // Handle arrays (colors, stops)\n        value.forEach(item => {\n          if (this.isSignal(item)) {\n            const unsubscribe = (item as Signal<any>).subscribe(() => this.handleSignalChange())\n            this.subscriptions.push(unsubscribe)\n          }\n        })\n      } else if (this.isSignal(value)) {\n        // Handle individual signals\n        const unsubscribe = (value as Signal<any>).subscribe(() => this.handleSignalChange())\n        this.subscriptions.push(unsubscribe)\n      }\n    }\n  }\n\n  private handleSignalChange(): void {\n    this.currentGradient = this.resolveStaticGradient()\n    this.notifyUpdate()\n  }\n\n  private notifyUpdate(): void {\n    if (this.updateCallback) {\n      this.updateCallback()\n    }\n  }\n\n  private gradientToCSS(gradient: GradientDefinition): string {\n    // Import and use the existing CSS generator\n    const { gradientToCSS } = require('./css-generator')\n    return gradientToCSS(gradient)\n  }\n}\n\n/**\n * Reactive state gradient asset with signal support\n */\nexport class ReactiveStateGradientAsset extends StateGradientAsset {\n  private reactiveSubscriptions: (() => void)[] = []\n\n  constructor(\n    name: string,\n    private reactiveStateGradients: {\n      default: StatefulBackgroundValue | Signal<StatefulBackgroundValue>\n      hover?: StatefulBackgroundValue | Signal<StatefulBackgroundValue>\n      active?: StatefulBackgroundValue | Signal<StatefulBackgroundValue>\n      focus?: StatefulBackgroundValue | Signal<StatefulBackgroundValue>\n      disabled?: StatefulBackgroundValue | Signal<StatefulBackgroundValue>\n      animation?: StateGradientOptions['animation']\n    },\n    private updateCallback?: () => void\n  ) {\n    // Resolve initial state\n    const initialState = ReactiveStateGradientAsset.resolveStateOptions(reactiveStateGradients)\n    super(name, initialState)\n    \n    this.setupStateSignalSubscriptions()\n  }\n\n  /**\n   * Update reactive state configuration\n   */\n  updateReactiveState(\n    newState: ReactiveStateGradientAsset['reactiveStateGradients']\n  ): void {\n    this.cleanupStateSubscriptions()\n    this.reactiveStateGradients = newState\n    \n    // Update the underlying state gradients\n    const resolvedState = ReactiveStateGradientAsset.resolveStateOptions(newState)\n    this.updateStateGradients(resolvedState)\n    \n    this.setupStateSignalSubscriptions()\n    this.notifyStateUpdate()\n  }\n\n  /**\n   * Clean up signal subscriptions\n   */\n  cleanupStateSubscriptions(): void {\n    this.reactiveSubscriptions.forEach(unsubscribe => unsubscribe())\n    this.reactiveSubscriptions = []\n  }\n\n  private static resolveStateOptions(\n    reactiveState: ReactiveStateGradientAsset['reactiveStateGradients']\n  ): StateGradientOptions {\n    const resolved: StateGradientOptions = {\n      default: ReactiveStateGradientAsset.resolveValue(reactiveState.default) as any,\n      animation: reactiveState.animation\n    }\n\n    if (reactiveState.hover) {\n      resolved.hover = ReactiveStateGradientAsset.resolveValue(reactiveState.hover) as any\n    }\n    if (reactiveState.active) {\n      resolved.active = ReactiveStateGradientAsset.resolveValue(reactiveState.active) as any\n    }\n    if (reactiveState.focus) {\n      resolved.focus = ReactiveStateGradientAsset.resolveValue(reactiveState.focus) as any\n    }\n    if (reactiveState.disabled) {\n      resolved.disabled = ReactiveStateGradientAsset.resolveValue(reactiveState.disabled) as any\n    }\n\n    return resolved\n  }\n\n  private static resolveValue<T>(value: T | Signal<T>): T {\n    if (value !== null && \n        typeof value === 'object' && \n        'value' in value && \n        'subscribe' in value) {\n      return (value as Signal<T>).value\n    }\n    return value as T\n  }\n\n  private static isSignal<T>(value: T | Signal<T>): value is Signal<T> {\n    return value !== null && \n           typeof value === 'object' && \n           'value' in value && \n           'subscribe' in value\n  }\n\n  private setupStateSignalSubscriptions(): void {\n    Object.entries(this.reactiveStateGradients).forEach(([key, value]) => {\n      if (key === 'animation') return // Skip animation\n      \n      if (ReactiveStateGradientAsset.isSignal(value)) {\n        const unsubscribe = (value as Signal<any>).subscribe(() => this.handleStateSignalChange())\n        this.reactiveSubscriptions.push(unsubscribe)\n      }\n    })\n  }\n\n  private handleStateSignalChange(): void {\n    const resolvedState = ReactiveStateGradientAsset.resolveStateOptions(this.reactiveStateGradients)\n    this.updateStateGradients(resolvedState)\n    this.notifyStateUpdate()\n  }\n\n  private notifyStateUpdate(): void {\n    if (this.updateCallback) {\n      this.updateCallback()\n    }\n  }\n}\n\n/**\n * Factory functions for creating reactive gradients\n */\nexport const ReactiveGradients = {\n  /**\n   * Create a reactive linear gradient\n   */\n  linear: (\n    options: ReactiveLinearGradientOptions,\n    updateCallback?: () => void\n  ): ReactiveGradientAsset => {\n    return new ReactiveGradientAsset(\n      'reactive-linear',\n      { type: 'linear', options, __reactive: true },\n      updateCallback\n    )\n  },\n\n  /**\n   * Create a reactive radial gradient\n   */\n  radial: (\n    options: ReactiveRadialGradientOptions,\n    updateCallback?: () => void\n  ): ReactiveGradientAsset => {\n    return new ReactiveGradientAsset(\n      'reactive-radial',\n      { type: 'radial', options, __reactive: true },\n      updateCallback\n    )\n  },\n\n  /**\n   * Create a reactive angular gradient\n   */\n  angular: (\n    options: ReactiveAngularGradientOptions,\n    updateCallback?: () => void\n  ): ReactiveGradientAsset => {\n    return new ReactiveGradientAsset(\n      'reactive-angular',\n      { type: 'angular', options, __reactive: true },\n      updateCallback\n    )\n  },\n\n  /**\n   * Create a reactive state gradient\n   */\n  state: (\n    name: string,\n    options: ReactiveStateGradientAsset['reactiveStateGradients'],\n    updateCallback?: () => void\n  ): ReactiveStateGradientAsset => {\n    return new ReactiveStateGradientAsset(name, options, updateCallback)\n  }\n} as const\n\n/**\n * Utility functions for working with reactive gradients\n */\nexport const ReactiveGradientUtils = {\n  /**\n   * Create an animated gradient that cycles through colors\n   */\n  createAnimatedGradient: (\n    colors: string[],\n    _duration: number = 3000\n  ): ReactiveGradientAsset => {\n    // This would need actual signal implementation\n    // Placeholder for the concept\n    const colorSignal = {\n      value: colors[0],\n      subscribe: (_callback: () => void) => {\n        // Implementation would cycle through colors\n        return () => {} // unsubscribe\n      }\n    } satisfies Signal<string>\n\n    return ReactiveGradients.linear({\n      colors: [colorSignal, colors[1]],\n      startPoint: 'top',\n      endPoint: 'bottom'\n    })\n  },\n\n  /**\n   * Create a progress gradient that fills based on a signal\n   */\n  createProgressGradient: (\n    progressSignal: Signal<number>,\n    color: string = '#007AFF'\n  ): ReactiveGradientAsset => {\n    return ReactiveGradients.linear({\n      colors: [color, 'transparent'],\n      stops: [progressSignal, progressSignal], // Both stops use the same signal\n      startPoint: 'leading',\n      endPoint: 'trailing'\n    })\n  },\n\n  /**\n   * Create a data-driven gradient that reflects numeric values\n   */\n  createDataGradient: (\n    _valueSignal: Signal<number>,\n    _minValue: number,\n    _maxValue: number,\n    colorScale: string[] = ['#ff0000', '#ffff00', '#00ff00']\n  ): ReactiveGradientAsset => {\n    // Implementation would map value to color index\n    // This is a conceptual placeholder\n    return ReactiveGradients.linear({\n      colors: colorScale,\n      startPoint: 'top',\n      endPoint: 'bottom'\n    })\n  }\n} as const\n\n/**\n * Enhanced background modifier support for reactive gradients\n */\nexport const ReactiveBackgroundUtils = {\n  /**\n   * Check if a background value is reactive\n   */\n  isReactiveBackground: (value: unknown): value is ReactiveGradientAsset | ReactiveStateGradientAsset => {\n    return value instanceof ReactiveGradientAsset || value instanceof ReactiveStateGradientAsset\n  },\n\n  /**\n   * Create a reactive background from a signal\n   */\n  fromSignal: (backgroundSignal: Signal<StatefulBackgroundValue>): ReactiveStateGradientAsset => {\n    return ReactiveGradients.state('signal-background', {\n      default: backgroundSignal\n    })\n  }\n} as const"],"names":["ReactiveGradientAsset","AssetClass","name","reactiveDefinition","updateCallback","__publicField","newDefinition","unsubscribe","type","options","LinearGradient","RadialGradient","AngularGradient","color","stop","value","_key","item","gradient","gradientToCSS","ReactiveStateGradientAsset","StateGradientAsset","reactiveStateGradients","initialState","newState","resolvedState","reactiveState","resolved","key","ReactiveGradients","ReactiveGradientUtils","colors","_duration","colorSignal","_callback","progressSignal","_valueSignal","_minValue","_maxValue","colorScale","ReactiveBackgroundUtils","backgroundSignal"],"mappings":"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"}

package/dist/gradients/state-gradient-asset.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../assets/Asset.cjs"),o=require("./css-generator.cjs");var d=Object.defineProperty,h=(i,t,e)=>t in i?d(i,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[t]=e,n=(i,t,e)=>h(i,typeof t!="symbol"?t+"":t,e);class r extends a.Asset{constructor(t,e){super(t),this.stateGradients=e,n(this,"currentState","default"),n(this,"animationOptions"),n(this,"resolvedGradientCache",new Map),n(this,"isTransitioning",!1),this.animationOptions=e.animation||{duration:300,easing:"ease",delay:0},this.preResolveGradients()}setState(t){t!==this.currentState&&this.stateGradients[t]&&!this.isTransitioning&&(this.currentState=t,this.animationOptions.duration&&this.animationOptions.duration>0&&(this.isTransitioning=!0,setTimeout(()=>{this.isTransitioning=!1},this.animationOptions.duration+(this.animationOptions.delay||0))))}getState(){return this.currentState}resolve(){const t=this.currentState;if(this.resolvedGradientCache.has(t))return this.resolvedGradientCache.get(t);const e=this.stateGradients[this.currentState]||this.stateGradients.default,s=this.resolveGradientValue(e);return this.resolvedGradientCache.set(t,s),s}getStateGradient(t){const e=this.stateGradients[t]||this.stateGradients.default;return this.resolveGradientValue(e)}getAnimationCSS(){const{duration:t,easing:e,delay:s}=this.animationOptions;return`transition: background ${t}ms ${e} ${s||0}ms;`}getAvailableStates(){return Object.keys(this.stateGradients).filter(t=>this.stateGradients[t]!==void 0)}hasState(t){return t in this.stateGradients&&this.stateGradients[t]!==void 0}setAnimation(t){this.animationOptions={...this.animationOptions,...t}}resolveGradientValue(t){return typeof t=="string"?t:this.isAsset(t)?t.resolve():this.isGradientDefinition(t)?o.gradientToCSS(t):""}isAsset(t){return t&&typeof t=="object"&&typeof t.resolve=="function"}isGradientDefinition(t){return t&&typeof t=="object"&&"type"in t&&"options"in t}preResolveGradients(){Object.keys(this.stateGradients).forEach(t=>{const e=t;if(e!=="animation"&&this.stateGradients[e]){const s=this.resolveGradientValue(this.stateGradients[e]);this.resolvedGradientCache.set(e,s)}})}clearCache(){this.resolvedGradientCache.clear(),this.preResolveGradients()}updateStateGradients(t){this.stateGradients=t,this.animationOptions=t.animation||this.animationOptions,this.clearCache()}}function c(i,t){return new r(i,t)}exports.StateGradient=c;exports.StateGradientAsset=r;
+//# sourceMappingURL=state-gradient-asset.cjs.map

package/dist/gradients/state-gradient-asset.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-gradient-asset.cjs","sources":["../../src/gradients/state-gradient-asset.ts"],"sourcesContent":["import { Asset } from '../assets/Asset'\nimport type { \n  StateGradientOptions, \n  GradientDefinition, \n  GradientAnimationOptions \n} from './types'\nimport { gradientToCSS } from './css-generator'\n\n/**\n * State-aware gradient asset that manages different gradients for interaction states\n * \n * Provides hover, active, focus, and disabled state support with smooth transitions.\n */\nexport class StateGradientAsset extends Asset<string> {\n  private currentState: keyof StateGradientOptions = 'default'\n  private animationOptions: GradientAnimationOptions\n  private resolvedGradientCache: Map<string, string> = new Map()\n  private isTransitioning: boolean = false\n\n  constructor(\n    name: string,\n    private stateGradients: StateGradientOptions\n  ) {\n    super(name)\n    this.animationOptions = stateGradients.animation || {\n      duration: 300,\n      easing: 'ease',\n      delay: 0\n    }\n    \n    // Pre-resolve all gradients for performance\n    this.preResolveGradients()\n  }\n\n  /**\n   * Set the current interaction state\n   */\n  setState(state: keyof StateGradientOptions): void {\n    if (state !== this.currentState && this.stateGradients[state] && !this.isTransitioning) {\n      this.currentState = state\n      \n      // Set transition flag to prevent rapid state changes during animation\n      if (this.animationOptions.duration && this.animationOptions.duration > 0) {\n        this.isTransitioning = true\n        setTimeout(() => {\n          this.isTransitioning = false\n        }, this.animationOptions.duration + (this.animationOptions.delay || 0))\n      }\n    }\n  }\n\n  /**\n   * Get the current state\n   */\n  getState(): keyof StateGradientOptions {\n    return this.currentState\n  }\n\n  /**\n   * Resolve the current gradient to CSS\n   */\n  resolve(): string {\n    // Use cached result if available\n    const cacheKey = this.currentState\n    if (this.resolvedGradientCache.has(cacheKey)) {\n      return this.resolvedGradientCache.get(cacheKey)!\n    }\n    \n    const gradient = this.stateGradients[this.currentState] || this.stateGradients.default\n    const resolved = this.resolveGradientValue(gradient as GradientDefinition | string | Asset)\n    \n    // Cache the result\n    this.resolvedGradientCache.set(cacheKey, resolved)\n    return resolved\n  }\n\n  /**\n   * Get gradient for a specific state without changing current state\n   */\n  getStateGradient(state: keyof StateGradientOptions): string {\n    const gradient = this.stateGradients[state] || this.stateGradients.default\n    return this.resolveGradientValue(gradient as GradientDefinition | string | Asset)\n  }\n\n  /**\n   * Get animation CSS properties for transitions\n   */\n  getAnimationCSS(): string {\n    const { duration, easing, delay } = this.animationOptions\n    return `transition: background ${duration}ms ${easing} ${delay || 0}ms;`\n  }\n\n  /**\n   * Get all available states\n   */\n  getAvailableStates(): (keyof StateGradientOptions)[] {\n    return Object.keys(this.stateGradients).filter(\n      key => this.stateGradients[key as keyof StateGradientOptions] !== undefined\n    ) as (keyof StateGradientOptions)[]\n  }\n\n  /**\n   * Check if a state is available\n   */\n  hasState(state: keyof StateGradientOptions): boolean {\n    return state in this.stateGradients && this.stateGradients[state] !== undefined\n  }\n\n  /**\n   * Update animation options\n   */\n  setAnimation(options: Partial<GradientAnimationOptions>): void {\n    this.animationOptions = { ...this.animationOptions, ...options }\n  }\n\n  private resolveGradientValue(value: GradientDefinition | string | Asset): string {\n    if (typeof value === 'string') {\n      return value\n    }\n\n    if (this.isAsset(value)) {\n      return value.resolve() as string\n    }\n\n    if (this.isGradientDefinition(value)) {\n      return gradientToCSS(value)\n    }\n\n    return ''\n  }\n\n  private isAsset(value: any): value is Asset {\n    return value && typeof value === 'object' && typeof value.resolve === 'function'\n  }\n\n  private isGradientDefinition(value: any): value is GradientDefinition {\n    return value && typeof value === 'object' && 'type' in value && 'options' in value\n  }\n\n  /**\n   * Pre-resolve all gradients to improve runtime performance\n   */\n  private preResolveGradients(): void {\n    Object.keys(this.stateGradients).forEach(stateKey => {\n      const state = stateKey as keyof StateGradientOptions\n      if (state !== 'animation' && this.stateGradients[state]) {\n        const resolved = this.resolveGradientValue(this.stateGradients[state]!)\n        this.resolvedGradientCache.set(state, resolved)\n      }\n    })\n  }\n\n  /**\n   * Clear the gradient cache (useful when gradients change dynamically)\n   */\n  clearCache(): void {\n    this.resolvedGradientCache.clear()\n    this.preResolveGradients()\n  }\n\n  /**\n   * Force update animation options and clear cache if needed\n   */\n  updateStateGradients(newGradients: StateGradientOptions): void {\n    this.stateGradients = newGradients\n    this.animationOptions = newGradients.animation || this.animationOptions\n    this.clearCache()\n  }\n}\n\n/**\n * Create a state-based gradient asset\n */\nexport function StateGradient(\n  name: string,\n  gradients: StateGradientOptions\n): StateGradientAsset {\n  return new StateGradientAsset(name, gradients)\n}"],"names":["StateGradientAsset","Asset","name","stateGradients","__publicField","state","cacheKey","gradient","resolved","duration","easing","delay","key","options","value","gradientToCSS","stateKey","newGradients","StateGradient","gradients"],"mappings":"oTAaO,MAAMA,UAA2BC,EAAAA,KAAc,CAMpD,YACEC,EACQC,EACR,CACA,MAAMD,CAAI,EAFF,KAAA,eAAAC,EAPVC,EAAA,KAAQ,eAA2C,SAAA,EACnDA,EAAA,KAAQ,kBAAA,EACRA,EAAA,KAAQ,4BAAiD,GAAI,EAC7DA,EAAA,KAAQ,kBAA2B,EAAA,EAOjC,KAAK,iBAAmBD,EAAe,WAAa,CAClD,SAAU,IACV,OAAQ,OACR,MAAO,CAAA,EAIT,KAAK,oBAAA,CACP,CAKA,SAASE,EAAyC,CAC5CA,IAAU,KAAK,cAAgB,KAAK,eAAeA,CAAK,GAAK,CAAC,KAAK,kBACrE,KAAK,aAAeA,EAGhB,KAAK,iBAAiB,UAAY,KAAK,iBAAiB,SAAW,IACrE,KAAK,gBAAkB,GACvB,WAAW,IAAM,CACf,KAAK,gBAAkB,EACzB,EAAG,KAAK,iBAAiB,UAAY,KAAK,iBAAiB,OAAS,EAAE,GAG5E,CAKA,UAAuC,CACrC,OAAO,KAAK,YACd,CAKA,SAAkB,CAEhB,MAAMC,EAAW,KAAK,aACtB,GAAI,KAAK,sBAAsB,IAAIA,CAAQ,EACzC,OAAO,KAAK,sBAAsB,IAAIA,CAAQ,EAGhD,MAAMC,EAAW,KAAK,eAAe,KAAK,YAAY,GAAK,KAAK,eAAe,QACzEC,EAAW,KAAK,qBAAqBD,CAA+C,EAG1F,YAAK,sBAAsB,IAAID,EAAUE,CAAQ,EAC1CA,CACT,CAKA,iBAAiBH,EAA2C,CAC1D,MAAME,EAAW,KAAK,eAAeF,CAAK,GAAK,KAAK,eAAe,QACnE,OAAO,KAAK,qBAAqBE,CAA+C,CAClF,CAKA,iBAA0B,CACxB,KAAM,CAAE,SAAAE,EAAU,OAAAC,EAAQ,MAAAC,CAAA,EAAU,KAAK,iBACzC,MAAO,0BAA0BF,CAAQ,MAAMC,CAAM,IAAIC,GAAS,CAAC,KACrE,CAKA,oBAAqD,CACnD,OAAO,OAAO,KAAK,KAAK,cAAc,EAAE,OACtCC,GAAO,KAAK,eAAeA,CAAiC,IAAM,MAAA,CAEtE,CAKA,SAASP,EAA4C,CACnD,OAAOA,KAAS,KAAK,gBAAkB,KAAK,eAAeA,CAAK,IAAM,MACxE,CAKA,aAAaQ,EAAkD,CAC7D,KAAK,iBAAmB,CAAE,GAAG,KAAK,iBAAkB,GAAGA,CAAA,CACzD,CAEQ,qBAAqBC,EAAoD,CAC/E,OAAI,OAAOA,GAAU,SACZA,EAGL,KAAK,QAAQA,CAAK,EACbA,EAAM,QAAA,EAGX,KAAK,qBAAqBA,CAAK,EAC1BC,EAAAA,cAAcD,CAAK,EAGrB,EACT,CAEQ,QAAQA,EAA4B,CAC1C,OAAOA,GAAS,OAAOA,GAAU,UAAY,OAAOA,EAAM,SAAY,UACxE,CAEQ,qBAAqBA,EAAyC,CACpE,OAAOA,GAAS,OAAOA,GAAU,UAAY,SAAUA,GAAS,YAAaA,CAC/E,CAKQ,qBAA4B,CAClC,OAAO,KAAK,KAAK,cAAc,EAAE,QAAQE,GAAY,CACnD,MAAMX,EAAQW,EACd,GAAIX,IAAU,aAAe,KAAK,eAAeA,CAAK,EAAG,CACvD,MAAMG,EAAW,KAAK,qBAAqB,KAAK,eAAeH,CAAK,CAAE,EACtE,KAAK,sBAAsB,IAAIA,EAAOG,CAAQ,CAChD,CACF,CAAC,CACH,CAKA,YAAmB,CACjB,KAAK,sBAAsB,MAAA,EAC3B,KAAK,oBAAA,CACP,CAKA,qBAAqBS,EAA0C,CAC7D,KAAK,eAAiBA,EACtB,KAAK,iBAAmBA,EAAa,WAAa,KAAK,iBACvD,KAAK,WAAA,CACP,CACF,CAKO,SAASC,EACdhB,EACAiB,EACoB,CACpB,OAAO,IAAInB,EAAmBE,EAAMiB,CAAS,CAC/C"}

package/dist/gradients/state-gradient-asset.d.ts

@@ -0,0 +1,67 @@
+import { Asset } from '../assets/Asset';
+import type { StateGradientOptions, GradientAnimationOptions } from './types';
+/**
+ * State-aware gradient asset that manages different gradients for interaction states
+ *
+ * Provides hover, active, focus, and disabled state support with smooth transitions.
+ */
+export declare class StateGradientAsset extends Asset<string> {
+    private stateGradients;
+    private currentState;
+    private animationOptions;
+    private resolvedGradientCache;
+    private isTransitioning;
+    constructor(name: string, stateGradients: StateGradientOptions);
+    /**
+     * Set the current interaction state
+     */
+    setState(state: keyof StateGradientOptions): void;
+    /**
+     * Get the current state
+     */
+    getState(): keyof StateGradientOptions;
+    /**
+     * Resolve the current gradient to CSS
+     */
+    resolve(): string;
+    /**
+     * Get gradient for a specific state without changing current state
+     */
+    getStateGradient(state: keyof StateGradientOptions): string;
+    /**
+     * Get animation CSS properties for transitions
+     */
+    getAnimationCSS(): string;
+    /**
+     * Get all available states
+     */
+    getAvailableStates(): (keyof StateGradientOptions)[];
+    /**
+     * Check if a state is available
+     */
+    hasState(state: keyof StateGradientOptions): boolean;
+    /**
+     * Update animation options
+     */
+    setAnimation(options: Partial<GradientAnimationOptions>): void;
+    private resolveGradientValue;
+    private isAsset;
+    private isGradientDefinition;
+    /**
+     * Pre-resolve all gradients to improve runtime performance
+     */
+    private preResolveGradients;
+    /**
+     * Clear the gradient cache (useful when gradients change dynamically)
+     */
+    clearCache(): void;
+    /**
+     * Force update animation options and clear cache if needed
+     */
+    updateStateGradients(newGradients: StateGradientOptions): void;
+}
+/**
+ * Create a state-based gradient asset
+ */
+export declare function StateGradient(name: string, gradients: StateGradientOptions): StateGradientAsset;
+//# sourceMappingURL=state-gradient-asset.d.ts.map

package/dist/gradients/state-gradient-asset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-gradient-asset.d.ts","sourceRoot":"","sources":["../../src/gradients/state-gradient-asset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,KAAK,EACV,oBAAoB,EAEpB,wBAAwB,EACzB,MAAM,SAAS,CAAA;AAGhB;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,KAAK,CAAC,MAAM,CAAC;IAQjD,OAAO,CAAC,cAAc;IAPxB,OAAO,CAAC,YAAY,CAAwC;IAC5D,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,qBAAqB,CAAiC;IAC9D,OAAO,CAAC,eAAe,CAAiB;gBAGtC,IAAI,EAAE,MAAM,EACJ,cAAc,EAAE,oBAAoB;IAa9C;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,oBAAoB,GAAG,IAAI;IAcjD;;OAEG;IACH,QAAQ,IAAI,MAAM,oBAAoB;IAItC;;OAEG;IACH,OAAO,IAAI,MAAM;IAejB;;OAEG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,oBAAoB,GAAG,MAAM;IAK3D;;OAEG;IACH,eAAe,IAAI,MAAM;IAKzB;;OAEG;IACH,kBAAkB,IAAI,CAAC,MAAM,oBAAoB,CAAC,EAAE;IAMpD;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,oBAAoB,GAAG,OAAO;IAIpD;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,wBAAwB,CAAC,GAAG,IAAI;IAI9D,OAAO,CAAC,oBAAoB;IAgB5B,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,oBAAoB;IAI5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAU3B;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACH,oBAAoB,CAAC,YAAY,EAAE,oBAAoB,GAAG,IAAI;CAK/D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,oBAAoB,GAC9B,kBAAkB,CAEpB"}