@zengrid/core 1.0.1 → 1.0.4

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

@@ -0,0 +1,134 @@
+/**
+ * Segment Tree implementation
+ * Efficient range query and update data structure
+ */
+import type { ISegmentTree, SegmentTreeOptions, AggregateFunction } from './segment-tree.interface';
+import { AggregationType } from './segment-tree.interface';
+/**
+ * Segment Tree - Efficient range queries and updates
+ *
+ * Implementation:
+ * - Array-based complete binary tree
+ * - Each node stores the aggregate of its range
+ * - Supports lazy propagation for efficient range updates
+ * - Generic type T for flexibility (numbers, objects, etc.)
+ *
+ * @example
+ * ```typescript
+ * // Sum queries
+ * const tree = new SegmentTree({ values: [1, 3, 5, 7, 9, 11], type: 'sum' });
+ * tree.query(1, 3); // Returns 15 (3 + 5 + 7)
+ * tree.update(1, 10); // Change 3 to 10
+ * tree.query(1, 3); // Returns 22 (10 + 5 + 7)
+ *
+ * // Min queries
+ * const minTree = new SegmentTree({ values: [5, 2, 8, 1, 9], type: 'min' });
+ * minTree.query(0, 4); // Returns 1
+ * minTree.update(3, 10);
+ * minTree.query(0, 4); // Returns 2
+ *
+ * // Status bar aggregation example
+ * const cellValues = [100, 200, 150, 300, 250];
+ * const sumTree = new SegmentTree({ values: cellValues, type: 'sum' });
+ * sumTree.query(1, 3); // Sum of cells 1-3: 650
+ * ```
+ */
+export declare class SegmentTree<T> implements ISegmentTree<T> {
+    private tree;
+    private lazy;
+    private arr;
+    private n;
+    private aggregate;
+    private identityValue;
+    private useLazy;
+    private _type;
+    constructor(options: SegmentTreeOptions<T>);
+    /**
+     * Get aggregation configuration
+     */
+    private getAggregationConfig;
+    /**
+     * Build the segment tree recursively
+     */
+    private buildTree;
+    /**
+     * Push lazy updates down to children
+     */
+    private pushDown;
+    /**
+     * Apply update to a node value
+     * For SUM: multiply update by range size
+     * For MIN/MAX: just use the update value
+     */
+    private applyUpdate;
+    /**
+     * Query range [left, right]
+     */
+    query(left: number, right: number): T;
+    /**
+     * Recursive query helper
+     */
+    private queryTree;
+    /**
+     * Update a single element
+     */
+    update(index: number, value: T): void;
+    /**
+     * Recursive update helper
+     */
+    private updateTree;
+    /**
+     * Update a range [left, right]
+     */
+    rangeUpdate(left: number, right: number, value: T): void;
+    /**
+     * Lazy range update helper
+     */
+    private rangeUpdateLazy;
+    /**
+     * Get value at index
+     */
+    get(index: number): T;
+    /**
+     * Build tree from new array
+     */
+    build(arr: T[]): void;
+    /**
+     * Convert tree to array
+     */
+    toArray(): T[];
+    /**
+     * Find first index where predicate is true
+     */
+    findFirst(left: number, predicate: (value: T) => boolean): number;
+    /**
+     * Get size of array
+     */
+    get size(): number;
+    /**
+     * Get total aggregated value
+     */
+    get total(): T;
+    /**
+     * Get aggregation type
+     */
+    get aggregationType(): AggregationType;
+    /**
+     * Create SegmentTree from array
+     */
+    static from<T>(values: T[], type?: AggregationType): SegmentTree<T>;
+    /**
+     * Create custom SegmentTree
+     */
+    static custom<T>(values: T[], aggregate: AggregateFunction<T>, identity: T): SegmentTree<T>;
+    /**
+     * Debug: Print tree structure
+     */
+    toString(): string;
+    /**
+     * Debug: Validate tree structure
+     */
+    validate(): boolean;
+    private validateNode;
+}
+//# sourceMappingURL=segment-tree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segment-tree.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/segment-tree/segment-tree.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAkC,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,WAAW,CAAC,CAAC,CAAE,YAAW,YAAY,CAAC,CAAC,CAAC;IACpD,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,CAAC,CAAS;IAClB,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,KAAK,CAAkB;gBAEnB,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC;IAgC1C;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAsB5B;;OAEG;IACH,OAAO,CAAC,SAAS;IAiBjB;;OAEG;IACH,OAAO,CAAC,QAAQ;IA8BhB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAYnB;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC;IAcrC;;OAEG;IACH,OAAO,CAAC,SAAS;IAiCjB;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IASrC;;OAEG;IACH,OAAO,CAAC,UAAU;IA+BlB;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAkBxD;;OAEG;IACH,OAAO,CAAC,eAAe;IAqCvB;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC;IAQrB;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,IAAI;IAarB;;OAEG;IACH,OAAO,IAAI,CAAC,EAAE;IAQd;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM;IAUjE;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,CAAC,CAKb;IAED;;OAEG;IACH,IAAI,eAAe,IAAI,eAAe,CAErC;IAED;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,IAAI,GAAE,eAAqC,GAAG,WAAW,CAAC,CAAC,CAAC;IAIxF;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,EACb,MAAM,EAAE,CAAC,EAAE,EACX,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,GACV,WAAW,CAAC,CAAC,CAAC;IASjB;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,QAAQ,IAAI,OAAO;IAInB,OAAO,CAAC,YAAY;CA2BrB"}

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

