@proyecto-viviana/solid-stately 0.0.6 → 0.1.0

package/src/toast/createToastState.ts

@@ -0,0 +1,316 @@
+/**
+ * Toast state management for SolidJS
+ * Based on @react-stately/toast useToastState
+ */
+
+import { createSignal, onCleanup, type Accessor } from 'solid-js';
+
+// ============================================
+// TYPES
+// ============================================
+
+export interface ToastOptions {
+  /** A timeout to automatically close the toast, in milliseconds. */
+  timeout?: number;
+  /** The priority of the toast relative to other toasts. */
+  priority?: number;
+  /** Handler called when the toast is closed. */
+  onClose?: () => void;
+}
+
+export interface QueuedToast<T> {
+  /** The content of the toast. */
+  content: T;
+  /** A unique key for the toast. */
+  key: string;
+  /** The timer for the toast. */
+  timer: Timer | null;
+  /** Whether the toast should be animated. */
+  animation?: 'entering' | 'exiting' | 'queued';
+  /** The priority of the toast. */
+  priority: number;
+  /** Handler called when the toast is closed. */
+  onClose?: () => void;
+  /** The timeout for the toast. */
+  timeout?: number;
+}
+
+export interface ToastQueueOptions {
+  /** The maximum number of toasts to display at once. */
+  maxVisibleToasts?: number;
+  /** Whether toasts should stack (true) or queue (false). */
+  hasExitAnimation?: boolean;
+}
+
+export interface ToastStateProps<T> {
+  /** The toast queue to use. */
+  queue: ToastQueue<T>;
+}
+
+export interface ToastState<T> {
+  /** The currently visible toasts. */
+  visibleToasts: Accessor<QueuedToast<T>[]>;
+  /** Adds a toast to the queue. */
+  add: (content: T, options?: ToastOptions) => string;
+  /** Closes a toast by key. */
+  close: (key: string) => void;
+  /** Pauses all toast timers. */
+  pauseAll: () => void;
+  /** Resumes all toast timers. */
+  resumeAll: () => void;
+}
+
+// ============================================
+// TIMER CLASS
+// ============================================
+
+/**
+ * A Timer that supports pause and resume.
+ */
+export class Timer {
+  private timerId: number | null = null;
+  private startTime: number = 0;
+  private remaining: number;
+  private callback: () => void;
+
+  constructor(callback: () => void, delay: number) {
+    this.callback = callback;
+    this.remaining = delay;
+    this.resume();
+  }
+
+  pause() {
+    if (this.timerId === null) {
+      return;
+    }
+    clearTimeout(this.timerId);
+    this.timerId = null;
+    this.remaining -= Date.now() - this.startTime;
+  }
+
+  resume() {
+    if (this.timerId !== null) {
+      return;
+    }
+    this.startTime = Date.now();
+    this.timerId = window.setTimeout(() => {
+      this.timerId = null;
+      this.callback();
+    }, this.remaining);
+  }
+
+  reset(delay: number) {
+    this.pause();
+    this.remaining = delay;
+    this.resume();
+  }
+
+  cancel() {
+    if (this.timerId !== null) {
+      clearTimeout(this.timerId);
+      this.timerId = null;
+    }
+  }
+}
+
+// ============================================
+// TOAST QUEUE CLASS
+// ============================================
+
+type SubscribeCallback<T> = (toasts: QueuedToast<T>[]) => void;
+
+/**
+ * A queue that manages toast notifications.
+ * Can be created once and shared across the app (singleton pattern).
+ */
+export class ToastQueue<T> {
+  private queue: QueuedToast<T>[] = [];
+  private subscriptions = new Set<SubscribeCallback<T>>();
+  private maxVisibleToasts: number;
+  private hasExitAnimation: boolean;
+  private keyCounter = 0;
+
+  constructor(options: ToastQueueOptions = {}) {
+    this.maxVisibleToasts = options.maxVisibleToasts ?? 5;
+    this.hasExitAnimation = options.hasExitAnimation ?? false;
+  }
+
+  /**
+   * Subscribe to queue changes.
+   */
+  subscribe(callback: SubscribeCallback<T>): () => void {
+    this.subscriptions.add(callback);
+    return () => {
+      this.subscriptions.delete(callback);
+    };
+  }
+
+  /**
+   * Add a toast to the queue.
+   */
+  add(content: T, options: ToastOptions = {}): string {
+    const key = String(this.keyCounter++);
+
+    const toast: QueuedToast<T> = {
+      content,
+      key,
+      timer: null,
+      priority: options.priority ?? 0,
+      onClose: options.onClose,
+      timeout: options.timeout,
+      animation: 'entering',
+    };
+
+    // Find insertion point based on priority
+    let low = 0;
+    let high = this.queue.length;
+    while (low < high) {
+      const mid = Math.floor((low + high) / 2);
+      if (toast.priority > this.queue[mid].priority) {
+        high = mid;
+      } else {
+        low = mid + 1;
+      }
+    }
+
+    // Insert at the correct position
+    this.queue = [
+      ...this.queue.slice(0, low),
+      toast,
+      ...this.queue.slice(low),
+    ];
+
+    // Start timer for visible toasts
+    this.updateVisibility();
+
+    return key;
+  }
+
+  /**
+   * Close a toast by key.
+   */
+  close(key: string): void {
+    const toast = this.queue.find((t) => t.key === key);
+    if (!toast) return;
+
+    // Cancel any existing timer
+    toast.timer?.cancel();
+    toast.timer = null;
+
+    if (this.hasExitAnimation && toast.animation !== 'queued') {
+      // Mark as exiting for animation
+      toast.animation = 'exiting';
+      this.notify();
+    } else {
+      // Remove immediately
+      this.remove(key);
+    }
+  }
+
+  /**
+   * Remove a toast after exit animation completes.
+   */
+  remove(key: string): void {
+    const toast = this.queue.find((t) => t.key === key);
+    if (toast) {
+      toast.onClose?.();
+      toast.timer?.cancel();
+    }
+
+    this.queue = this.queue.filter((t) => t.key !== key);
+    this.updateVisibility();
+  }
+
+  /**
+   * Pause all toast timers.
+   */
+  pauseAll(): void {
+    for (const toast of this.queue) {
+      toast.timer?.pause();
+    }
+  }
+
+  /**
+   * Resume all toast timers.
+   */
+  resumeAll(): void {
+    for (const toast of this.queue) {
+      toast.timer?.resume();
+    }
+  }
+
+  private updateVisibility(): void {
+    // Mark toasts as visible or queued based on maxVisibleToasts
+    const visibleCount = this.queue.filter(
+      (t) => t.animation !== 'queued' && t.animation !== 'exiting'
+    ).length;
+
+    let promoted = 0;
+    for (const toast of this.queue) {
+      if (toast.animation === 'queued' && visibleCount + promoted < this.maxVisibleToasts) {
+        toast.animation = 'entering';
+        promoted++;
+      }
+      if (toast.animation === 'queued') continue;
+
+      // Start timer for visible toasts
+      if (toast.timeout != null && toast.timer === null && toast.animation !== 'exiting') {
+        toast.timer = new Timer(() => {
+          this.close(toast.key);
+        }, toast.timeout);
+      }
+    }
+
+    this.notify();
+  }
+
+  private notify(): void {
+    const toasts = [...this.queue];
+    for (const callback of this.subscriptions) {
+      callback(toasts);
+    }
+  }
+}
+
+// ============================================
+// HOOK
+// ============================================
+
+/**
+ * Creates reactive toast state from a ToastQueue.
+ * Use this hook to subscribe to toast changes in your component.
+ */
+export function createToastState<T>(props: ToastStateProps<T>): ToastState<T> {
+  const [visibleToasts, setVisibleToasts] = createSignal<QueuedToast<T>[]>([]);
+
+  // Subscribe to queue changes
+  const unsubscribe = props.queue.subscribe((toasts) => {
+    setVisibleToasts(toasts);
+  });
+
+  onCleanup(() => {
+    unsubscribe();
+  });
+
+  return {
+    visibleToasts,
+    add: (content, options) => props.queue.add(content, options),
+    close: (key) => props.queue.close(key),
+    pauseAll: () => props.queue.pauseAll(),
+    resumeAll: () => props.queue.resumeAll(),
+  };
+}
+
+// ============================================
+// CONVENIENCE HOOKS
+// ============================================
+
+/**
+ * Creates a new ToastQueue and returns reactive state.
+ * Use this if you don't need a global queue.
+ */
+export function createToastQueue<T>(options?: ToastQueueOptions): ToastState<T> & { queue: ToastQueue<T> } {
+  const queue = new ToastQueue<T>(options);
+  const state = createToastState({ queue });
+  return { ...state, queue };
+}

