@zengrid/core 1.0.7 → 1.1.0

package/dist/src/rendering/renderers/advanced-cell-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"advanced-cell-renderer.d.ts","sourceRoot":"","sources":["../../../../src/rendering/renderers/advanced-cell-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IAE3C;;OAEG;IACH,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,GAAG,CAAC;IAExC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,OAAO,CAAC;IAE7C;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;OAEG;IACH,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAE7B;;OAEG;IACH,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAEhC;;;OAGG;IACH,MAAM,CAAC,EAAE,YAAY,GAAG,UAAU,CAAC;IAEnC;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IACvD,OAAO,CAAC,OAAO,CAA8B;gBAEjC,OAAO,EAAE,2BAA2B;IAQhD,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI;IAkBxD,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI;IAexD,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAMnC,OAAO,CAAC,sBAAsB;IAc9B,OAAO,CAAC,sBAAsB;IA6B9B,OAAO,CAAC,eAAe;CAmBxB"}

package/dist/src/rendering/renderers/image-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"image-renderer.d.ts","sourceRoot":"","sources":["../../../../src/rendering/renderers/image-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,CAAC;IAE3D;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,aAAc,YAAW,YAAY;IAChD,OAAO,CAAC,OAAO,CAAuB;gBAE1B,OAAO,GAAE,oBAAyB;IAQ9C,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI;IAsBxD,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI;IAWxD,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAKnC,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,UAAU;CAInB"}

package/dist/src/rendering/renderers/number-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"number-renderer.d.ts","sourceRoot":"","sources":["../../../../src/rendering/renderers/number-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B;;;OAGG;IACH,KAAK,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;IAE3C;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,cAAe,YAAW,YAAY;IACjD,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,aAAa,CAAS;gBAElB,OAAO,GAAE,qBAA0B;IAU/C,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI;IAKxD,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI;IAYxD,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;CAIpC"}

package/dist/src/rendering/renderers/text-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"text-renderer.d.ts","sourceRoot":"","sources":["../../../../src/rendering/renderers/text-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEvE;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,YAAW,YAAY;IAC/C,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI;IAKxD,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI;IAIxD,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAKnC,OAAO,CAAC,WAAW;CAIpB"}

package/dist/src/shared/algorithms/filter/bloom-filter.d.ts