@@ -0,0 +1,202 @@
+/**
+ * Segment Tree interfaces for ZenGrid
+ * Efficiently handles range queries and updates for aggregation operations
+ */
+/**
+ * Aggregation function type
+ * Combines two values into one
+ */
+export type AggregateFunction<T> = (a: T, b: T) => T;
+/**
+ * Common aggregation operations
+ */
+export declare enum AggregationType {
+    SUM = "sum",
+    MIN = "min",
+    MAX = "max",
+    GCD = "gcd",
+    LCM = "lcm",
+    PRODUCT = "product",
+    CUSTOM = "custom"
+}
+/**
+ * Segment Tree interface
+ *
+ * A tree data structure for storing intervals or segments, allowing for efficient
+ * querying and updating of array elements over ranges.
+ *
+ * Use cases:
+ * - Status bar aggregations (sum, min, max of selected cells)
+ * - Range statistics (average, count, sum over a range)
+ * - Dynamic cumulative calculations
+ * - Range minimum/maximum queries
+ * - Frequent range updates with queries
+ *
+ * Performance:
+ * - Build: O(n)
+ * - Query: O(log n)
+ * - Update (point): O(log n)
+ * - Update (range): O(log n) with lazy propagation
+ * - Space: O(4n) = O(n)
+ */
+export interface ISegmentTree<T> {
+    /**
+     * Query the aggregated value over a range [left, right]
+     * @param left - Start index (inclusive)
+     * @param right - End index (inclusive)
+     * @returns Aggregated value over the range
+     * @complexity O(log n)
+     */
+    query(left: number, right: number): T;
+    /**
+     * Update a single element at index
+     * @param index - Index to update
+     * @param value - New value
+     * @complexity O(log n)
+     */
+    update(index: number, value: T): void;
+    /**
+     * Update a range of elements [left, right]
+     * @param left - Start index (inclusive)
+     * @param right - End index (inclusive)
+     * @param value - Value to apply to the range
+     * @complexity O(log n) with lazy propagation
+     */
+    rangeUpdate(left: number, right: number, value: T): void;
+    /**
+     * Get the value at a specific index
+     * @param index - Index to query
+     * @returns Value at index
+     * @complexity O(log n) or O(1) depending on implementation
+     */
+    get(index: number): T;
+    /**
+     * Build or rebuild the tree from new array
+     * @param arr - New array of values
+     * @complexity O(n)
+     */
+    build(arr: T[]): void;
+    /**
+     * Get the entire array
+     * @returns Current array values
+     * @complexity O(n)
+     */
+    toArray(): T[];
+    /**
+     * Find the first index where the aggregate from start meets a condition
+     * Useful for binary search on aggregates
+     * @param left - Start index
+     * @param predicate - Condition to test
+     * @returns Index or -1 if not found
+     * @complexity O(log^2 n)
+     */
+    findFirst(left: number, predicate: (value: T) => boolean): number;
+    /**
+     * Get the size of the underlying array
+     */
+    readonly size: number;
+    /**
+     * Get the total aggregated value (entire array)
+     */
+    readonly total: T;
+    /**
+     * Get the aggregation type
+     */
+    readonly aggregationType: AggregationType;
+}
+/**
+ * Options for creating a Segment Tree
+ */
+export interface SegmentTreeOptions<T> {
+    /**
+     * Initial array of values
+     */
+    values?: T[];
+    /**
+     * Aggregation type (for common operations)
+     * If CUSTOM is specified, must provide customAggregate function
+     */
+    type?: AggregationType;
+    /**
+     * Custom aggregation function
+     * Required if type is CUSTOM
+     */
+    customAggregate?: AggregateFunction<T>;
+    /**
+     * Identity value for the aggregation
+     * - For SUM: 0
+     * - For MIN: Infinity
+     * - For MAX: -Infinity
+     * - For PRODUCT: 1
+     * Must be provided for CUSTOM type
+     */
+    identity?: T;
+    /**
+     * Whether to use lazy propagation for range updates
+     * @default true
+     */
+    lazy?: boolean;
+}
+/**
+ * Predefined aggregation functions and identities
+ */
+export declare const Aggregations: {
+    sum: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    min: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    max: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    gcd: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    lcm: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    product: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+};
+/**
+ * Helper functions for segment tree operations
+ */
+export declare const SegmentTreeUtils: {
+    /**
+     * Calculate the tree size needed for array of size n
+     */
+    getTreeSize(n: number): number;
+    /**
+     * Check if index is valid
+     */
+    isValidIndex(index: number, size: number): boolean;
+    /**
+     * Check if range is valid
+     */
+    isValidRange(left: number, right: number, size: number): boolean;
+    /**
+     * Get parent index in tree
+     */
+    parent(index: number): number;
+    /**
+     * Get left child index in tree
+     */
+    leftChild(index: number): number;
+    /**
+     * Get right child index in tree
+     */
+    rightChild(index: number): number;
+    /**
+     * Get the middle point of a range
+     */
+    mid(left: number, right: number): number;
+};
+//# sourceMappingURL=segment-tree.interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segment-tree.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/segment-tree/segment-tree.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AAErD;;GAEG;AACH,oBAAY,eAAe;IACzB,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,OAAO,YAAY;IACnB,MAAM,WAAW;CAClB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;IAEtC;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAEtC;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAEzD;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;IAEtB;;;;OAIG;IACH,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC;IAEtB;;;;OAIG;IACH,OAAO,IAAI,CAAC,EAAE,CAAC;IAEf;;;;;;;OAOG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,CAAC;IAElE;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;IAEb;;;OAGG;IACH,IAAI,CAAC,EAAE,eAAe,CAAC;IAEvB;;;OAGG;IACH,eAAe,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAEvC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEb;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;gBAEb,MAAM,KAAK,MAAM;;;;gBAIjB,MAAM,KAAK,MAAM;;;;gBAIjB,MAAM,KAAK,MAAM;;;;gBAIjB,MAAM,KAAK,MAAM;;;;gBAWjB,MAAM,KAAK,MAAM;;;;gBAOjB,MAAM,KAAK,MAAM;;;CAG5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;mBACY,MAAM,GAAG,MAAM;IAK9B;;OAEG;wBACiB,MAAM,QAAQ,MAAM,GAAG,OAAO;IAIlD;;OAEG;uBACgB,MAAM,SAAS,MAAM,QAAQ,MAAM,GAAG,OAAO;IAQhE;;OAEG;kBACW,MAAM,GAAG,MAAM;IAI7B;;OAEG;qBACc,MAAM,GAAG,MAAM;IAIhC;;OAEG;sBACe,MAAM,GAAG,MAAM;IAIjC;;OAEG;cACO,MAAM,SAAS,MAAM,GAAG,MAAM;CAGzC,CAAC"}

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

