@zengrid/shared 1.0.3 → 1.1.0

package/dist/src/data-structures/disjoint-set/disjoint-set.interface.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Disjoint Set (Union-Find) interfaces for ZenGrid
+ * Efficient data structure for managing merged cells and connected components
+ */
+/**
+ * Disjoint Set statistics
+ */
+export interface DisjointSetStats {
+    /** Total number of elements */
+    totalElements: number;
+    /** Number of disjoint sets */
+    numSets: number;
+    /** Size of the largest set */
+    largestSetSize: number;
+    /** Average set size */
+    averageSetSize: number;
+    /** Memory usage estimate in bytes */
+    memoryBytes: number;
+}
+/**
+ * Disjoint Set interface (Union-Find)
+ *
+ * A data structure for tracking a partition of elements into disjoint sets.
+ * Uses path compression and union by rank for near-constant time operations.
+ *
+ * Use cases:
+ * - Managing merged cells in spreadsheets
+ * - Tracking connected components in graphs
+ * - Detecting cycles in undirected graphs
+ * - Kruskal's minimum spanning tree algorithm
+ * - Image segmentation
+ * - Network connectivity
+ *
+ * Performance:
+ * - makeSet: O(1)
+ * - find: O(α(n)) amortized, where α is inverse Ackermann function (effectively O(1))
+ * - union: O(α(n)) amortized
+ * - connected: O(α(n)) amortized
+ * - Space: O(n)
+ *
+ * Optimizations:
+ * - Path compression: Makes find operations extremely fast
+ * - Union by rank: Keeps trees shallow for better performance
+ * - Both optimizations together give near-constant time complexity
+ */
+export interface IDisjointSet<T> {
+    /**
+     * Create a new set containing only the given element
+     * If element already exists, this is a no-op
+     * @param element - The element to create a set for
+     * @complexity O(1)
+     */
+    makeSet(element: T): void;
+    /**
+     * Find the representative (root) of the set containing the element
+     * Uses path compression to optimize future queries
+     * @param element - The element to find
+     * @returns The representative element, or undefined if element doesn't exist
+     * @complexity O(α(n)) amortized
+     */
+    find(element: T): T | undefined;
+    /**
+     * Unite the sets containing two elements
+     * Uses union by rank to keep trees shallow
+     * @param element1 - First element
+     * @param element2 - Second element
+     * @returns true if sets were merged, false if already in same set or element doesn't exist
+     * @complexity O(α(n)) amortized
+     */
+    union(element1: T, element2: T): boolean;
+    /**
+     * Check if two elements are in the same set
+     * @param element1 - First element
+     * @param element2 - Second element
+     * @returns true if both elements exist and are in the same set
+     * @complexity O(α(n)) amortized
+     */
+    connected(element1: T, element2: T): boolean;
+    /**
+     * Get the size of the set containing the element
+     * @param element - The element to query
+     * @returns Size of the set, or 0 if element doesn't exist
+     * @complexity O(α(n)) amortized
+     */
+    getSetSize(element: T): number;
+    /**
+     * Get all disjoint sets
+     * @returns Map from representative element to array of all elements in that set
+     * @complexity O(n)
+     */
+    getSets(): Map<T, T[]>;
+    /**
+     * Get all elements in the same set as the given element
+     * @param element - The element to query
+     * @returns Array of all elements in the same set, or empty array if element doesn't exist
+     * @complexity O(n) - needs to scan all elements
+     */
+    getSet(element: T): T[];
+    /**
+     * Check if an element exists in the data structure
+     * @param element - The element to check
+     * @complexity O(1)
+     */
+    has(element: T): boolean;
+    /**
+     * Remove an element from the data structure
+     * Note: This is not a standard operation for Disjoint Set and has O(n) complexity
+     * @param element - The element to remove
+     * @returns true if element was found and removed
+     * @complexity O(n)
+     */
+    remove(element: T): boolean;
+    /**
+     * Clear all sets
+     * @complexity O(1)
+     */
+    clear(): void;
+    /**
+     * Get all elements
+     * @returns Array of all elements
+     * @complexity O(n)
+     */
+    elements(): T[];
+    /**
+     * Get statistics about the disjoint set
+     */
+    getStats(): DisjointSetStats;
+    /**
+     * Number of elements in the data structure
+     */
+    readonly size: number;
+    /**
+     * Number of disjoint sets
+     */
+    readonly numSets: number;
+    /**
+     * Whether the data structure is empty
+     */
+    readonly isEmpty: boolean;
+}
+/**
+ * Options for creating a Disjoint Set
+ */
+export interface DisjointSetOptions<T> {
+    /**
+     * Custom hash function for elements
+     * If not provided, uses JSON.stringify for objects or toString for primitives
+     */
+    hashFn?: (element: T) => string | number;
+    /**
+     * Custom equality function
+     * If not provided, uses strict equality (===)
+     */
+    equalityFn?: (a: T, b: T) => boolean;
+    /**
+     * Initial elements to create sets for
+     */
+    initialElements?: T[];
+}
+/**
+ * Utility functions for Disjoint Set
+ */
+export declare const DisjointSetUtils: {
+    /**
+     * Calculate expected memory usage
+     * @param n - Number of elements
+     * @returns Estimated memory in bytes
+     */
+    estimateMemory(n: number): number;
+    /**
+     * Check if operations are effectively O(1)
+     * For practical purposes, α(n) ≤ 4 for any realistic n
+     */
+    inverseAckermann(n: number): number;
+    /**
+     * Create a grid coordinate hash function for merged cells
+     * Useful for grid applications where elements are [row, col] coordinates
+     */
+    gridHashFn(element: [number, number]): string;
+    /**
+     * Create equality function for grid coordinates
+     */
+    gridEqualityFn(a: [number, number], b: [number, number]): boolean;
+};
+//# sourceMappingURL=disjoint-set.interface.d.ts.map