@@ -1,120 +0,0 @@
-/**
- * Bloom Filter - Probabilistic Data Structure
- *
- * A space-efficient probabilistic data structure for testing set membership.
- * May have false positives but never false negatives.
- *
- * **Time Complexity:**
- * - Add: O(k) where k = number of hash functions
- * - Check: O(k)
- *
- * **Space Complexity:** O(m) where m = bit array size
- *
- * **Use Cases:**
- * - Quick "definitely not in set" checks (e.g., "does this filter value exist?")
- * - Cache optimization (avoid expensive lookups for non-existent items)
- * - Duplicate detection in large datasets
- * - Spell checkers
- *
- * @example
- * ```typescript
- * const filter = new BloomFilter(1000, 3); // 1000 bits, 3 hash functions
- *
- * // Add some items
- * filter.add('apple');
- * filter.add('banana');
- * filter.add('cherry');
- *
- * filter.contains('apple');   // true (definitely in set)
- * filter.contains('grape');   // false (definitely NOT in set)
- * filter.contains('apples');  // might be true (false positive possible)
- * ```
- *
- * @example Grid Filter Optimization
- * ```typescript
- * // Quickly check if a filter value might exist before scanning column
- * class ColumnFilter {
- *   private bloomFilter = new BloomFilter(10000, 4);
- *
- *   indexColumn(values: any[]): void {
- *     values.forEach(v => this.bloomFilter.add(String(v)));
- *   }
- *
- *   mightContain(value: string): boolean {
- *     return this.bloomFilter.contains(value);
- *   }
- * }
- * ```
- */
-export declare class BloomFilter {
-    private bitArray;
-    private size;
-    private hashCount;
-    /**
-     * Create a new Bloom Filter
-     *
-     * @param size - Size of the bit array (larger = fewer false positives)
-     * @param hashCount - Number of hash functions (more = fewer false positives, slower)
-     */
-    constructor(size: number, hashCount?: number);
-    /**
-     * Add an item to the filter
-     *
-     * @param item - Item to add
-     */
-    add(item: string): void;
-    /**
-     * Check if an item might be in the set
-     *
-     * @param item - Item to check
-     * @returns true if item might be in set, false if definitely NOT in set
-     */
-    contains(item: string): boolean;
-    /**
-     * Clear the filter
-     */
-    clear(): void;
-    /**
-     * Get the false positive probability
-     *
-     * P(false positive) ≈ (1 - e^(-kn/m))^k
-     * where k = hash functions, n = items added, m = bit array size
-     *
-     * @param itemCount - Number of items added
-     * @returns Estimated false positive probability
-     */
-    getFalsePositiveRate(itemCount: number): number;
-    /**
-     * Calculate optimal bit array size for desired false positive rate
-     *
-     * m = -(n * ln(p)) / (ln(2)^2)
-     *
-     * @param itemCount - Expected number of items
-     * @param falsePositiveRate - Desired false positive rate (e.g., 0.01 for 1%)
-     * @returns Optimal bit array size
-     */
-    static optimalSize(itemCount: number, falsePositiveRate: number): number;
-    /**
-     * Calculate optimal number of hash functions
-     *
-     * k = (m/n) * ln(2)
-     *
-     * @param bitArraySize - Size of bit array
-     * @param itemCount - Expected number of items
-     * @returns Optimal number of hash functions
-     */
-    static optimalHashCount(bitArraySize: number, itemCount: number): number;
-    /**
-     * Generate multiple hash values for an item
-     */
-    private getHashes;
-    /**
-     * First hash function (simple polynomial hash)
-     */
-    private hashFunc1;
-    /**
-     * Second hash function (FNV-1a variant)
-     */
-    private hashFunc2;
-}
-//# sourceMappingURL=bloom-filter.d.ts.map

package/dist/src/shared/algorithms/filter/bloom-filter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bloom-filter.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/filter/bloom-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,SAAS,CAAS;IAE1B;;;;;OAKG;gBACS,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,MAAU;IAM/C;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQvB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAY/B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;;;;;;OAQG;IACH,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAQ/C;;;;;;;;OAQG;IACH,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,MAAM;IAIxE;;;;;;;;OAQG;IACH,MAAM,CAAC,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;IAMxE;;OAEG;IACH,OAAO,CAAC,SAAS;IAejB;;OAEG;IACH,OAAO,CAAC,SAAS;IAUjB;;OAEG;IACH,OAAO,CAAC,SAAS;CAUlB"}

package/dist/src/shared/algorithms/filter/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Filter Algorithms
- *
- * Efficient filtering and probabilistic data structures.
- */
-export { BloomFilter } from './bloom-filter';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/algorithms/filter/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/filter/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/src/shared/algorithms/graph/bfs.d.ts

