@zengrid/core 1.0.1 → 1.0.4

package/dist/src/shared/data-structures/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Data Structures for ZenGrid
+ */
+export { SparseMatrix } from './sparse-matrix';
+export type { ReadonlySparseMatrix, ISparseMatrix, SparseMatrixOptions, } from './sparse-matrix';
+export { PrefixSumArray } from './prefix-sum-array';
+export type { IPrefixSumArray, PrefixSumArrayOptions, } from './prefix-sum-array';
+export { ColumnStore } from './column-store';
+export type { IColumnStore, ColumnStoreOptions, ColumnDefinition, ColumnType, AggregateOperation, AggregationResult, } from './column-store';
+export { IndexMap } from './index-map';
+export type { IIndexMap, IndexMapEntry, IndexMapOptions, } from './index-map';
+export { IntervalTree } from './interval-tree';
+export type { IIntervalTree, Interval, IntervalData, IntervalTreeOptions, } from './interval-tree';
+export { IntervalUtils } from './interval-tree';
+export { Trie } from './trie';
+export type { ITrie, ITrieNode, TrieOptions, TrieSearchResult, } from './trie';
+export { RTree } from './rtree';
+export type { IRTree, Rectangle, RTreeData, RTreeOptions, RTreeSearchResult, RTreeStats, } from './rtree';
+export { DependencyGraph } from './dependency-graph';
+export type { IDependencyGraph, NodeId, Dependency, DependencyGraphOptions, TopologicalSortResult, GraphStats, } from './dependency-graph';
+export { SuffixArray } from './suffix-array';
+export type { ISuffixArray, SuffixArrayOptions, SuffixSearchResult, SuffixArrayStats, } from './suffix-array';
+export { LRUCache } from './lru-cache';
+export type { ILRUCache, LRUCacheOptions, CacheEntry, CacheStats, } from './lru-cache';
+export { CommandStack } from './command-stack';
+export type { ICommandStack, ICommand, ICommandStackOptions, } from './command-stack';
+export { SegmentTree } from './segment-tree';
+export type { ISegmentTree, SegmentTreeOptions, AggregateFunction, AggregationType, } from './segment-tree';
+export { Aggregations, SegmentTreeUtils } from './segment-tree';
+export { SkipList } from './skip-list';
+export type { ISkipList, SkipListNode, SkipListOptions, RangeResult, SkipListStats, } from './skip-list';
+export { defaultComparator, SkipListUtils } from './skip-list';
+export { DisjointSet } from './disjoint-set';
+export type { IDisjointSet, DisjointSetOptions, DisjointSetStats, } from './disjoint-set';
+export { DisjointSetUtils } from './disjoint-set';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/data-structures/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/shared/data-structures/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EACV,oBAAoB,EACpB,aAAa,EACb,mBAAmB,GACpB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,YAAY,EACV,eAAe,EACf,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EACV,SAAS,EACT,aAAa,EACb,eAAe,GAChB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EACV,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,mBAAmB,GACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,YAAY,EACV,KAAK,EACL,SAAS,EACT,WAAW,EACX,gBAAgB,GACjB,MAAM,QAAQ,CAAC;AAGhB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EACV,MAAM,EACN,SAAS,EACT,SAAS,EACT,YAAY,EACZ,iBAAiB,EACjB,UAAU,GACX,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,YAAY,EACV,gBAAgB,EAChB,MAAM,EACN,UAAU,EACV,sBAAsB,EACtB,qBAAqB,EACrB,UAAU,GACX,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EACV,SAAS,EACT,eAAe,EACf,UAAU,EACV,UAAU,GACX,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EACV,aAAa,EACb,QAAQ,EACR,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,GAChB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGhE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EACV,SAAS,EACT,YAAY,EACZ,eAAe,EACf,WAAW,EACX,aAAa,GACd,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG/D,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/src/shared/data-structures/interval-tree/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Interval Tree - Augmented BST for interval queries
+ */
+export { IntervalTree } from './interval-tree';
+export type { IIntervalTree, Interval, IntervalData, IntervalTreeOptions, } from './interval-tree.interface';
+export { IntervalUtils } from './interval-tree.interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/data-structures/interval-tree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/interval-tree/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EACV,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,mBAAmB,GACpB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/src/shared/data-structures/interval-tree/interval-tree.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Interval Tree implementation
+ * Augmented BST for efficient interval queries
+ */
+import type { IIntervalTree, Interval, IntervalData, IntervalTreeOptions } from './interval-tree.interface';
+/**
+ * Interval Tree - Augmented BST for interval queries
+ *
+ * Implementation:
+ * - Each node stores an interval and the max endpoint in its subtree
+ * - Balanced using AVL tree rotations for guaranteed O(log n) operations
+ * - Intervals are ordered by start time
+ *
+ * @example
+ * ```typescript
+ * const tree = new IntervalTree<string>();
+ * tree.insert({ start: 10, end: 20 }, 'A');
+ * tree.insert({ start: 15, end: 25 }, 'B');
+ * tree.insert({ start: 30, end: 40 }, 'C');
+ *
+ * tree.search({ start: 18, end: 22 }); // Returns A and B
+ * tree.searchPoint(35); // Returns C
+ * ```
+ */
+export declare class IntervalTree<T> implements IIntervalTree<T> {
+    private root;
+    private count;
+    private nextId;
+    private readonly balanced;
+    private readonly allowDuplicates;
+    private readonly comparator;
+    constructor(options?: IntervalTreeOptions);
+    /**
+     * Insert an interval
+     */
+    insert(interval: Interval, data: T): IntervalData<T>;
+    private insertNode;
+    /**
+     * Delete an interval
+     */
+    delete(intervalData: IntervalData<T>): boolean;
+    private deleteNode;
+    /**
+     * Delete by ID
+     */
+    deleteById(id: string | number): boolean;
+    private findById;
+    /**
+     * Find all overlapping intervals
+     */
+    search(interval: Interval): IntervalData<T>[];
+    private searchOverlap;
+    /**
+     * Find all intervals containing a point
+     */
+    searchPoint(point: number): IntervalData<T>[];
+    /**
+     * Find all intervals contained within the given interval
+     */
+    searchContained(interval: Interval): IntervalData<T>[];
+    private searchContainedHelper;
+    /**
+     * Find all intervals containing the given interval
+     */
+    searchContaining(interval: Interval): IntervalData<T>[];
+    private searchContainingHelper;
+    /**
+     * Find minimum interval (by start time)
+     */
+    findMin(): IntervalData<T> | undefined;
+    private findMinNode;
+    /**
+     * Find maximum interval (by max endpoint in tree)
+     */
+    findMax(): IntervalData<T> | undefined;
+    private findMaxHelper;
+    /**
+     * Check if any interval overlaps
+     */
+    hasOverlap(interval: Interval): boolean;
+    private hasOverlapHelper;
+    /**
+     * Get all intervals in sorted order
+     */
+    inorder(): IntervalData<T>[];
+    private inorderHelper;
+    /**
+     * Iterate over all intervals
+     */
+    forEach(callback: (interval: IntervalData<T>) => void): void;
+    private forEachHelper;
+    /**
+     * Filter intervals
+     */
+    filter(predicate: (interval: IntervalData<T>) => boolean): IIntervalTree<T>;
+    /**
+     * Map intervals
+     */
+    map<U>(mapper: (data: T, interval: Interval) => U): IIntervalTree<U>;
+    /**
+     * Clear the tree
+     */
+    clear(): void;
+    /**
+     * Get tree size
+     */
+    get size(): number;
+    /**
+     * Check if empty
+     */
+    get isEmpty(): boolean;
+    /**
+     * Get tree height
+     */
+    get height(): number;
+    private getHeight;
+    /**
+     * AVL balancing methods
+     */
+    private balance;
+    private getBalanceFactor;
+    private rotateLeft;
+    private rotateRight;
+    /**
+     * Create IntervalTree from array of intervals
+     */
+    static from<T>(intervals: Array<{
+        interval: Interval;
+        data: T;
+    }>, options?: IntervalTreeOptions): IntervalTree<T>;
+    /**
+     * Debug: Get tree structure as string
+     */
+    toString(): string;
+    /**
+     * Debug: Validate tree structure
+     */
+    validate(): boolean;
+    private validateNode;
+}
+//# sourceMappingURL=interval-tree.d.ts.map