@@ -0,0 +1,4 @@
+export { SkipList } from './skip-list';
+export type { ISkipList, SkipListNode, SkipListOptions, RangeResult, SkipListStats, } from './skip-list.interface';
+export { defaultComparator, SkipListUtils } from './skip-list.interface';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/skip-list/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EACV,SAAS,EACT,YAAY,EACZ,eAAe,EACf,WAAW,EACX,aAAa,GACd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/src/shared/data-structures/skip-list/skip-list.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Skip List implementation
+ * Probabilistic sorted data structure
+ */
+import type { ISkipList, SkipListOptions, RangeResult, SkipListStats } from './skip-list.interface';
+/**
+ * Skip List - Probabilistic sorted data structure
+ *
+ * Implementation:
+ * - Multiple levels of linked lists
+ * - Each level is a subset of the level below
+ * - Levels are determined probabilistically
+ * - Search starts at highest level and descends
+ *
+ * @example
+ * ```typescript
+ * const skipList = new SkipList<number, string>();
+ * skipList.set(10, 'ten');
+ * skipList.set(5, 'five');
+ * skipList.set(20, 'twenty');
+ *
+ * skipList.get(10); // 'ten'
+ * skipList.range(5, 15); // [{key: 5, value: 'five'}, {key: 10, value: 'ten'}]
+ * skipList.keys(); // [5, 10, 20]
+ * ```
+ */
+export declare class SkipList<K, V> implements ISkipList<K, V> {
+    private head;
+    private maxLevel;
+    private probability;
+    private compare;
+    private currentLevel;
+    private count;
+    constructor(options?: SkipListOptions<K>);
+    /**
+     * Create a new node with random level
+     */
+    private createNode;
+    /**
+     * Generate random level for new node
+     */
+    private randomLevel;
+    /**
+     * Find the position where key should be or is located
+     * Returns update array with predecessors at each level
+     */
+    private findUpdatePath;
+    /**
+     * Insert or update a key-value pair
+     */
+    set(key: K, value: V): V | undefined;
+    /**
+     * Get value by key
+     */
+    get(key: K): V | undefined;
+    /**
+     * Check if key exists
+     */
+    has(key: K): boolean;
+    /**
+     * Delete a key
+     */
+    delete(key: K): boolean;
+    /**
+     * Get all entries in sorted order
+     */
+    entries(): Array<[K, V]>;
+    /**
+     * Get all keys in sorted order
+     */
+    keys(): K[];
+    /**
+     * Get all values in sorted order by key
+     */
+    values(): V[];
+    /**
+     * Get range of entries
+     */
+    range(startKey: K, endKey: K): RangeResult<K, V>[];
+    /**
+     * Get minimum entry
+     */
+    min(): RangeResult<K, V> | undefined;
+    /**
+     * Get maximum entry
+     */
+    max(): RangeResult<K, V> | undefined;
+    /**
+     * Get kth smallest entry (0-indexed)
+     */
+    getKth(k: number): RangeResult<K, V> | undefined;
+    /**
+     * Count entries in range
+     */
+    countRange(startKey: K, endKey: K): number;
+    /**
+     * Find floor (largest key <= given key)
+     */
+    floor(key: K): RangeResult<K, V> | undefined;
+    /**
+     * Find ceiling (smallest key >= given key)
+     */
+    ceiling(key: K): RangeResult<K, V> | undefined;
+    /**
+     * Iterate over all entries
+     */
+    forEach(callback: (value: V, key: K) => void): void;
+    /**
+     * Clear all entries
+     */
+    clear(): void;
+    /**
+     * Get statistics
+     */
+    getStats(): SkipListStats;
+    /**
+     * Get size
+     */
+    get size(): number;
+    /**
+     * Check if empty
+     */
+    get isEmpty(): boolean;
+    /**
+     * Create skip list from entries
+     */
+    static from<K, V>(entries: Array<[K, V]>, options?: SkipListOptions<K>): SkipList<K, V>;
+    /**
+     * Debug: Print structure
+     */
+    toString(): string;
+    /**
+     * Debug: Validate structure
+     */
+    validate(): boolean;
+}
+//# sourceMappingURL=skip-list.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skip-list.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/skip-list/skip-list.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,SAAS,EAET,eAAe,EACf,WAAW,EACX,aAAa,EACd,MAAM,uBAAuB,CAAC;AAI/B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,YAAW,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;IACpD,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,KAAK,CAAS;gBAEV,OAAO,GAAE,eAAe,CAAC,CAAC,CAAM;IAW5C;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAkBtB;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAmCpC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAuB1B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IA6BvB;;OAEG;IACH,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAYxB;;OAEG;IACH,IAAI,IAAI,CAAC,EAAE;IAYX;;OAEG;IACH,MAAM,IAAI,CAAC,EAAE;IAYb;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;IA0BlD;;OAEG;IACH,GAAG,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS;IAQpC;;OAEG;IACH,GAAG,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS;IAsBpC;;OAEG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS;IAoBhD;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM;IAI1C;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS;IAqB5C;;OAEG;IACH,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS;IAqB9C;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI;IASnD;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,QAAQ,IAAI,aAAa;IA0BzB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EACd,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EACtB,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,GAC3B,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;IAQjB;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,QAAQ,IAAI,OAAO;CAyBpB"}