@@ -1,71 +0,0 @@
-import type { AdjacencyList, BFSOptions, PathResult } from './graph.interface';
-/**
- * Breadth-First Search (BFS)
- *
- * Explores nodes level by level, visiting all neighbors before moving deeper.
- *
- * **Time Complexity:** O(V + E) where V = vertices, E = edges
- * **Space Complexity:** O(V) for the queue
- *
- * **Use Cases:**
- * - Shortest path in unweighted graphs
- * - Level-order traversal
- * - Finding connected components
- * - Web crawling
- * - Social network analysis (friends of friends)
- *
- * @example
- * ```typescript
- * const graph: AdjacencyList<string> = new Map([
- *   ['A', new Set(['B', 'C'])],
- *   ['B', new Set(['D', 'E'])],
- *   ['C', new Set(['F'])],
- *   ['D', new Set()],
- *   ['E', new Set()],
- *   ['F', new Set()],
- * ]);
- *
- * const visited = bfs(graph, 'A');
- * // visited: ['A', 'B', 'C', 'D', 'E', 'F'] (breadth-first order)
- * ```
- *
- * @param graph - Adjacency list representation
- * @param start - Starting node
- * @param options - Traversal options
- * @returns Array of visited nodes in BFS order
- */
-export declare function bfs<T>(graph: AdjacencyList<T>, start: T, options?: BFSOptions<T>): T[];
-/**
- * BFS to find shortest path between two nodes (unweighted)
- *
- * @param graph - Adjacency list
- * @param start - Start node
- * @param end - End node
- * @returns Path result with shortest path
- */
-export declare function bfsShortestPath<T>(graph: AdjacencyList<T>, start: T, end: T): PathResult<T>;
-/**
- * Find all nodes at a specific distance from start
- *
- * @param graph - Adjacency list
- * @param start - Start node
- * @param distance - Distance from start
- * @returns Array of nodes at the specified distance
- */
-export declare function nodesAtDistance<T>(graph: AdjacencyList<T>, start: T, distance: number): T[];
-/**
- * Find connected component containing a node
- *
- * @param graph - Adjacency list
- * @param start - Starting node
- * @returns All nodes in the connected component
- */
-export declare function connectedComponent<T>(graph: AdjacencyList<T>, start: T): T[];
-/**
- * Find all connected components in the graph
- *
- * @param graph - Adjacency list
- * @returns Array of connected components
- */
-export declare function allConnectedComponents<T>(graph: AdjacencyList<T>): T[][];
-//# sourceMappingURL=bfs.d.ts.map

package/dist/src/shared/algorithms/graph/bfs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bfs.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/graph/bfs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,GAAG,CAAC,CAAC,EACnB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,CAAC,EACR,OAAO,GAAE,UAAU,CAAC,CAAC,CAAM,GAC1B,CAAC,EAAE,CA8BL;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CA8C3F;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,EAAE,CA8B3F;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,CAE5E;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAaxE"}

package/dist/src/shared/algorithms/graph/dfs.d.ts

@@ -1,62 +0,0 @@
-import type { AdjacencyList, DFSOptions } from './graph.interface';
-/**
- * Depth-First Search (DFS)
- *
- * Explores as far as possible along each branch before backtracking.
- *
- * **Time Complexity:** O(V + E) where V = vertices, E = edges
- * **Space Complexity:** O(V) for the recursion stack
- *
- * **Use Cases:**
- * - Path finding
- * - Cycle detection
- * - Topological sorting
- * - Connected components
- * - Maze solving
- *
- * @example
- * ```typescript
- * const graph: AdjacencyList<string> = new Map([
- *   ['A', new Set(['B', 'C'])],
- *   ['B', new Set(['D'])],
- *   ['C', new Set(['D'])],
- *   ['D', new Set()],
- * ]);
- *
- * const visited = dfs(graph, 'A');
- * // visited: ['A', 'B', 'D', 'C'] (depth-first order)
- * ```
- *
- * @param graph - Adjacency list representation
- * @param start - Starting node
- * @param options - Traversal options
- * @returns Array of visited nodes in DFS order
- */
-export declare function dfs<T>(graph: AdjacencyList<T>, start: T, options?: DFSOptions<T>): T[];
-/**
- * DFS to find a path between two nodes
- *
- * @param graph - Adjacency list
- * @param start - Start node
- * @param end - End node
- * @returns Path from start to end, or empty array if no path exists
- */
-export declare function dfsPath<T>(graph: AdjacencyList<T>, start: T, end: T): T[];
-/**
- * Detect if a graph has cycles using DFS
- *
- * @param graph - Adjacency list
- * @returns true if graph has cycles
- */
-export declare function hasCycle<T>(graph: AdjacencyList<T>): boolean;
-/**
- * Find all strongly connected components using Tarjan's algorithm
- *
- * A strongly connected component is a maximal set of vertices
- * where every vertex is reachable from every other vertex.
- *
- * @param graph - Adjacency list
- * @returns Array of strongly connected components
- */
-export declare function stronglyConnectedComponents<T>(graph: AdjacencyList<T>): T[][];
-//# sourceMappingURL=dfs.d.ts.map