package/src/toast/index.d.ts

@@ -0,0 +1,2 @@
+export { createToastState, createToastQueue, ToastQueue, Timer, type ToastOptions, type QueuedToast, type ToastQueueOptions, type ToastStateProps, type ToastState, } from './createToastState';
+//# sourceMappingURL=index.d.ts.map

package/src/toast/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACV,KAAK,EACL,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,UAAU,GAChB,MAAM,oBAAoB,CAAC"}

package/src/toast/index.ts

@@ -0,0 +1,11 @@
+export {
+  createToastState,
+  createToastQueue,
+  ToastQueue,
+  Timer,
+  type ToastOptions,
+  type QueuedToast,
+  type ToastQueueOptions,
+  type ToastStateProps,
+  type ToastState,
+} from './createToastState';

package/{dist → src}/toggle/createToggleState.d.ts

@@ -31,3 +31,4 @@ export interface ToggleState {
  * Provides state management for toggle components like checkboxes and switches.
  */
 export declare function createToggleState(props?: MaybeAccessor<ToggleStateOptions>): ToggleState;
+//# sourceMappingURL=createToggleState.d.ts.map

package/src/toggle/createToggleState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createToggleState.d.ts","sourceRoot":"","sources":["createToggleState.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAgB,QAAQ,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,EAAE,KAAK,aAAa,EAAU,MAAM,UAAU,CAAC;AAMtD,MAAM,WAAW,kBAAkB;IACjC,2DAA2D;IAC3D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,wEAAwE;IACxE,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;IACzC,wCAAwC;IACxC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,sCAAsC;IACtC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IACvC,iDAAiD;IACjD,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,+BAA+B;IAC/B,WAAW,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,CAAC;IACvC,kCAAkC;IAClC,MAAM,IAAI,IAAI,CAAC;CAChB;AAMD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,GAAE,aAAa,CAAC,kBAAkB,CAAM,GAAG,WAAW,CAiD5F"}

package/{dist → src}/toggle/index.d.ts

@@ -1 +1,2 @@
 export { createToggleState, type ToggleStateOptions, type ToggleState, } from './createToggleState';
+//# sourceMappingURL=index.d.ts.map

package/src/toggle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,KAAK,kBAAkB,EACvB,KAAK,WAAW,GACjB,MAAM,qBAAqB,CAAC"}

package/src/tooltip/createTooltipTriggerState.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Manages state for a tooltip trigger.
+ * Based on @react-stately/tooltip useTooltipTriggerState.
+ *
+ * Tracks whether the tooltip is open, and provides methods to toggle this state.
+ * Ensures only one tooltip is open at a time and controls the delay for showing a tooltip.
+ */
+import { type Accessor } from 'solid-js';
+import { type OverlayTriggerProps } from '../overlays';
+export interface TooltipTriggerProps extends OverlayTriggerProps {
+    /** The delay time in milliseconds for the tooltip to show up. */
+    delay?: number;
+    /** The delay time in milliseconds for the tooltip to close. */
+    closeDelay?: number;
+}
+export interface TooltipTriggerState {
+    /** Whether the tooltip is currently showing. */
+    readonly isOpen: Accessor<boolean>;
+    /**
+     * Shows the tooltip. By default, the tooltip becomes visible after a delay
+     * depending on a global warmup timer. The `immediate` option shows the
+     * tooltip immediately instead.
+     */
+    open(immediate?: boolean): void;
+    /** Hides the tooltip. */
+    close(immediate?: boolean): void;
+}
+/**
+ * Resets the global tooltip state. Useful for testing.
+ * @internal
+ */
+export declare function resetTooltipState(): void;
+/**
+ * Manages state for a tooltip trigger. Tracks whether the tooltip is open, and provides
+ * methods to toggle this state. Ensures only one tooltip is open at a time and controls
+ * the delay for showing a tooltip.
+ */
+export declare function createTooltipTriggerState(props?: TooltipTriggerProps): TooltipTriggerState;
+//# sourceMappingURL=createTooltipTriggerState.d.ts.map

package/src/tooltip/createTooltipTriggerState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTooltipTriggerState.d.ts","sourceRoot":"","sources":["createTooltipTriggerState.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAA2B,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,EAA6B,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAOlF,MAAM,WAAW,mBAAoB,SAAQ,mBAAmB;IAC9D,iEAAiE;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAClC,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IACnC;;;;OAIG;IACH,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,yBAAyB;IACzB,KAAK,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAClC;AASD;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAYxC;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,GAAE,mBAAwB,GAC9B,mBAAmB,CAkHrB"}

package/src/tooltip/createTooltipTriggerState.ts

@@ -0,0 +1,183 @@
+/**
+ * Manages state for a tooltip trigger.
+ * Based on @react-stately/tooltip useTooltipTriggerState.
+ *
+ * Tracks whether the tooltip is open, and provides methods to toggle this state.
+ * Ensures only one tooltip is open at a time and controls the delay for showing a tooltip.
+ */
+
+import { createSignal, onCleanup, type Accessor } from 'solid-js';
+import { createOverlayTriggerState, type OverlayTriggerProps } from '../overlays';
+import { isServer } from '../ssr';
+
+// Default delays (in ms)
+const TOOLTIP_DELAY = 1500;
+const TOOLTIP_COOLDOWN = 500;
+
+export interface TooltipTriggerProps extends OverlayTriggerProps {
+  /** The delay time in milliseconds for the tooltip to show up. */
+  delay?: number;
+  /** The delay time in milliseconds for the tooltip to close. */
+  closeDelay?: number;
+}
+
+export interface TooltipTriggerState {
+  /** Whether the tooltip is currently showing. */
+  readonly isOpen: Accessor<boolean>;
+  /**
+   * Shows the tooltip. By default, the tooltip becomes visible after a delay
+   * depending on a global warmup timer. The `immediate` option shows the
+   * tooltip immediately instead.
+   */
+  open(immediate?: boolean): void;
+  /** Hides the tooltip. */
+  close(immediate?: boolean): void;
+}
+
+// Global state for coordinating tooltips
+let tooltips: Record<string, (immediate?: boolean) => void> = {};
+let tooltipId = 0;
+let globalWarmedUp = false;
+let globalWarmUpTimeout: ReturnType<typeof setTimeout> | null = null;
+let globalCooldownTimeout: ReturnType<typeof setTimeout> | null = null;
+
+/**
+ * Resets the global tooltip state. Useful for testing.
+ * @internal
+ */
+export function resetTooltipState(): void {
+  tooltips = {};
+  tooltipId = 0;
+  globalWarmedUp = false;
+  if (globalWarmUpTimeout) {
+    clearTimeout(globalWarmUpTimeout);
+    globalWarmUpTimeout = null;
+  }
+  if (globalCooldownTimeout) {
+    clearTimeout(globalCooldownTimeout);
+    globalCooldownTimeout = null;
+  }
+}
+
+/**
+ * Manages state for a tooltip trigger. Tracks whether the tooltip is open, and provides
+ * methods to toggle this state. Ensures only one tooltip is open at a time and controls
+ * the delay for showing a tooltip.
+ */
+export function createTooltipTriggerState(
+  props: TooltipTriggerProps = {}
+): TooltipTriggerState {
+  const delay = () => props.delay ?? TOOLTIP_DELAY;
+  const closeDelay = () => props.closeDelay ?? TOOLTIP_COOLDOWN;
+
+  const overlayState = createOverlayTriggerState(props);
+  const id = `tooltip-${++tooltipId}`;
+
+  let closeTimeout: ReturnType<typeof setTimeout> | null = null;
+  const [closeCallback, setCloseCallback] = createSignal<() => void>(() => overlayState.close());
+
+  const ensureTooltipEntry = () => {
+    tooltips[id] = hideTooltip;
+  };
+
+  const closeOpenTooltips = () => {
+    for (const hideTooltipId in tooltips) {
+      if (hideTooltipId !== id) {
+        tooltips[hideTooltipId](true);
+        delete tooltips[hideTooltipId];
+      }
+    }
+  };
+
+  const showTooltip = () => {
+    if (closeTimeout) {
+      clearTimeout(closeTimeout);
+      closeTimeout = null;
+    }
+    closeOpenTooltips();
+    ensureTooltipEntry();
+    globalWarmedUp = true;
+    overlayState.open();
+
+    if (globalWarmUpTimeout) {
+      clearTimeout(globalWarmUpTimeout);
+      globalWarmUpTimeout = null;
+    }
+    if (globalCooldownTimeout) {
+      clearTimeout(globalCooldownTimeout);
+      globalCooldownTimeout = null;
+    }
+  };
+
+  const hideTooltip = (immediate?: boolean) => {
+    if (immediate || closeDelay() <= 0) {
+      if (closeTimeout) {
+        clearTimeout(closeTimeout);
+        closeTimeout = null;
+      }
+      closeCallback()();
+    } else if (!closeTimeout) {
+      closeTimeout = setTimeout(() => {
+        closeTimeout = null;
+        closeCallback()();
+      }, closeDelay());
+    }
+
+    if (globalWarmUpTimeout) {
+      clearTimeout(globalWarmUpTimeout);
+      globalWarmUpTimeout = null;
+    }
+
+    if (globalWarmedUp) {
+      if (globalCooldownTimeout) {
+        clearTimeout(globalCooldownTimeout);
+      }
+      globalCooldownTimeout = setTimeout(() => {
+        delete tooltips[id];
+        globalCooldownTimeout = null;
+        globalWarmedUp = false;
+      }, Math.max(TOOLTIP_COOLDOWN, closeDelay()));
+    }
+  };
+
+  const warmupTooltip = () => {
+    closeOpenTooltips();
+    ensureTooltipEntry();
+
+    if (!overlayState.isOpen() && !globalWarmUpTimeout && !globalWarmedUp) {
+      globalWarmUpTimeout = setTimeout(() => {
+        globalWarmUpTimeout = null;
+        globalWarmedUp = true;
+        showTooltip();
+      }, delay());
+    } else if (!overlayState.isOpen()) {
+      showTooltip();
+    }
+  };
+
+  // Update close callback when overlayState.close changes
+  setCloseCallback(() => overlayState.close);
+
+  // Cleanup on unmount
+  onCleanup(() => {
+    if (closeTimeout) {
+      clearTimeout(closeTimeout);
+    }
+    if (tooltips[id]) {
+      delete tooltips[id];
+    }
+  });
+
+  return {
+    isOpen: overlayState.isOpen,
+    open: (immediate?: boolean) => {
+      if (isServer) return;
+      if (!immediate && delay() > 0 && !closeTimeout) {
+        warmupTooltip();
+      } else {
+        showTooltip();
+      }
+    },
+    close: hideTooltip,
+  };
+}

package/src/tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { createTooltipTriggerState, resetTooltipState, type TooltipTriggerProps, type TooltipTriggerState, } from './createTooltipTriggerState';
+//# sourceMappingURL=index.d.ts.map

package/src/tooltip/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,6BAA6B,CAAC"}

package/src/tooltip/index.ts

@@ -0,0 +1,6 @@
+export {
+  createTooltipTriggerState,
+  resetTooltipState,
+  type TooltipTriggerProps,
+  type TooltipTriggerState,
+} from './createTooltipTriggerState';

package/src/tree/TreeCollection.d.ts

@@ -0,0 +1,40 @@
+/**
+ * TreeCollection implementation.
+ * Based on @react-stately/tree/TreeCollection.
+ *
+ * A flattened view of tree nodes that respects expanded state.
+ * Only visible nodes (root + expanded children) are included in iteration.
+ */
+import type { Key } from '../collections/types';
+import type { TreeCollection as ITreeCollection, TreeNode, TreeItemData } from './types';
+/**
+ * Creates a TreeCollection from hierarchical data.
+ * The collection is flattened based on expanded keys.
+ */
+export declare class TreeCollection<T> implements ITreeCollection<T> {
+    private keyMap;
+    private visibleKeys;
+    private _rows;
+    constructor(items: TreeItemData<T>[], expandedKeys: Set<Key>);
+    private buildCollection;
+    get size(): number;
+    get rows(): TreeNode<T>[];
+    get rowCount(): number;
+    getKeys(): Iterable<Key>;
+    getItem(key: Key): TreeNode<T> | null;
+    at(index: number): TreeNode<T> | null;
+    getKeyBefore(key: Key): Key | null;
+    getKeyAfter(key: Key): Key | null;
+    getFirstKey(): Key | null;
+    getLastKey(): Key | null;
+    getChildren(key: Key): Iterable<TreeNode<T>>;
+    getTextValue(key: Key): string;
+    getParentKey(key: Key): Key | null;
+    [Symbol.iterator](): Iterator<TreeNode<T>>;
+}
+/**
+ * Factory function to create a TreeCollection.
+ * Useful for the collectionFactory pattern in TreeStateOptions.
+ */
+export declare function createTreeCollection<T>(items: TreeItemData<T>[], expandedKeys: Set<Key>): TreeCollection<T>;
+//# sourceMappingURL=TreeCollection.d.ts.map

package/src/tree/TreeCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeCollection.d.ts","sourceRoot":"","sources":["TreeCollection.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,IAAI,eAAe,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEzF;;;GAGG;AACH,qBAAa,cAAc,CAAC,CAAC,CAAE,YAAW,eAAe,CAAC,CAAC,CAAC;IAC1D,OAAO,CAAC,MAAM,CAAoC;IAClD,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,KAAK,CAAqB;gBAGhC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,EACxB,YAAY,EAAE,GAAG,CAAC,GAAG,CAAC;IAKxB,OAAO,CAAC,eAAe;IAqEvB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAExB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAID,OAAO,IAAI,QAAQ,CAAC,GAAG,CAAC;IAIxB,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI;IAIrC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI;IAOrC,YAAY,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI;IAMlC,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI;IAMjC,WAAW,IAAI,GAAG,GAAG,IAAI;IAIzB,UAAU,IAAI,GAAG,GAAG,IAAI;IAIxB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAK5C,YAAY,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM;IAK9B,YAAY,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI;IAKlC,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;CAG3C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,EACxB,YAAY,EAAE,GAAG,CAAC,GAAG,CAAC,GACrB,cAAc,CAAC,CAAC,CAAC,CAEnB"}