package/dist/src/data-structures/disjoint-set/disjoint-set.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disjoint-set.interface.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/disjoint-set/disjoint-set.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+BAA+B;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,uBAAuB;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC;IAE1B;;;;;;OAMG;IACH,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAEhC;;;;;;;OAOG;IACH,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO,CAAC;IAEzC;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO,CAAC;IAE7C;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,CAAC,GAAG,MAAM,CAAC;IAE/B;;;;OAIG;IACH,OAAO,IAAI,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAEvB;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;IAExB;;;;OAIG;IACH,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC;IAEzB;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC;IAE5B;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;;OAIG;IACH,QAAQ,IAAI,CAAC,EAAE,CAAC;IAEhB;;OAEG;IACH,QAAQ,IAAI,gBAAgB,CAAC;IAE7B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAAC;IAEzC;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAErC;;OAEG;IACH,eAAe,CAAC,EAAE,CAAC,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;OAIG;sBACe,MAAM,GAAG,MAAM;IAOjC;;;OAGG;wBACiB,MAAM,GAAG,MAAM;IAUnC;;;OAGG;wBACiB,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM;IAI7C;;OAEG;sBACe,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO;CAGlE,CAAC"}

package/dist/src/data-structures/disjoint-set/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Disjoint Set (Union-Find) for ZenGrid
+ */
+export { DisjointSet } from './disjoint-set';
+export type { IDisjointSet, DisjointSetOptions, DisjointSetStats } from './disjoint-set.interface';
+export { DisjointSetUtils } from './disjoint-set.interface';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/disjoint-set/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACnG,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC"}

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