package/dist/src/shared/algorithms/graph/dfs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dfs.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/graph/dfs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,GAAG,CAAC,CAAC,EACnB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,CAAC,EACR,OAAO,GAAE,UAAU,CAAC,CAAC,CAAM,GAC1B,CAAC,EAAE,CAiCL;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,CA0BzE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CA6B5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAiD7E"}

package/dist/src/shared/algorithms/graph/graph.interface.d.ts

@@ -1,63 +0,0 @@
-/**
- * Graph algorithm interfaces and types
- */
-/**
- * Generic graph representation (adjacency list)
- */
-export type AdjacencyList<T = any> = Map<T, Set<T>>;
-/**
- * Weighted edge
- */
-export interface WeightedEdge<T> {
-    from: T;
-    to: T;
-    weight: number;
-}
-/**
- * DFS traversal options
- */
-export interface DFSOptions<T> {
-    /**
-     * Callback when visiting a node
-     */
-    onVisit?: (node: T, depth: number) => void;
-    /**
-     * Callback when backtracking from a node
-     */
-    onBacktrack?: (node: T) => void;
-    /**
-     * Callback when detecting a back edge (cycle)
-     */
-    onBackEdge?: (from: T, to: T) => void;
-}
-/**
- * BFS traversal options
- */
-export interface BFSOptions<T> {
-    /**
-     * Callback when visiting a node
-     */
-    onVisit?: (node: T, level: number) => void;
-    /**
-     * Maximum depth to traverse
-     */
-    maxDepth?: number;
-}
-/**
- * Path result
- */
-export interface PathResult<T> {
-    /**
-     * Nodes in the path
-     */
-    path: T[];
-    /**
-     * Total cost/distance
-     */
-    cost: number;
-    /**
-     * Whether a path was found
-     */
-    found: boolean;
-}
-//# sourceMappingURL=graph.interface.d.ts.map

package/dist/src/shared/algorithms/graph/graph.interface.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graph.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/graph/graph.interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,GAAG,IAAI,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,IAAI,EAAE,CAAC,CAAC;IACR,EAAE,EAAE,CAAC,CAAC;IACN,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAE3C;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAEhC;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAE3C;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B;;OAEG;IACH,IAAI,EAAE,CAAC,EAAE,CAAC;IAEV;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB"}

package/dist/src/shared/algorithms/graph/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Graph Algorithms
- *
- * Efficient algorithms for graph traversal, path finding, and analysis.
- */
-export { dfs, dfsPath, hasCycle, stronglyConnectedComponents, } from './dfs';
-export { bfs, bfsShortestPath, nodesAtDistance, connectedComponent, allConnectedComponents, } from './bfs';
-export type { AdjacencyList, WeightedEdge, DFSOptions, BFSOptions, PathResult, } from './graph.interface';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/algorithms/graph/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/graph/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,GAAG,EACH,OAAO,EACP,QAAQ,EACR,2BAA2B,GAC5B,MAAM,OAAO,CAAC;AAGf,OAAO,EACL,GAAG,EACH,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,OAAO,CAAC;AAGf,YAAY,EACV,aAAa,EACb,YAAY,EACZ,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,mBAAmB,CAAC"}