package/dist/src/shared/data-structures/interval-tree/interval-tree.d.ts.map

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

package/dist/src/shared/data-structures/interval-tree/interval-tree.interface.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Interval Tree interfaces for ZenGrid
+ * Efficiently finds all intervals that overlap with a given interval or point
+ */
+/**
+ * Represents an interval with a start and end
+ */
+export interface Interval {
+    /** Start of the interval (inclusive) */
+    start: number;
+    /** End of the interval (inclusive) */
+    end: number;
+}
+/**
+ * An interval with associated data
+ */
+export interface IntervalData<T> extends Interval {
+    /** User data associated with this interval */
+    data: T;
+    /** Optional unique identifier */
+    id?: string | number;
+}
+/**
+ * Interval Tree interface
+ *
+ * An augmented binary search tree for efficient interval queries.
+ * Each node stores an interval and the maximum endpoint in its subtree.
+ *
+ * Use cases:
+ * - Finding all overlapping time ranges
+ * - Range queries in calendars/schedules
+ * - Collision detection (e.g., overlapping cells in a grid)
+ * - Finding visible rows/columns in virtual scrolling
+ * - Query optimization (index range scans)
+ *
+ * Performance:
+ * - Insert: O(log n) average, O(n) worst case (use Red-Black tree for guaranteed O(log n))
+ * - Delete: O(log n) average
+ * - Search overlapping: O(log n + k) where k = number of results
+ * - Point query: O(log n + k)
+ * - Space: O(n)
+ */
+export interface IIntervalTree<T> {
+    /**
+     * Insert an interval with associated data
+     * @param interval - The interval to insert
+     * @param data - Data to associate with the interval
+     * @returns The inserted interval with data
+     * @complexity O(log n) average
+     */
+    insert(interval: Interval, data: T): IntervalData<T>;
+    /**
+     * Delete an interval by reference
+     * @param intervalData - The interval to delete
+     * @returns true if found and deleted
+     * @complexity O(log n)
+     */
+    delete(intervalData: IntervalData<T>): boolean;
+    /**
+     * Delete an interval by ID
+     * @param id - The ID of the interval to delete
+     * @returns true if found and deleted
+     * @complexity O(n) - requires linear search
+     */
+    deleteById(id: string | number): boolean;
+    /**
+     * Find all intervals that overlap with the given interval
+     * @param interval - The query interval
+     * @returns Array of overlapping intervals
+     * @complexity O(log n + k) where k = number of results
+     */
+    search(interval: Interval): IntervalData<T>[];
+    /**
+     * Find all intervals that contain the given point
+     * @param point - The point to query
+     * @returns Array of intervals containing the point
+     * @complexity O(log n + k) where k = number of results
+     */
+    searchPoint(point: number): IntervalData<T>[];
+    /**
+     * Find all intervals that are completely contained within the given interval
+     * @param interval - The containing interval
+     * @returns Array of contained intervals
+     * @complexity O(n) worst case
+     */
+    searchContained(interval: Interval): IntervalData<T>[];
+    /**
+     * Find all intervals that completely contain the given interval
+     * @param interval - The interval to be contained
+     * @returns Array of containing intervals
+     * @complexity O(n) worst case
+     */
+    searchContaining(interval: Interval): IntervalData<T>[];
+    /**
+     * Find the interval with the earliest start time
+     * @returns The interval or undefined if tree is empty
+     * @complexity O(log n)
+     */
+    findMin(): IntervalData<T> | undefined;
+    /**
+     * Find the interval with the latest end time
+     * @returns The interval or undefined if tree is empty
+     * @complexity O(log n)
+     */
+    findMax(): IntervalData<T> | undefined;
+    /**
+     * Check if any interval overlaps with the given interval
+     * @param interval - The query interval
+     * @complexity O(log n)
+     */
+    hasOverlap(interval: Interval): boolean;
+    /**
+     * Get all intervals in sorted order (by start time)
+     * @returns Array of all intervals sorted by start
+     * @complexity O(n)
+     */
+    inorder(): IntervalData<T>[];
+    /**
+     * Iterate over all intervals in sorted order
+     * @param callback - Function to call for each interval
+     * @complexity O(n)
+     */
+    forEach(callback: (interval: IntervalData<T>) => void): void;
+    /**
+     * Filter intervals by a predicate
+     * @param predicate - Test function
+     * @returns New interval tree with intervals that pass the test
+     * @complexity O(n)
+     */
+    filter(predicate: (interval: IntervalData<T>) => boolean): IIntervalTree<T>;
+    /**
+     * Map intervals to a new interval tree
+     * @param mapper - Transform function for the data
+     * @returns New interval tree with transformed data
+     * @complexity O(n)
+     */
+    map<U>(mapper: (data: T, interval: Interval) => U): IIntervalTree<U>;
+    /**
+     * Clear all intervals
+     * @complexity O(1)
+     */
+    clear(): void;
+    /**
+     * Number of intervals in the tree
+     */
+    readonly size: number;
+    /**
+     * Whether the tree is empty
+     */
+    readonly isEmpty: boolean;
+    /**
+     * Height of the tree (for debugging/analysis)
+     */
+    readonly height: number;
+}
+/**
+ * Options for creating an IntervalTree
+ */
+export interface IntervalTreeOptions {
+    /**
+     * Whether to use a balanced tree (Red-Black tree)
+     * Guarantees O(log n) operations but slightly slower constants
+     * @default false (uses simple BST)
+     */
+    balanced?: boolean;
+    /**
+     * Whether to allow duplicate intervals
+     * @default true
+     */
+    allowDuplicates?: boolean;
+    /**
+     * Custom comparator for intervals
+     * Defaults to comparing by start time, then end time
+     */
+    comparator?: (a: Interval, b: Interval) => number;
+}
+/**
+ * Helper functions for interval operations
+ */
+export declare const IntervalUtils: {
+    /**
+     * Check if two intervals overlap
+     */
+    overlaps(a: Interval, b: Interval): boolean;
+    /**
+     * Check if interval contains a point
+     */
+    contains(interval: Interval, point: number): boolean;
+    /**
+     * Check if interval A contains interval B
+     */
+    containsInterval(a: Interval, b: Interval): boolean;
+    /**
+     * Get the intersection of two intervals
+     * Returns undefined if they don't overlap
+     */
+    intersection(a: Interval, b: Interval): Interval | undefined;
+    /**
+     * Get the union of two overlapping intervals
+     * Returns undefined if they don't overlap
+     */
+    union(a: Interval, b: Interval): Interval | undefined;
+    /**
+     * Merge overlapping intervals
+     */
+    mergeOverlapping(intervals: Interval[]): Interval[];
+    /**
+     * Default comparator: compare by start, then by end
+     */
+    defaultComparator(a: Interval, b: Interval): number;
+};
+//# sourceMappingURL=interval-tree.interface.d.ts.map