@@ -0,0 +1,150 @@
+/**
+ * IndexMap implementation
+ * Provides O(1) bidirectional lookup with maintained insertion order
+ */
+import type { IIndexMap, IndexMapEntry, IndexMapOptions } from './index-map.interface';
+/**
+ * IndexMap - A hybrid data structure combining Map and Array benefits
+ *
+ * Features:
+ * - O(1) key → value lookup
+ * - O(1) index → entry lookup
+ * - O(1) key → index lookup
+ * - Optional O(1) value → key reverse lookup
+ * - Maintains insertion order
+ *
+ * Implementation:
+ * - Uses Map for key → {value, index} mapping
+ * - Uses Array for index → {key, value} mapping
+ * - Optional Map for value → key[] reverse mapping
+ *
+ * @example
+ * ```typescript
+ * const map = new IndexMap<string, number>();
+ * map.set('a', 1); // index 0
+ * map.set('b', 2); // index 1
+ * map.set('c', 3); // index 2
+ *
+ * map.get('b');           // 2
+ * map.getByIndex(1);      // { key: 'b', value: 2, index: 1 }
+ * map.indexOf('c');       // 2
+ * map.getValueByIndex(0); // 1
+ * ```
+ */
+export declare class IndexMap<K, V> implements IIndexMap<K, V> {
+    private keyToData;
+    private indexToEntry;
+    private valueToKeys?;
+    private readonly reverseMapping;
+    constructor(options?: IndexMapOptions);
+    /**
+     * Set a key-value pair
+     */
+    set(key: K, value: V): number;
+    /**
+     * Get value by key
+     */
+    get(key: K): V | undefined;
+    /**
+     * Get entry by index
+     */
+    getByIndex(index: number): IndexMapEntry<K, V> | undefined;
+    /**
+     * Get key by index
+     */
+    getKeyByIndex(index: number): K | undefined;
+    /**
+     * Get value by index
+     */
+    getValueByIndex(index: number): V | undefined;
+    /**
+     * Get the index of a key
+     */
+    indexOf(key: K): number;
+    /**
+     * Reverse lookup: get key(s) by value
+     */
+    getKeysByValue(value: V): K[];
+    /**
+     * Check if a key exists
+     */
+    has(key: K): boolean;
+    /**
+     * Check if a value exists
+     */
+    hasValue(value: V): boolean;
+    /**
+     * Delete an entry by key
+     * Reindexes all subsequent entries
+     */
+    delete(key: K): boolean;
+    /**
+     * Delete an entry by index
+     */
+    deleteByIndex(index: number): boolean;
+    /**
+     * Clear all entries
+     */
+    clear(): void;
+    /**
+     * Get all keys in insertion order
+     */
+    keys(): K[];
+    /**
+     * Get all values in insertion order
+     */
+    values(): V[];
+    /**
+     * Get all entries in insertion order
+     */
+    entries(): [K, V][];
+    /**
+     * Iterate over entries
+     */
+    forEach(callback: (value: V, key: K, index: number) => void): void;
+    /**
+     * Find the first key that satisfies a predicate
+     */
+    find(predicate: (value: V, key: K, index: number) => boolean): K | undefined;
+    /**
+     * Filter entries by a predicate
+     */
+    filter(predicate: (value: V, key: K, index: number) => boolean): IIndexMap<K, V>;
+    /**
+     * Map values to a new IndexMap
+     */
+    map<U>(mapper: (value: V, key: K, index: number) => U): IIndexMap<K, U>;
+    /**
+     * Number of entries
+     */
+    get size(): number;
+    /**
+     * Whether reverse mapping is enabled
+     */
+    get hasReverseMapping(): boolean;
+    /**
+     * Create IndexMap from an array of entries
+     */
+    static from<K, V>(entries: Iterable<[K, V]>, options?: IndexMapOptions): IndexMap<K, V>;
+    /**
+     * Create IndexMap from a regular Map
+     */
+    static fromMap<K, V>(source: Map<K, V>, options?: IndexMapOptions): IndexMap<K, V>;
+    /**
+     * Create IndexMap from an object
+     */
+    static fromObject<V>(obj: Record<string, V>, options?: IndexMapOptions): IndexMap<string, V>;
+    /**
+     * Convert to a plain object (only works with string keys)
+     */
+    toObject(): Record<string, V>;
+    /**
+     * Convert to a regular Map
+     */
+    toMap(): Map<K, V>;
+    /**
+     * Get a string representation for debugging
+     */
+    toString(): string;
+}
+//# sourceMappingURL=index-map.d.ts.map

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

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

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