package/dist/src/shared/algorithms/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Algorithms for ZenGrid
- */
-export { binarySearch, binarySearchLeft, binarySearchRight, } from './search';
-export type { BinarySearchOptions, BinarySearchResult, } from './search';
-export { dfs, dfsPath, hasCycle, stronglyConnectedComponents, bfs, bfsShortestPath, nodesAtDistance, connectedComponent, allConnectedComponents, } from './graph';
-export type { AdjacencyList, WeightedEdge, DFSOptions, BFSOptions, PathResult, } from './graph';
-export { BloomFilter } from './filter';
-export { detectSequence, generateSequence, autofill, } from './pattern';
-export type { SequenceType, SequencePattern, } from './pattern';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/algorithms/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/shared/algorithms/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,GAAG,EACH,OAAO,EACP,QAAQ,EACR,2BAA2B,EAC3B,GAAG,EACH,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,SAAS,CAAC;AACjB,YAAY,EACV,aAAa,EACb,YAAY,EACZ,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,QAAQ,GACT,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,YAAY,EACZ,eAAe,GAChB,MAAM,WAAW,CAAC"}

package/dist/src/shared/algorithms/pattern/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Pattern Detection Algorithms
- *
- * Algorithms for detecting patterns in data sequences and autofill.
- */
-export { detectSequence, generateSequence, autofill, } from './sequence-detector';
-export type { SequenceType, SequencePattern, } from './sequence-detector';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/algorithms/pattern/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/pattern/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,QAAQ,GACT,MAAM,qBAAqB,CAAC;AAE7B,YAAY,EACV,YAAY,EACZ,eAAe,GAChB,MAAM,qBAAqB,CAAC"}

package/dist/src/shared/algorithms/pattern/sequence-detector.d.ts

@@ -1,62 +0,0 @@
-/**
- * Sequence Detection for Autofill
- *
- * Detects patterns in data sequences for intelligent autofill.
- *
- * **Supported Patterns:**
- * - Arithmetic sequences: 1, 2, 3, 4, ...
- * - Geometric sequences: 2, 4, 8, 16, ...
- * - Date sequences: Jan 1, Jan 2, Jan 3, ...
- * - Day sequences: Mon, Tue, Wed, ...
- * - Text patterns: Item 1, Item 2, Item 3, ...
- *
- * @example
- * ```typescript
- * // Detect arithmetic sequence
- * const pattern = detectSequence([1, 2, 3, 4]);
- * // pattern: { type: 'arithmetic', step: 1 }
- *
- * // Generate next values
- * const next = generateSequence(pattern, 5, 3);
- * // next: [5, 6, 7]
- * ```
- */
-/**
- * Sequence pattern types
- */
-export type SequenceType = 'arithmetic' | 'geometric' | 'date' | 'text' | 'constant' | 'none';
-/**
- * Detected sequence pattern
- */
-export interface SequencePattern {
-    type: SequenceType;
-    step?: number;
-    ratio?: number;
-    template?: string;
-    confidence: number;
-}
-/**
- * Detect sequence pattern from an array of values
- *
- * @param values - Array of values (at least 2 required)
- * @returns Detected pattern
- */
-export declare function detectSequence(values: any[]): SequencePattern;
-/**
- * Generate next values in a sequence
- *
- * @param pattern - Detected sequence pattern
- * @param startValue - Starting value
- * @param count - Number of values to generate
- * @returns Array of generated values
- */
-export declare function generateSequence(pattern: SequencePattern, startValue: any, count: number): any[];
-/**
- * Autofill a range based on detected pattern
- *
- * @param source - Source values to detect pattern from
- * @param targetLength - Desired length of result
- * @returns Autofilled array
- */
-export declare function autofill(source: any[], targetLength: number): any[];
-//# sourceMappingURL=sequence-detector.d.ts.map

