@tachui/core 0.8.1-alpha → 0.8.8

package/dist/reactive/index.js

@@ -1,493 +1,87 @@
-import { W as g, U as u, O as c, V as v, y as b, w as E, v as y, G as C, g as w, l as h, r as q, k as F } from "../scheduler-BKeqwrYE.js";
-import { R as he, T as pe, j as me, n as ge, p as ve, c as be, a as ye, b as Se, h as Ee, q as Ce, d as we, s as qe, e as Fe, t as Ne, K as _e, f as Oe, A as Re, H as $e, L as Ie, m as xe, B as Pe, I as De, M as Ue, i as Me, J as Te, x as ze, o as Ae, C as Le, D as Ve, E as We, F as je, N as He, z as Be, u as Ge } from "../scheduler-BKeqwrYE.js";
-import { c as Je, a as Ke, b as Qe, d as Xe } from "../effect-B9Knft0b.js";
-import { ComputationState as d } from "./types.js";
-var N = Object.defineProperty, _ = (t, e, r) => e in t ? N(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, o = (t, e, r) => _(t, typeof e != "symbol" ? e + "" : e, r);
-let O = 0;
-class R {
-  constructor(e, r = {}) {
-    this.effectFn = e, o(this, "id", ++O), o(this, "type", "effect"), o(this, "priority"), o(this, "sources", /* @__PURE__ */ new Set()), o(this, "observers", /* @__PURE__ */ new Set()), o(this, "isDisposed", !1), o(this, "cleanupFn"), o(this, "options"), o(this, "owner"), this.priority = r.priority ?? u.Normal, this.options = r, this.owner = g(), r.fireImmediately !== !1 && this.execute();
-  }
-  /**
-   * Notify method called by unified scheduler
-   */
-  notify() {
-    this.isDisposed || this.execute();
-  }
-  /**
-   * Execute the effect with proper error handling
-   */
-  execute() {
-    if (this.isDisposed) return;
-    if (this.cleanupFn) {
-      try {
-        this.cleanupFn();
-      } catch (s) {
-        console.error("Effect cleanup error:", s);
-      }
-      this.cleanupFn = void 0;
-    }
-    for (const s of this.sources)
-      "removeObserver" in s && typeof s.removeObserver == "function" ? s.removeObserver(this) : "observers" in s && s.observers instanceof Set && s.observers.delete(this);
-    this.sources.clear();
-    const e = v(), r = this.setCurrentComputation || (() => {
-    });
-    r(this);
-    try {
-      const s = this.effectFn();
-      typeof s == "function" && (this.cleanupFn = s);
-    } catch (s) {
-      if (this.options.onError)
-        try {
-          this.options.onError(s);
-        } catch (n) {
-          throw console.error("Effect error handler threw error:", n), s;
-        }
-      else
-        throw console.error(`Effect ${this.options.debugName || this.id} threw error:`, s), s;
-    } finally {
-      r(e);
-    }
-  }
-  /**
-   * Complete cleanup for memory management
-   */
-  cleanup() {
-    if (this.isDisposed = !0, this.cleanupFn) {
-      try {
-        this.cleanupFn();
-      } catch (e) {
-        console.error("Effect cleanup error:", e);
-      }
-      this.cleanupFn = void 0;
-    }
-    for (const e of this.sources)
-      "removeObserver" in e && typeof e.removeObserver == "function" ? e.removeObserver(this) : "observers" in e && e.observers instanceof Set && e.observers.delete(this);
-    if (this.sources.clear(), this.owner?.cleanups) {
-      const e = this.owner.cleanups.indexOf(this.cleanup.bind(this));
-      e >= 0 && this.owner.cleanups.splice(e, 1);
-    }
-  }
-  /**
-   * Dispose the effect (alias for cleanup)
-   */
-  dispose() {
-    this.cleanup();
-  }
-  /**
-   * Check if effect is disposed
-   */
-  get disposed() {
-    return this.isDisposed;
-  }
-  /**
-   * Debug information
-   */
-  [Symbol.for("tachui.debug")]() {
-    return {
-      id: this.id,
-      type: this.type,
-      priority: u[this.priority],
-      debugName: this.options.debugName,
-      disposed: this.isDisposed,
-      sourceCount: this.sources.size,
-      hasCleanup: !!this.cleanupFn
-    };
-  }
-  toString() {
-    return `Effect(${this.options.debugName || this.id})`;
-  }
-}
-function l(t, e) {
-  const r = new R(t, e), s = g();
-  return s && s.cleanups.push(() => r.cleanup()), () => r.cleanup();
-}
-function A(t, e) {
-  return l(t, { ...e, priority: u.High });
-}
-function L(t, e) {
-  return l(t, { ...e, priority: u.Low });
-}
-function V(t, e) {
-  return l(t, { ...e, fireImmediately: !1 });
-}
-function W(t, e, r = 3, s) {
-  let n = 0;
-  const f = () => {
-    try {
-      return t();
-    } catch (m) {
-      if (n++, e && n <= r && e(m, n)) {
-        setTimeout(() => f(), n * 100);
-        return;
-      } else
-        throw m;
-    }
-  };
-  return l(f, {
-    ...s,
-    debugName: `${s?.debugName || "effect"}(resilient)`
-  });
-}
-function j(t) {
-  const e = t.map(({ fn: r, options: s }) => l(r, s));
-  return () => {
-    e.forEach((r) => r());
-  };
-}
-function H() {
-  return c.getInstance().getPerformanceMetrics();
-}
-function B() {
-  c.getInstance().flushSync();
-}
-var $ = Object.defineProperty, I = (t, e, r) => e in t ? $(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, a = (t, e, r) => I(t, typeof e != "symbol" ? e + "" : e, r);
-let x = 0;
-class P {
-  constructor(e, r = {}) {
-    a(this, "id", ++x), a(this, "type", "signal"), a(this, "priority"), a(this, "observers", /* @__PURE__ */ new Set()), a(this, "_value"), a(this, "scheduler", c.getInstance()), a(this, "equalsFn"), a(this, "debugName"), a(this, "options"), this._value = e, this.options = r, this.priority = r.priority ?? u.Normal, this.equalsFn = r.equals ?? E, this.debugName = r.debugName;
-  }
-  /**
-   * Get the current value and track dependency
-   */
-  getValue() {
-    const e = v();
-    return e && e.state !== d.Disposed && (this.observers.add(e), e.sources.add(this)), this._value;
-  }
-  /**
-   * Get the current value without tracking dependency
-   */
-  peek() {
-    return this._value;
-  }
-  /**
-   * Set a new value using custom equality function
-   */
-  setValue(e) {
-    const r = typeof e == "function" ? e(this._value) : e;
-    if (!this.equalsFn(r, this._value)) {
-      const s = this._value;
-      this._value = r, process.env.NODE_ENV === "development" && this.debugName && console.debug(`[Signal:${this.debugName}] ${s} -> ${r}`), this.scheduler.schedule(this);
-    }
-    return r;
-  }
-  /**
-   * Notify all observers (called by scheduler)
-   */
-  notify() {
-    for (const e of this.observers)
-      e.state !== d.Disposed && (e.state = d.Dirty, "type" in e && "priority" in e && this.scheduler.schedule(e));
-  }
-  /**
-   * Remove an observer (cleanup)
-   */
-  removeObserver(e) {
-    this.observers.delete(e);
-  }
-  /**
-   * Complete cleanup for memory management
-   */
-  cleanup() {
-    for (const e of this.observers)
-      e.sources.delete(this);
-    this.observers.clear();
-  }
-  /**
-   * Get debug information about this signal
-   */
-  [Symbol.for("tachui.debug")]() {
-    return {
-      id: this.id,
-      type: this.type,
-      value: this._value,
-      observerCount: this.observers.size,
-      priority: u[this.priority],
-      debugName: this.debugName,
-      equalsFn: this.equalsFn.name || "anonymous"
-    };
-  }
-  toString() {
-    return `Signal(${this.options.debugName || this.id}): ${this._value}`;
-  }
-}
-function p(t, e) {
-  const r = new P(t, e), s = r.getValue.bind(r);
-  s.peek = r.peek.bind(r);
-  const n = r.setValue.bind(r);
-  return Object.defineProperty(s, Symbol.for("tachui.signal"), {
-    value: r,
-    enumerable: !1
-  }), [s, n];
-}
-function G(t, e) {
-  return p(t, {
-    ...e,
-    equals: y
-  });
-}
-function k(t, e) {
-  return p(t, {
-    ...e,
-    equals: b
-  });
-}
-function J(t) {
-  return t[Symbol.for("tachui.signal")] || null;
-}
-function K(t) {
-  return typeof t == "function" && Symbol.for("tachui.signal") in t;
-}
-function Q() {
-  c.getInstance().flushSync();
-}
-function X() {
-  return c.getInstance().getPerformanceMetrics();
-}
-let S = !0, i = {
-  signalsConverted: 0,
-  computedsConverted: 0,
-  effectsConverted: 0,
-  errorsFixed: 0
-};
-function Y(t) {
-  return S && console.warn(
-    "createLegacySignal is deprecated. Use createSignal() or createEnhancedSignal() instead. See: https://docs.tachui.dev/migration/reactive-system"
-  ), i.signalsConverted++, C(t);
-}
-function D(t, e) {
-  const r = t[0]();
-  let s;
-  switch (e?.equals) {
-    case "deep":
-      s = y;
-      break;
-    case "shallow":
-      s = b;
-      break;
-    case "custom":
-      s = e.customEquals;
-      break;
-    default:
-      s = void 0;
-  }
-  return i.signalsConverted++, p(r, {
-    equals: s,
-    priority: e?.priority,
-    debugName: e?.debugName
-  });
-}
-function Z(t) {
-  const e = t(), r = [];
-  let s = "enhanced";
-  return typeof e == "object" && e !== null && (Array.isArray(e) ? (r.push("Consider using deepEquals for array values to detect mutations"), r.push("Use createDeepSignal() for automatic deep comparison"), s = "deep") : (r.push("Consider using shallowEquals for object values with simple properties"), r.push("Use createShallowSignal() for automatic shallow comparison"), s = "shallow")), r.length === 0 && r.push("Signal looks good for reference equality"), { recommendations: r, suggestedMigration: s };
-}
-function ee(t) {
-  const e = {
-    signals: [],
-    computeds: [],
-    effects: [],
-    cleanup: () => {
-    }
-  };
-  t.signals && (e.signals = t.signals.map(
-    ({ original: s, options: n }) => D(s, n)
-  )), t.computeds && (e.computeds = t.computeds.map(({ original: s, options: n }) => (i.computedsConverted++, w(s, n))));
-  const r = [];
-  return t.effects && t.effects.forEach(({ original: s, options: n }) => {
-    i.effectsConverted++;
-    const f = l(s, n);
-    r.push(f);
-  }), e.cleanup = () => {
-    r.forEach((s) => s());
-  }, e;
-}
-function te(t) {
-  const e = [];
-  let r = t;
-  return [
-    {
-      from: /createSignal\(/g,
-      to: "createEnhancedSignal(",
-      description: "Upgraded createSignal to createEnhancedSignal"
-    },
-    {
-      from: /createComputed\(([^,]+)\)/g,
-      to: "createComputed($1, { debugName: 'computed' })",
-      description: "Added debug name to createComputed"
-    },
-    {
-      from: /createEffect\(([^,]+)\)/g,
-      to: "createEnhancedEffect($1, { debugName: 'effect' })",
-      description: "Upgraded createEffect to createEnhancedEffect with debug name"
-    }
-  ].forEach((n) => {
-    r.match(n.from) && (r = r.replace(n.from, n.to), e.push(n.description));
-  }), { newCode: r, transformations: e };
-}
-function U() {
-  const t = c.getInstance(), e = t.getPerformanceMetrics(), r = [];
-  let s = 100;
-  return e.errorCount > 0 && (r.push(`Fix ${e.errorCount} reactive errors for better stability`), s -= e.errorCount * 5), e.averageUpdateTime > 16 && (r.push("Update times exceed 16ms - consider optimizing computations"), s -= 20), e.totalNodes > 1e3 && (r.push("High number of reactive nodes - consider batching updates"), s -= 10), {
-    scheduler: t.getDebugInfo(),
-    signals: {
-      total: i.signalsConverted,
-      recommendations: ["Use appropriate equality functions for your data types"]
-    },
-    computeds: {
-      total: i.computedsConverted,
-      recommendations: ["Add error recovery for critical computations"]
-    },
-    effects: {
-      total: i.effectsConverted,
-      recommendations: ["Use appropriate priorities for different effect types"]
-    },
-    overallScore: Math.max(0, s),
-    recommendations: r
-  };
-}
-function re(t = { verbose: !1 }) {
-  const e = c.getInstance(), r = (n) => {
-    console.error("🔥 Reactive System Error:", n), i.errorsFixed++;
-  }, s = e.onError(r);
-  return t.verbose && (console.log("🔍 Reactive debugging enabled"), console.log("📊 Migration stats:", i)), () => {
-    s(), t.verbose && console.log("🔍 Reactive debugging disabled");
-  };
-}
-function se() {
-  return { ...i };
-}
-function ne() {
-  i = {
-    signalsConverted: 0,
-    computedsConverted: 0,
-    effectsConverted: 0,
-    errorsFixed: 0
-  };
-}
-function ie(t) {
-  S = t;
-}
-function oe() {
-  const t = U();
-  return `
-# TachUI Reactive System Migration Report
-
-## Statistics
-- Signals converted: ${i.signalsConverted}
-- Computeds converted: ${i.computedsConverted}
-- Effects converted: ${i.effectsConverted}
-- Errors fixed: ${i.errorsFixed}
-
-## Performance Score: ${t.overallScore}/100
-
-## Recommendations
-${t.recommendations.map((e) => `- ${e}`).join(`
-`)}
-
-## Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
-`;
-}
-function ae() {
-  return h() !== null;
-}
-function M(t) {
-  return q(null, t);
-}
-function ce(t) {
-  return M(() => F(t));
-}
-function ue() {
-  let t = h();
-  if (!t) return null;
-  for (; t.parent; )
-    t = t.parent;
-  return t;
-}
-function le() {
-  const t = [];
-  let e = h();
-  for (; e; )
-    t.push(e), e = e.parent;
-  return t;
-}
+import { T as t, c as s, a as r, b as c, e as i, f as n, d as l, g as o, h as g, o as u, s as f, i as d, j as h, k as E } from "../scheduler-DppMK9mR.js";
+import { R as m, M as p, U as R, q as y, w as q, x as v, a as C, b, y as w, n as x, z as M, c as P, A as T, B as O, E as L, I as U, f as I, J as j, p as k, v as z, g as B, K as D, d as W, i as A, F as G, o as F, L as H, G as J, H as K, u as N } from "../theme-CRLPHryV.js";
+import { c as V, b as X, a as Y, d as Z } from "../effect-BsW3fy1q.js";
+import { p as $, q as ee, i as ae, A as te, c as se, a as re, j as ce, b as ie, r as ne, d as le, s as oe, e as ge, k as ue, F as fe, G as de, f as he, t as Ee, g as Se, l as me, h as pe, m as Re, u as ye, B as qe, C as ve, n as Ce, o as be, D as we, v as xe, w as Me, x as Pe, y as Te, E as Oe, z as Le } from "../signal-list-07gNXGiW.js";
 export {
-  he as ReactiveError,
-  c as ReactiveScheduler,
-  pe as TaskPriority,
-  u as UpdatePriority,
-  U as analyzeReactivePerformance,
-  Z as analyzeSignalUsage,
-  me as batch,
-  ge as combineEquals,
-  ve as createArrayEquals,
-  be as createCleanupGroup,
-  w as createComputed,
-  G as createDeepSignal,
-  ce as createDetachedRoot,
-  Je as createEffect,
-  j as createEffectBatch,
-  l as createEnhancedEffect,
-  p as createEnhancedSignal,
-  ye as createEventListener,
-  A as createHighPriorityEffect,
-  Se as createInterval,
-  Y as createLegacySignal,
-  L as createLowPriorityEffect,
-  Ee as createMemo,
+  m as ReactiveError,
+  p as ReactiveScheduler,
+  t as TaskPriority,
+  R as UpdatePriority,
+  $ as analyzeReactivePerformance,
+  ee as analyzeSignalUsage,
+  y as batch,
+  q as combineEquals,
+  v as createArrayEquals,
+  s as createCleanupGroup,
+  C as createComputed,
+  ae as createDeepSignal,
+  te as createDetachedRoot,
+  V as createEffect,
+  se as createEffectBatch,
+  re as createEnhancedEffect,
+  ce as createEnhancedSignal,
+  r as createEventListener,
+  ie as createHighPriorityEffect,
+  c as createInterval,
+  ne as createLegacySignal,
+  le as createLowPriorityEffect,
+  b as createMemo,
   oe as createMigrationReport,
-  Ce as createObjectEquals,
-  Ke as createOnceEffect,
-  Qe as createRenderEffect,
-  W as createResilientEffect,
-  we as createResource,
-  F as createRoot,
-  qe as createSelectorEquals,
-  k as createShallowSignal,
-  C as createSignal,
-  Xe as createSyncEffect,
-  Fe as createTimeout,
-  V as createWatchEffect,
-  Ne as debugEquals,
-  y as deepEquals,
-  E as defaultEquals,
-  _e as detectSystemTheme,
-  Oe as dispose,
-  re as enableReactiveDebugging,
-  Re as enableScheduling,
-  B as flushEffectUpdates,
-  Q as flushSignalUpdates,
-  $e as flushSync,
-  Ie as getCurrentTheme,
-  H as getEffectPerformanceMetrics,
-  J as getEnhancedSignalImpl,
-  se as getMigrationStats,
-  h as getOwner,
-  le as getOwnerChain,
-  xe as getReactiveContext,
-  ue as getRootOwner,
-  Pe as getScheduler,
-  De as getSignalImpl,
-  X as getSignalPerformanceMetrics,
-  Ue as getThemeSignal,
-  Me as isComputed,
-  K as isEnhancedSignal,
-  ae as isReactiveContext,
-  Te as isSignal,
-  ze as jsonEquals,
-  ee as migrateBatch,
-  te as migrateReactiveCode,
-  D as migrateToEnhancedSignal,
-  Ae as onCleanup,
-  ne as resetMigrationStats,
-  M as runOutsideReactiveContext,
-  q as runWithOwner,
-  Le as scheduleIdle,
-  Ve as scheduleUpdate,
-  We as scheduleWithPriority,
-  ie as setMigrationWarnings,
-  je as setScheduler,
-  He as setTheme,
-  b as shallowEquals,
-  Be as structuralEquals,
-  Ge as untrack
+  w as createObjectEquals,
+  X as createOnceEffect,
+  Y as createRenderEffect,
+  ge as createResilientEffect,
+  i as createResource,
+  x as createRoot,
+  M as createSelectorEquals,
+  ue as createShallowSignal,
+  P as createSignal,
+  fe as createSignalList,
+  de as createSignalListControls,
+  Z as createSyncEffect,
+  n as createTimeout,
+  he as createWatchEffect,
+  T as debugEquals,
+  O as deepEquals,
+  L as defaultEquals,
+  U as detectSystemTheme,
+  l as dispose,
+  Ee as enableReactiveDebugging,
+  o as enableScheduling,
+  Se as flushEffectUpdates,
+  me as flushSignalUpdates,
+  I as flushSync,
+  j as getCurrentTheme,
+  pe as getEffectPerformanceMetrics,
+  Re as getEnhancedSignalImpl,
+  ye as getMigrationStats,
+  k as getOwner,
+  qe as getOwnerChain,
+  z as getReactiveContext,
+  ve as getRootOwner,
+  g as getScheduler,
+  B as getSignalImpl,
+  Ce as getSignalPerformanceMetrics,
+  D as getThemeSignal,
+  W as isComputed,
+  be as isEnhancedSignal,
+  we as isReactiveContext,
+  A as isSignal,
+  G as jsonEquals,
+  xe as migrateBatch,
+  Me as migrateReactiveCode,
+  Pe as migrateToEnhancedSignal,
+  u as onCleanup,
+  Te as resetMigrationStats,
+  Oe as runOutsideReactiveContext,
+  F as runWithOwner,
+  f as scheduleIdle,
+  d as scheduleUpdate,
+  h as scheduleWithPriority,
+  Le as setMigrationWarnings,
+  E as setScheduler,
+  H as setTheme,
+  J as shallowEquals,
+  K as structuralEquals,
+  N as untrack
 };

package/dist/reactive/signal-list.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Fine-Grained Reactive Lists
+ *
+ * Provides high-performance list management by separating array structure
+ * from item data. Each item gets its own signal, enabling surgical updates
+ * without triggering full reconciliation.
+ *
+ * @example
+ * ```typescript
+ * // Create a signal list with a key function
+ * const [items, list] = createSignalList(
+ *   [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }],
+ *   item => item.id
+ * )
+ *
+ * // In your component, track only the IDs (array structure)
+ * const ids = list.ids()
+ *
+ * // Render each row with its own reactive data
+ * ids.map(id => {
+ *   const getData = list.get(id)
+ *   return h('div', null, () => getData().name)  // Reactive text
+ * })
+ *
+ * // Update individual item - only that item re-renders
+ * list.update(1, { id: 1, name: 'Alice Updated' })
+ *
+ * // Replace all items - still surgical updates
+ * list.set([{ id: 1, name: 'Alice New' }, { id: 3, name: 'Charlie' }])
+ * ```
+ */
+export type SignalListKeyFn<T, K extends PropertyKey = PropertyKey> = (item: T) => K;
+export interface SignalListControls<T, K extends PropertyKey = PropertyKey> {
+    /**
+     * Get array of item keys/IDs. Track this in components to know which items exist.
+     * When this changes, component re-renders with new list structure.
+     */
+    ids: () => K[];
+    /**
+     * Get reactive getter for a specific item by key.
+     * Returns a function that reactively returns the current item data.
+     */
+    get: (key: K) => () => T;
+    /**
+     * Update a single item by key. Only triggers reactive updates for that item.
+     */
+    update: (key: K, item: T) => void;
+    /**
+     * Replace entire list. Updates existing items surgically, adds new ones, removes old ones.
+     */
+    set: (items: T[]) => void;
+    /**
+     * Clear all items.
+     */
+    clear: () => void;
+    /**
+     * Remove a specific item by key.
+     */
+    remove: (key: K) => void;
+    /**
+     * Reorder the list using an array of existing keys without touching item data.
+     */
+    reorder: (ids: K[]) => void;
+    /**
+     * Get all current items as a plain array (non-reactive).
+     */
+    getAll: () => T[];
+}
+/**
+ * Create a fine-grained reactive list where each item has its own signal.
+ *
+ * This enables surgical updates to individual items without triggering
+ * full component re-renders or reconciliation. The component tracks only
+ * the array of IDs (structure), while each item's data is tracked independently.
+ *
+ * **Performance Benefits**:
+ * - Updating 1 item in 1,000: 175x faster (no reconciliation)
+ * - Replacing all 1,000 items: 242x faster (surgical signal updates)
+ *
+ * **When to use**:
+ * - Large lists (100+ items) with frequent updates
+ * - Updates to individual items (e.g., editing one row)
+ * - Batch updates to item properties (e.g., marking all as read)
+ *
+ * **When NOT to use**:
+ * - Small lists (<20 items) - overhead not worth it
+ * - Lists that are fully replaced frequently - use regular createSignal
+ * - Lists where you never update individual items
+ *
+ * @param initialItems - Initial array of items
+ * @param keyFn - Function to extract unique key from each item (e.g., item => item.id)
+ * @returns Tuple of [ids signal, list controls]
+ */
+export declare function createSignalList<T, K extends PropertyKey = PropertyKey>(initialItems: T[], keyFn: SignalListKeyFn<T, K>): [() => T[], SignalListControls<T, K>];
+/**
+ * Helper to create list controls without the reactive getter.
+ * Useful when you always want to track structure, never all items.
+ */
+export declare function createSignalListControls<T, K extends PropertyKey = PropertyKey>(initialItems: T[], keyFn: SignalListKeyFn<T, K>): SignalListControls<T, K>;
+//# sourceMappingURL=signal-list.d.ts.map

package/dist/reactive/signal-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-list.d.ts","sourceRoot":"","sources":["../../src/reactive/signal-list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,GAAG,WAAW,IAAI,CACpE,IAAI,EAAE,CAAC,KACJ,CAAC,CAAA;AAEN,MAAM,WAAW,kBAAkB,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,GAAG,WAAW;IACxE;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC,EAAE,CAAA;IAEd;;;OAGG;IACH,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,MAAM,CAAC,CAAA;IAExB;;OAEG;IACH,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,IAAI,CAAA;IAEjC;;OAEG;IACH,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI,CAAA;IAEzB;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAA;IAEjB;;OAEG;IACH,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAA;IAExB;;OAEG;IACH,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAA;IAE3B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,GAAG,WAAW,EACrE,YAAY,EAAE,CAAC,EAAE,EACjB,KAAK,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC3B,CAAC,MAAM,CAAC,EAAE,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CA+LvC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,GAAG,WAAW,EAC7E,YAAY,EAAE,CAAC,EAAE,EACjB,KAAK,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC3B,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAG1B"}