package/dist/src/shared/data-structures/interval-tree/interval-tree.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval-tree.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/interval-tree/interval-tree.interface.ts"],"names":[],"mappings":"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"}

package/dist/src/shared/data-structures/lru-cache/index.d.ts

@@ -0,0 +1,3 @@
+export { LRUCache } from './lru-cache';
+export type { ILRUCache, LRUCacheOptions, CacheEntry, CacheStats, } from './lru-cache.interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/data-structures/lru-cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/lru-cache/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EACV,SAAS,EACT,eAAe,EACf,UAAU,EACV,UAAU,GACX,MAAM,uBAAuB,CAAC"}

package/dist/src/shared/data-structures/lru-cache/lru-cache.d.ts

@@ -0,0 +1,134 @@
+import type { ILRUCache, LRUCacheOptions, CacheEntry, CacheStats } from './lru-cache.interface';
+/**
+ * LRU Cache - Least Recently Used Cache
+ *
+ * A cache with automatic eviction of least recently used entries.
+ * Uses doubly-linked list + hash map for O(1) operations.
+ *
+ * **Time Complexity:**
+ * - get: O(1)
+ * - set: O(1)
+ * - delete: O(1)
+ * - has: O(1)
+ * - clear: O(n)
+ *
+ * **Space Complexity:** O(n) where n = number of entries
+ *
+ * **Use Cases in Grid:**
+ * - Cache rendered cells: Avoid re-rendering visible cells
+ * - Cache formula results: =SUM(A1:A1000) computed once
+ * - Cache formatted values: "$1,234.56" cached instead of re-formatting
+ * - Cache API responses: Reduce server requests
+ *
+ * @example Cell Rendering Cache
+ * ```typescript
+ * const cellCache = new LRUCache<string, HTMLElement>({ capacity: 500 });
+ *
+ * function renderCell(row: number, col: number): HTMLElement {
+ *   const key = `${row},${col}`;
+ *   let element = cellCache.get(key);
+ *
+ *   if (!element) {
+ *     element = createCellElement(row, col); // Expensive operation
+ *     cellCache.set(key, element);
+ *   }
+ *
+ *   return element;
+ * }
+ * ```
+ *
+ * @example Formula Cache
+ * ```typescript
+ * const formulaCache = new LRUCache<string, number>({
+ *   capacity: 1000,
+ *   ttl: 5000, // 5 seconds
+ * });
+ *
+ * function evaluateFormula(formula: string): number {
+ *   return formulaCache.get(formula) ?? computeFormula(formula);
+ * }
+ * ```
+ */
+export declare class LRUCache<K, V> implements ILRUCache<K, V> {
+    private capacity;
+    private ttl;
+    private cache;
+    private head;
+    private tail;
+    private onEvict?;
+    private trackStats;
+    private hits;
+    private misses;
+    private evictions;
+    private sets;
+    constructor(options?: LRUCacheOptions);
+    /**
+     * Get a value from the cache
+     */
+    get(key: K): V | undefined;
+    /**
+     * Set a value in the cache
+     */
+    set(key: K, value: V): void;
+    /**
+     * Check if a key exists
+     */
+    has(key: K): boolean;
+    /**
+     * Delete a specific entry
+     */
+    delete(key: K): boolean;
+    /**
+     * Clear all entries
+     */
+    clear(): void;
+    /**
+     * Get current size
+     */
+    size(): number;
+    /**
+     * Get statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Get all keys (oldest to newest)
+     */
+    keys(): K[];
+    /**
+     * Get all values (oldest to newest)
+     */
+    values(): V[];
+    /**
+     * Get all entries with metadata
+     */
+    entries(): Array<[K, CacheEntry<V>]>;
+    /**
+     * Peek without updating LRU order
+     */
+    peek(key: K): V | undefined;
+    /**
+     * Resize cache capacity
+     */
+    resize(newCapacity: number): void;
+    /**
+     * Check if a node is expired
+     */
+    private isExpired;
+    /**
+     * Move node to head (most recently used)
+     */
+    private moveToHead;
+    /**
+     * Add node to head
+     */
+    private addToHead;
+    /**
+     * Remove node from list
+     */
+    private removeNode;
+    /**
+     * Evict least recently used entry
+     */
+    private evictLRU;
+}
+//# sourceMappingURL=lru-cache.d.ts.map