package/dist/src/shared/algorithms/pattern/sequence-detector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sequence-detector.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/pattern/sequence-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,YAAY,GACZ,WAAW,GACX,MAAM,GACN,MAAM,GACN,UAAU,GACV,MAAM,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,eAAe,CAkC7D;AAoGD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,EAAE,CAsDhG;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,YAAY,EAAE,MAAM,GAAG,GAAG,EAAE,CAqBnE"}

package/dist/src/shared/algorithms/search/binary-search.d.ts

@@ -1,86 +0,0 @@
-import type { Comparator } from '../../types';
-/**
- * Options for binary search
- */
-export interface BinarySearchOptions<T> {
-    /**
-     * Custom comparator function
-     * @default (a, b) => a - b for numbers
-     */
-    comparator?: Comparator<T>;
-    /**
-     * If true, returns insertion point when not found
-     * Insertion point is the index where the target should be inserted
-     * @default false
-     */
-    returnInsertionPoint?: boolean;
-}
-/**
- * Result of binary search
- */
-export interface BinarySearchResult {
-    /**
-     * Whether the target was found
-     */
-    found: boolean;
-    /**
-     * Index where target was found, or -1 if not found
-     * If returnInsertionPoint is true and not found, returns insertion index
-     */
-    index: number;
-}
-/**
- * Performs binary search on a sorted array
- *
- * @param array - Sorted array to search
- * @param target - Value to find
- * @param options - Search options
- * @returns Search result with found status and index
- *
- * @example
- * ```typescript
- * const result = binarySearch([1, 3, 5, 7, 9], 5);
- * // { found: true, index: 2 }
- *
- * const result2 = binarySearch([1, 3, 5, 7], 4, { returnInsertionPoint: true });
- * // { found: false, index: 2 } - insert at index 2 to maintain order
- * ```
- *
- * @complexity O(log n) where n = array.length
- */
-export declare function binarySearch<T>(array: ReadonlyArray<T>, target: T, options?: BinarySearchOptions<T>): BinarySearchResult;
-/**
- * Find the leftmost (first) occurrence of target in sorted array
- *
- * @param array - Sorted array (may have duplicates)
- * @param target - Value to find
- * @param comparator - Custom comparator
- * @returns Index of first occurrence, or -1 if not found
- *
- * @example
- * ```typescript
- * const index = binarySearchLeft([1, 2, 2, 2, 3], 2);
- * // 1 (first occurrence of 2)
- * ```
- *
- * @complexity O(log n)
- */
-export declare function binarySearchLeft<T>(array: ReadonlyArray<T>, target: T, comparator?: Comparator<T>): number;
-/**
- * Find the rightmost (last) occurrence of target in sorted array
- *
- * @param array - Sorted array (may have duplicates)
- * @param target - Value to find
- * @param comparator - Custom comparator
- * @returns Index of last occurrence, or -1 if not found
- *
- * @example
- * ```typescript
- * const index = binarySearchRight([1, 2, 2, 2, 3], 2);
- * // 3 (last occurrence of 2)
- * ```
- *
- * @complexity O(log n)
- */
-export declare function binarySearchRight<T>(array: ReadonlyArray<T>, target: T, comparator?: Comparator<T>): number;
-//# sourceMappingURL=binary-search.d.ts.map

package/dist/src/shared/algorithms/search/binary-search.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary-search.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/search/binary-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC;;;OAGG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IAE3B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;IAEf;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,mBAAmB,CAAC,CAAC,CAAM,GACnC,kBAAkB,CA+BpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,UAAU,GAAE,UAAU,CAAC,CAAC,CAAsC,GAC7D,MAAM,CAqBR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,UAAU,GAAE,UAAU,CAAC,CAAC,CAAsC,GAC7D,MAAM,CAqBR"}

package/dist/src/shared/algorithms/search/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Search algorithms
- */
-export { binarySearch, binarySearchLeft, binarySearchRight, } from './binary-search';
-export type { BinarySearchOptions, BinarySearchResult, } from './binary-search';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/algorithms/search/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/search/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC"}