@@ -0,0 +1,186 @@
+/**
+ * IndexMap interfaces for ZenGrid
+ * Provides O(1) bidirectional lookup: key → value, index → entry, and optionally value → key
+ */
+/**
+ * Entry in the IndexMap containing both key and value
+ */
+export interface IndexMapEntry<K, V> {
+    key: K;
+    value: V;
+    index: number;
+}
+/**
+ * IndexMap interface
+ *
+ * A data structure that combines the benefits of Map and Array:
+ * - O(1) key → value lookup (like Map)
+ * - O(1) index → entry lookup (like Array)
+ * - O(1) key → index lookup
+ * - Maintains insertion order
+ * - Optional O(1) value → key reverse lookup
+ *
+ * Use cases:
+ * - Column/row mappings where you need both name and index access
+ * - Ordered collections with fast lookup by both key and position
+ * - Maintaining insertion order while allowing random access
+ */
+export interface IIndexMap<K, V> {
+    /**
+     * Set a key-value pair
+     * If key exists, updates the value without changing index
+     * If key is new, appends to the end
+     * @param key - The key
+     * @param value - The value
+     * @returns The index of the entry
+     * @complexity O(1)
+     */
+    set(key: K, value: V): number;
+    /**
+     * Get value by key
+     * @param key - The key to look up
+     * @returns The value or undefined if not found
+     * @complexity O(1)
+     */
+    get(key: K): V | undefined;
+    /**
+     * Get entry by index
+     * @param index - The index (0-based)
+     * @returns The entry or undefined if out of bounds
+     * @complexity O(1)
+     */
+    getByIndex(index: number): IndexMapEntry<K, V> | undefined;
+    /**
+     * Get key by index
+     * @param index - The index (0-based)
+     * @returns The key or undefined if out of bounds
+     * @complexity O(1)
+     */
+    getKeyByIndex(index: number): K | undefined;
+    /**
+     * Get value by index
+     * @param index - The index (0-based)
+     * @returns The value or undefined if out of bounds
+     * @complexity O(1)
+     */
+    getValueByIndex(index: number): V | undefined;
+    /**
+     * Get the index of a key
+     * @param key - The key to look up
+     * @returns The index or -1 if not found
+     * @complexity O(1)
+     */
+    indexOf(key: K): number;
+    /**
+     * Get the key(s) for a given value (reverse lookup)
+     * Only available when enableReverseMapping is true
+     * @param value - The value to find
+     * @returns Array of keys that map to this value (empty if not found or reverse mapping disabled)
+     * @complexity O(1) if reverse mapping enabled, O(n) if disabled
+     */
+    getKeysByValue(value: V): K[];
+    /**
+     * Check if a key exists
+     * @param key - The key to check
+     * @complexity O(1)
+     */
+    has(key: K): boolean;
+    /**
+     * Check if a value exists
+     * @param value - The value to check
+     * @complexity O(1) if reverse mapping enabled, O(n) if disabled
+     */
+    hasValue(value: V): boolean;
+    /**
+     * Delete an entry by key
+     * Reindexes all subsequent entries
+     * @param key - The key to delete
+     * @returns true if the entry existed and was deleted
+     * @complexity O(n) due to reindexing
+     */
+    delete(key: K): boolean;
+    /**
+     * Delete an entry by index
+     * Reindexes all subsequent entries
+     * @param index - The index to delete
+     * @returns true if the index was valid and entry was deleted
+     * @complexity O(n) due to reindexing
+     */
+    deleteByIndex(index: number): boolean;
+    /**
+     * Clear all entries
+     * @complexity O(1)
+     */
+    clear(): void;
+    /**
+     * Get all keys in insertion order
+     * @returns Array of keys
+     * @complexity O(n)
+     */
+    keys(): K[];
+    /**
+     * Get all values in insertion order
+     * @returns Array of values
+     * @complexity O(n)
+     */
+    values(): V[];
+    /**
+     * Get all entries in insertion order
+     * @returns Array of [key, value] tuples
+     * @complexity O(n)
+     */
+    entries(): [K, V][];
+    /**
+     * Iterate over entries
+     * @param callback - Function to call for each entry
+     * @complexity O(n)
+     */
+    forEach(callback: (value: V, key: K, index: number) => void): void;
+    /**
+     * Find the first key that satisfies a predicate
+     * @param predicate - Test function
+     * @returns The key or undefined
+     * @complexity O(n)
+     */
+    find(predicate: (value: V, key: K, index: number) => boolean): K | undefined;
+    /**
+     * Filter entries by a predicate
+     * @param predicate - Test function
+     * @returns New IndexMap with entries that pass the test
+     * @complexity O(n)
+     */
+    filter(predicate: (value: V, key: K, index: number) => boolean): IIndexMap<K, V>;
+    /**
+     * Map values to a new IndexMap
+     * @param mapper - Transform function
+     * @returns New IndexMap with transformed values
+     * @complexity O(n)
+     */
+    map<U>(mapper: (value: V, key: K, index: number) => U): IIndexMap<K, U>;
+    /**
+     * Number of entries
+     */
+    readonly size: number;
+    /**
+     * Whether reverse value → key mapping is enabled
+     */
+    readonly hasReverseMapping: boolean;
+}
+/**
+ * Options for creating an IndexMap
+ */
+export interface IndexMapOptions {
+    /**
+     * Enable bidirectional value → key lookup
+     * Maintains a reverse map for O(1) value → key queries
+     * Increases memory usage but enables fast reverse lookups
+     * @default false
+     */
+    enableReverseMapping?: boolean;
+    /**
+     * Initial capacity hint for optimization
+     * @default 16
+     */
+    initialCapacity?: number;
+}
+//# sourceMappingURL=index-map.interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-map.interface.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/index-map/index-map.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,EAAE,CAAC;IACjC,GAAG,EAAE,CAAC,CAAC;IACP,KAAK,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,EAAE,CAAC;IAC7B;;;;;;;;OAQG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC;IAE9B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAE3B;;;;;OAKG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC;IAE3D;;;;;OAKG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;IAE5C;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;IAE9C;;;;;OAKG;IACH,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC;IAExB;;;;;;OAMG;IACH,cAAc,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;IAE9B;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAErB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IAE5B;;;;;;OAMG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAExB;;;;;;OAMG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAEtC;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;;OAIG;IACH,IAAI,IAAI,CAAC,EAAE,CAAC;IAEZ;;;;OAIG;IACH,MAAM,IAAI,CAAC,EAAE,CAAC;IAEd;;;;OAIG;IACH,OAAO,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;IAEpB;;;;OAIG;IACH,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAEnE;;;;;OAKG;IACH,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,CAAC,GAAG,SAAS,CAAC;IAE7E;;;;;OAKG;IACH,MAAM,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEjF;;;;;OAKG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAExE;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B"}

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