package/dist/src/shared/data-structures/lru-cache/lru-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru-cache.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/lru-cache/lru-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EACf,UAAU,EACV,UAAU,EACX,MAAM,uBAAuB,CAAC;AAiB/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,YAAW,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;IACpD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,IAAI,CAA8B;IAC1C,OAAO,CAAC,IAAI,CAA8B;IAC1C,OAAO,CAAC,OAAO,CAAC,CAA6B;IAC7C,OAAO,CAAC,UAAU,CAAU;IAG5B,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,IAAI,CAAa;gBAEb,OAAO,GAAE,eAAoB;IAYzC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IA0B1B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAyB3B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAYpB;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAUvB;;OAEG;IACH,KAAK,IAAI,IAAI;IAab;;OAEG;IACH,IAAI,IAAI,MAAM;IAId;;OAEG;IACH,QAAQ,IAAI,UAAU;IAsBtB;;OAEG;IACH,IAAI,IAAI,CAAC,EAAE;IAYX;;OAEG;IACH,MAAM,IAAI,CAAC,EAAE;IAYb;;OAEG;IACH,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IAoBpC;;OAEG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAa3B;;OAEG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAejC;;OAEG;IACH,OAAO,CAAC,SAAS;IAKjB;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,OAAO,CAAC,SAAS;IAejB;;OAEG;IACH,OAAO,CAAC,UAAU;IAclB;;OAEG;IACH,OAAO,CAAC,QAAQ;CAcjB"}