@@ -0,0 +1,6 @@
+/**
+ * IndexMap - Bidirectional lookup data structure
+ */
+export { IndexMap } from './index-map';
+export type { IIndexMap, IndexMapEntry, IndexMapOptions } from './index-map.interface';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/index-map/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/src/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/data-structures/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/data-structures/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAGhG,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,YAAY,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAGjF,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,EAAE,SAAS,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAG7E,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAClG,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,YAAY,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAG9E,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,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGtF,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAGrF,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,EAAE,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACzF,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/src/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/data-structures/interval-tree/index.d.ts.map

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

@@ -0,0 +1,58 @@
+/**
+ * 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(interval: Interval, data: T): IntervalData<T>;
+    delete(intervalData: IntervalData<T>): boolean;
+    deleteById(id: string | number): boolean;
+    search(interval: Interval): IntervalData<T>[];
+    searchPoint(point: number): IntervalData<T>[];
+    searchContained(interval: Interval): IntervalData<T>[];
+    searchContaining(interval: Interval): IntervalData<T>[];
+    findMin(): IntervalData<T> | undefined;
+    findMax(): IntervalData<T> | undefined;
+    hasOverlap(interval: Interval): boolean;
+    inorder(): IntervalData<T>[];
+    forEach(callback: (interval: IntervalData<T>) => void): void;
+    filter(predicate: (interval: IntervalData<T>) => boolean): IIntervalTree<T>;
+    map<U>(mapper: (data: T, interval: Interval) => U): IIntervalTree<U>;
+    clear(): void;
+    get size(): number;
+    get isEmpty(): boolean;
+    get height(): number;
+    static from<T>(intervals: Array<{
+        interval: Interval;
+        data: T;
+    }>, options?: IntervalTreeOptions): IntervalTree<T>;
+    toString(): string;
+    validate(): boolean;
+}
+//# sourceMappingURL=interval-tree.d.ts.map