@zengrid/shared 1.0.2 → 1.0.4

package/dist/index.cjs.js

@@ -1187,7 +1187,7 @@ class CommandStack {
 /**
  * Common aggregation operations
  */
-var AggregationType;
+exports.AggregationType = void 0;
 (function (AggregationType) {
     AggregationType["SUM"] = "sum";
     AggregationType["MIN"] = "min";
@@ -1196,7 +1196,7 @@ var AggregationType;
     AggregationType["LCM"] = "lcm";
     AggregationType["PRODUCT"] = "product";
     AggregationType["CUSTOM"] = "custom";
-})(AggregationType || (AggregationType = {}));
+})(exports.AggregationType || (exports.AggregationType = {}));
 /**
  * Predefined aggregation functions and identities
  */
@@ -1324,10 +1324,10 @@ class SegmentTree {
     constructor(options) {
         this.arr = options.values ? [...options.values] : [];
         this.n = this.arr.length;
-        this._type = options.type ?? AggregationType.CUSTOM;
+        this._type = options.type ?? exports.AggregationType.CUSTOM;
         this.useLazy = options.lazy ?? true;
         // Determine aggregation function and identity
-        if (this._type === AggregationType.CUSTOM) {
+        if (this._type === exports.AggregationType.CUSTOM) {
             if (!options.customAggregate || options.identity === undefined) {
                 throw new Error('CUSTOM aggregation type requires customAggregate function and identity value');
             }
@@ -1353,17 +1353,17 @@ class SegmentTree {
      */
     getAggregationConfig(type) {
         switch (type) {
-            case AggregationType.SUM:
+            case exports.AggregationType.SUM:
                 return Aggregations.sum;
-            case AggregationType.MIN:
+            case exports.AggregationType.MIN:
                 return Aggregations.min;
-            case AggregationType.MAX:
+            case exports.AggregationType.MAX:
                 return Aggregations.max;
-            case AggregationType.GCD:
+            case exports.AggregationType.GCD:
                 return Aggregations.gcd;
-            case AggregationType.LCM:
+            case exports.AggregationType.LCM:
                 return Aggregations.lcm;
-            case AggregationType.PRODUCT:
+            case exports.AggregationType.PRODUCT:
                 return Aggregations.product;
             default:
                 throw new Error(`Unknown aggregation type: ${type}`);
@@ -1409,7 +1409,7 @@ class SegmentTree {
      * For MIN/MAX: just use the update value
      */
     applyUpdate(nodeValue, updateValue, rangeSize) {
-        if (this._type === AggregationType.SUM) {
+        if (this._type === exports.AggregationType.SUM) {
             // For sum, we need to multiply by range size
             const update = updateValue * rangeSize;
             return this.aggregate(nodeValue, update);
@@ -1599,7 +1599,7 @@ class SegmentTree {
     /**
      * Create SegmentTree from array
      */
-    static from(values, type = AggregationType.SUM) {
+    static from(values, type = exports.AggregationType.SUM) {
         return new SegmentTree({ values, type });
     }
     /**
@@ -1608,7 +1608,7 @@ class SegmentTree {
     static custom(values, aggregate, identity) {
         return new SegmentTree({
             values,
-            type: AggregationType.CUSTOM,
+            type: exports.AggregationType.CUSTOM,
             customAggregate: aggregate,
             identity,
         });
@@ -4791,6 +4791,1142 @@ class SuffixArray {
     }
 }
 
+/**
+ * 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]
+ * ```
+ */
+/**
+ * Detect sequence pattern from an array of values
+ *
+ * @param values - Array of values (at least 2 required)
+ * @returns Detected pattern
+ */
+function detectSequence(values) {
+    if (values.length < 2) {
+        return { type: 'none', confidence: 0 };
+    }
+    // Try numeric sequences first
+    if (values.every(v => typeof v === 'number' || !isNaN(Number(v)))) {
+        const numbers = values.map(v => Number(v));
+        // Check arithmetic sequence
+        const arithmeticPattern = detectArithmetic(numbers);
+        if (arithmeticPattern.confidence > 0.8) {
+            return arithmeticPattern;
+        }
+        // Check geometric sequence
+        const geometricPattern = detectGeometric(numbers);
+        if (geometricPattern.confidence > 0.8) {
+            return geometricPattern;
+        }
+    }
+    // Try text patterns
+    const textPattern = detectTextPattern(values.map(v => String(v)));
+    if (textPattern.confidence > 0.7) {
+        return textPattern;
+    }
+    // Check for constant value
+    if (values.every(v => v === values[0])) {
+        return { type: 'constant', confidence: 1.0 };
+    }
+    return { type: 'none', confidence: 0 };
+}
+/**
+ * Detect arithmetic sequence (constant difference)
+ */
+function detectArithmetic(numbers) {
+    if (numbers.length < 2) {
+        return { type: 'none', confidence: 0 };
+    }
+    const differences = [];
+    for (let i = 1; i < numbers.length; i++) {
+        differences.push(numbers[i] - numbers[i - 1]);
+    }
+    // Check if all differences are the same (within small tolerance)
+    const avgDiff = differences.reduce((a, b) => a + b, 0) / differences.length;
+    const variance = differences.reduce((sum, d) => sum + Math.pow(d - avgDiff, 2), 0) / differences.length;
+    if (variance < 0.01) {
+        return {
+            type: 'arithmetic',
+            step: avgDiff,
+            confidence: 1.0,
+        };
+    }
+    return { type: 'none', confidence: 0 };
+}
+/**
+ * Detect geometric sequence (constant ratio)
+ */
+function detectGeometric(numbers) {
+    if (numbers.length < 2 || numbers.some(n => n === 0)) {
+        return { type: 'none', confidence: 0 };
+    }
+    const ratios = [];
+    for (let i = 1; i < numbers.length; i++) {
+        ratios.push(numbers[i] / numbers[i - 1]);
+    }
+    // Check if all ratios are the same
+    const avgRatio = ratios.reduce((a, b) => a + b, 0) / ratios.length;
+    const variance = ratios.reduce((sum, r) => sum + Math.pow(r - avgRatio, 2), 0) / ratios.length;
+    if (variance < 0.01) {
+        return {
+            type: 'geometric',
+            ratio: avgRatio,
+            confidence: 1.0,
+        };
+    }
+    return { type: 'none', confidence: 0 };
+}
+/**
+ * Detect text pattern with number suffix
+ * E.g., "Item 1", "Item 2", "Item 3"
+ */
+function detectTextPattern(strings) {
+    if (strings.length < 2) {
+        return { type: 'none', confidence: 0 };
+    }
+    // Extract text prefix and number suffix
+    const parts = strings.map(s => {
+        const match = s.match(/^(.*?)(\d+)$/);
+        if (match) {
+            return { prefix: match[1], number: parseInt(match[2], 10) };
+        }
+        return null;
+    });
+    // Check if all have the same prefix
+    if (parts.every(p => p !== null)) {
+        const prefix = parts[0].prefix;
+        if (parts.every(p => p.prefix === prefix)) {
+            const numbers = parts.map(p => p.number);
+            const arithmeticPattern = detectArithmetic(numbers);
+            if (arithmeticPattern.type === 'arithmetic') {
+                return {
+                    type: 'text',
+                    template: prefix + '{n}',
+                    step: arithmeticPattern.step,
+                    confidence: 0.9,
+                };
+            }
+        }
+    }
+    return { type: 'none', confidence: 0 };
+}
+/**
+ * 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
+ */
+function generateSequence(pattern, startValue, count) {
+    const result = [];
+    switch (pattern.type) {
+        case 'arithmetic':
+            {
+                let current = Number(startValue);
+                for (let i = 0; i < count; i++) {
+                    result.push(current);
+                    current += pattern.step;
+                }
+            }
+            break;
+        case 'geometric':
+            {
+                let current = Number(startValue);
+                for (let i = 0; i < count; i++) {
+                    result.push(current);
+                    current *= pattern.ratio;
+                }
+            }
+            break;
+        case 'text':
+            {
+                // Extract number from start value
+                const match = String(startValue).match(/^(.*?)(\d+)$/);
+                if (match) {
+                    let num = parseInt(match[2], 10);
+                    const prefix = match[1];
+                    for (let i = 0; i < count; i++) {
+                        result.push(prefix + num);
+                        num += pattern.step ?? 1;
+                    }
+                }
+            }
+            break;
+        case 'constant':
+            for (let i = 0; i < count; i++) {
+                result.push(startValue);
+            }
+            break;
+        default:
+            // No pattern - just repeat the start value
+            for (let i = 0; i < count; i++) {
+                result.push(startValue);
+            }
+    }
+    return result;
+}
+/**
+ * Autofill a range based on detected pattern
+ *
+ * @param source - Source values to detect pattern from
+ * @param targetLength - Desired length of result
+ * @returns Autofilled array
+ */
+function autofill(source, targetLength) {
+    if (source.length === 0)
+        return [];
+    if (targetLength <= source.length)
+        return source.slice(0, targetLength);
+    const pattern = detectSequence(source);
+    if (pattern.type === 'none' || pattern.confidence < 0.5) {
+        // No pattern - just repeat the source cyclically
+        const result = [...source];
+        while (result.length < targetLength) {
+            result.push(source[result.length % source.length]);
+        }
+        return result.slice(0, targetLength);
+    }
+    // Generate remaining values based on pattern
+    const remaining = targetLength - source.length;
+    const lastValue = source[source.length - 1];
+    const generated = generateSequence(pattern, lastValue, remaining + 1).slice(1); // Skip first (same as last)
+    return [...source, ...generated];
+}
+
+/**
+ * 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);
+ *   }
+ * }
+ * ```
+ */
+class BloomFilter {
+    /**
+     * 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, hashCount = 3) {
+        this.size = size;
+        this.hashCount = hashCount;
+        this.bitArray = new Array(size).fill(false);
+    }
+    /**
+     * Add an item to the filter
+     *
+     * @param item - Item to add
+     */
+    add(item) {
+        const hashes = this.getHashes(item);
+        for (const hash of hashes) {
+            this.bitArray[hash] = true;
+        }
+    }
+    /**
+     * 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) {
+        const hashes = this.getHashes(item);
+        for (const hash of hashes) {
+            if (!this.bitArray[hash]) {
+                return false; // Definitely not in set
+            }
+        }
+        return true; // Might be in set (could be false positive)
+    }
+    /**
+     * Clear the filter
+     */
+    clear() {
+        this.bitArray.fill(false);
+    }
+    /**
+     * 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) {
+        const k = this.hashCount;
+        const m = this.size;
+        const n = itemCount;
+        return Math.pow(1 - Math.exp((-k * n) / m), k);
+    }
+    /**
+     * 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, falsePositiveRate) {
+        return Math.ceil(-(itemCount * Math.log(falsePositiveRate)) / Math.pow(Math.log(2), 2));
+    }
+    /**
+     * 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, itemCount) {
+        return Math.ceil((bitArraySize / itemCount) * Math.log(2));
+    }
+    // ==================== Private Methods ====================
+    /**
+     * Generate multiple hash values for an item
+     */
+    getHashes(item) {
+        const hashes = [];
+        // Use double hashing: h_i(x) = h1(x) + i * h2(x)
+        const hash1 = this.hashFunc1(item);
+        const hash2 = this.hashFunc2(item);
+        for (let i = 0; i < this.hashCount; i++) {
+            const hash = (hash1 + i * hash2) % this.size;
+            hashes.push(Math.abs(hash));
+        }
+        return hashes;
+    }
+    /**
+     * First hash function (simple polynomial hash)
+     */
+    hashFunc1(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            hash = (hash * 31 + str.charCodeAt(i)) % this.size;
+        }
+        return hash;
+    }
+    /**
+     * Second hash function (FNV-1a variant)
+     */
+    hashFunc2(str) {
+        let hash = 2166136261; // FNV offset basis
+        for (let i = 0; i < str.length; i++) {
+            hash ^= str.charCodeAt(i);
+            hash = (hash * 16777619) % this.size; // FNV prime
+        }
+        return hash;
+    }
+}
+
+/**
+ * Helper to handle null values in comparisons
+ */
+function compareWithNulls(a, b, nullPosition, compareFn) {
+    const aIsNull = a === null || a === undefined || Number.isNaN(a);
+    const bIsNull = b === null || b === undefined || Number.isNaN(b);
+    if (aIsNull && bIsNull)
+        return 0;
+    if (aIsNull) {
+        return nullPosition === 'first' ? -1 : nullPosition === 'last' ? 1 : 0;
+    }
+    if (bIsNull) {
+        return nullPosition === 'first' ? 1 : nullPosition === 'last' ? -1 : 0;
+    }
+    return compareFn(a, b);
+}
+/**
+ * Create a numeric comparator
+ *
+ * @param nullPosition - Where to place null values in sort order
+ * @returns Comparator function
+ *
+ * @example
+ * ```typescript
+ * const numbers = [3, null, 1, undefined, 2];
+ * numbers.sort(numericComparator('last'));
+ * // [1, 2, 3, null, undefined]
+ * ```
+ */
+function numericComparator(nullPosition = 'last') {
+    return (a, b) => {
+        return compareWithNulls(a, b, nullPosition, (x, y) => {
+            const numX = Number(x);
+            const numY = Number(y);
+            if (Number.isNaN(numX) && Number.isNaN(numY))
+                return 0;
+            if (Number.isNaN(numX))
+                return nullPosition === 'last' ? 1 : -1;
+            if (Number.isNaN(numY))
+                return nullPosition === 'last' ? -1 : 1;
+            return numX - numY;
+        });
+    };
+}
+/**
+ * Create a string comparator
+ *
+ * @param options - Comparator options
+ * @returns Comparator function
+ *
+ * @example
+ * ```typescript
+ * const names = ['Bob', 'alice', 'Charlie'];
+ * names.sort(stringComparator({ caseInsensitive: true }));
+ * // ['alice', 'Bob', 'Charlie']
+ * ```
+ */
+function stringComparator(options = {}) {
+    const { caseInsensitive = false, localeCompare = false, locale = 'en-US', nullPosition = 'last', } = options;
+    return (a, b) => {
+        return compareWithNulls(a, b, nullPosition, (x, y) => {
+            let strA = String(x);
+            let strB = String(y);
+            if (caseInsensitive) {
+                strA = strA.toLowerCase();
+                strB = strB.toLowerCase();
+            }
+            if (localeCompare) {
+                return strA.localeCompare(strB, locale);
+            }
+            return strA < strB ? -1 : strA > strB ? 1 : 0;
+        });
+    };
+}
+
+/**
+ * Minimum gallop threshold
+ * How many times one run must "win" before we switch to galloping mode
+ *
+ * JavaScript Note: Set higher than Python's default (7) due to function call overhead.
+ * Galloping mode has more overhead in JS, so we require more consecutive wins
+ * to justify entering gallop mode.
+ */
+const MIN_GALLOP = 32;
+/**
+ * Minimum merge threshold for stack invariants
+ */
+const MIN_MERGE = 32;
+/**
+ * Timsort - Production-grade stable O(n log n) sorting algorithm
+ *
+ * This is a full implementation of Timsort with all optimizations:
+ * - Natural run detection (finds already-sorted sequences)
+ * - Galloping mode (binary search optimization during merges)
+ * - Stack-based merge strategy (maintains merge invariants)
+ * - Reusable temporary buffer (reduces allocations)
+ *
+ * Used by Python, Java, and V8's Array.sort().
+ *
+ * @param array - Array to sort (modified in-place)
+ * @param comparator - Comparison function
+ * @param options - Timsort options
+ * @returns The sorted array
+ *
+ * @complexity
+ * - Time: O(n log n) worst case, O(n) best case (already sorted)
+ * - Space: O(n) for temporary merge buffer
+ */
+function timsort(array, comparator, options = {}) {
+    const n = array.length;
+    if (n < 2) {
+        return array;
+    }
+    const sorter = new TimsortImpl(array, comparator, options);
+    sorter.sort();
+    return array;
+}
+/**
+ * Sort indices based on values without modifying the values
+ *
+ * @param indices - Array of indices to sort
+ * @param getValue - Function to get value at an index
+ * @param comparator - Comparison function for values
+ * @param options - Timsort options
+ * @returns Sorted array of indices
+ *
+ * @example
+ * ```typescript
+ * const values = ['Charlie', 'Alice', 'Bob'];
+ * const indices = [0, 1, 2];
+ *
+ * const sorted = timsortIndices(
+ *   indices,
+ *   (i) => values[i],
+ *   (a, b) => a.localeCompare(b)
+ * );
+ * // sorted = [1, 2, 0] (Alice, Bob, Charlie)
+ * ```
+ */
+function timsortIndices(indices, getValue, comparator, options = {}) {
+    // Create index comparator
+    const indexComparator = (idxA, idxB) => {
+        return comparator(getValue(idxA), getValue(idxB));
+    };
+    return timsort(indices, indexComparator, options);
+}
+/**
+ * TimsortImpl - Internal implementation class
+ * Maintains state for the sorting process
+ */
+class TimsortImpl {
+    constructor(array, comparator, options) {
+        this.array = array;
+        this.comparator = comparator;
+        this.minGallop = MIN_GALLOP;
+        this.configuredMinRun = options.minRun;
+        this.runStack = [];
+        // Pre-allocate temporary buffer (reused across all merges)
+        const tmpSize = Math.floor(array.length / 2);
+        this.tmp = new Array(tmpSize);
+    }
+    /**
+     * Main sort entry point
+     */
+    sort() {
+        const n = this.array.length;
+        // Calculate optimal minRun (use configured value if provided)
+        const minRun = this.configuredMinRun ?? this.computeMinRun(n);
+        let lo = 0;
+        // Identify and sort runs
+        while (lo < n) {
+            // Find next run (either ascending or descending)
+            let runLen = this.countRunAndMakeAscending(lo);
+            // If run is too short, extend it with insertion sort
+            if (runLen < minRun) {
+                const force = Math.min(n - lo, minRun);
+                this.binaryInsertionSort(lo, lo + force, lo + runLen);
+                runLen = force;
+            }
+            // Push run onto stack and maybe merge
+            this.pushRun(lo, runLen);
+            this.mergeCollapse();
+            lo += runLen;
+        }
+        // Force merge all remaining runs
+        this.mergeForceCollapse();
+    }
+    /**
+     * Count length of run starting at lo and reverse if descending
+     * Returns length of run (at least 2 if array has 2+ elements)
+     */
+    countRunAndMakeAscending(lo) {
+        const n = this.array.length;
+        if (lo + 1 >= n) {
+            return 1;
+        }
+        let runHi = lo + 1;
+        // Check if descending
+        if (this.comparator(this.array[runHi], this.array[lo]) < 0) {
+            // Descending run - find end and reverse
+            runHi++;
+            while (runHi < n && this.comparator(this.array[runHi], this.array[runHi - 1]) < 0) {
+                runHi++;
+            }
+            this.reverseRange(lo, runHi);
+        }
+        else {
+            // Ascending run - find end
+            while (runHi < n && this.comparator(this.array[runHi], this.array[runHi - 1]) >= 0) {
+                runHi++;
+            }
+        }
+        return runHi - lo;
+    }
+    /**
+     * Reverse array[lo:hi]
+     */
+    reverseRange(lo, hi) {
+        hi--;
+        while (lo < hi) {
+            const temp = this.array[lo];
+            this.array[lo++] = this.array[hi];
+            this.array[hi--] = temp;
+        }
+    }
+    /**
+     * Binary insertion sort - more efficient than regular insertion sort
+     * Sorts array[lo:hi] where array[lo:start] is already sorted
+     */
+    binaryInsertionSort(lo, hi, start) {
+        if (start === lo) {
+            start++;
+        }
+        for (; start < hi; start++) {
+            const pivot = this.array[start];
+            // Binary search to find insertion point
+            let left = lo;
+            let right = start;
+            while (left < right) {
+                const mid = (left + right) >>> 1;
+                if (this.comparator(pivot, this.array[mid]) < 0) {
+                    right = mid;
+                }
+                else {
+                    left = mid + 1;
+                }
+            }
+            // Shift elements and insert
+            const n = start - left;
+            if (n > 0) {
+                for (let i = start; i > left; i--) {
+                    this.array[i] = this.array[i - 1];
+                }
+                this.array[left] = pivot;
+            }
+        }
+    }
+    /**
+     * Push a run onto the pending-run stack
+     */
+    pushRun(runBase, runLen) {
+        this.runStack.push({ start: runBase, length: runLen });
+    }
+    /**
+     * Merge runs to maintain stack invariants
+     *
+     * Invariants (from Python's timsort):
+     * 1. runLen[i - 2] > runLen[i - 1] + runLen[i]
+     * 2. runLen[i - 1] > runLen[i]
+     */
+    mergeCollapse() {
+        while (this.runStack.length > 1) {
+            let n = this.runStack.length - 2;
+            if ((n > 0 && this.runStack[n - 1].length <= this.runStack[n].length + this.runStack[n + 1].length) ||
+                (n > 1 && this.runStack[n - 2].length <= this.runStack[n - 1].length + this.runStack[n].length)) {
+                // Merge the smaller of the two pairs
+                if (this.runStack[n - 1].length < this.runStack[n + 1].length) {
+                    n--;
+                }
+                this.mergeAt(n);
+            }
+            else if (this.runStack[n].length <= this.runStack[n + 1].length) {
+                this.mergeAt(n);
+            }
+            else {
+                break; // Invariants are satisfied
+            }
+        }
+    }
+    /**
+     * Force merge all runs on the stack
+     */
+    mergeForceCollapse() {
+        while (this.runStack.length > 1) {
+            let n = this.runStack.length - 2;
+            if (n > 0 && this.runStack[n - 1].length < this.runStack[n + 1].length) {
+                n--;
+            }
+            this.mergeAt(n);
+        }
+    }
+    /**
+     * Merge the two runs at stack indices i and i+1
+     */
+    mergeAt(i) {
+        const run1 = this.runStack[i];
+        const run2 = this.runStack[i + 1];
+        // Merge run1 with run2
+        this.mergeRuns(run1.start, run1.length, run2.start, run2.length);
+        // Update stack
+        this.runStack[i] = { start: run1.start, length: run1.length + run2.length };
+        this.runStack.splice(i + 1, 1);
+    }
+    /**
+     * Merge two adjacent runs with galloping optimization
+     */
+    mergeRuns(base1, len1, base2, len2) {
+        // Optimization: Find where first element of run2 goes in run1
+        // Elements before that can be ignored
+        const k = this.gallopRight(this.array[base2], base1, len1, 0);
+        base1 += k;
+        len1 -= k;
+        if (len1 === 0) {
+            return;
+        }
+        // Optimization: Find where last element of run1 goes in run2
+        // Elements after that can be ignored
+        len2 = this.gallopLeft(this.array[base1 + len1 - 1], base2, len2, len2 - 1);
+        if (len2 === 0) {
+            return;
+        }
+        // Merge remaining runs, using tmp array for smaller run
+        if (len1 <= len2) {
+            this.mergeLo(base1, len1, base2, len2);
+        }
+        else {
+            this.mergeHi(base1, len1, base2, len2);
+        }
+    }
+    /**
+     * Merge with run1 in temporary array (run1 is smaller)
+     */
+    mergeLo(base1, len1, base2, len2) {
+        // Copy run1 to tmp
+        for (let i = 0; i < len1; i++) {
+            this.tmp[i] = this.array[base1 + i];
+        }
+        let cursor1 = 0; // Index in tmp
+        let cursor2 = base2; // Index in array
+        let dest = base1; // Index in array
+        // Move first element of run2
+        this.array[dest++] = this.array[cursor2++];
+        len2--;
+        if (len2 === 0) {
+            // Run2 exhausted, copy remaining tmp
+            for (let i = 0; i < len1; i++) {
+                this.array[dest + i] = this.tmp[cursor1 + i];
+            }
+            return;
+        }
+        if (len1 === 1) {
+            // Run1 has single element, copy run2 then the element
+            for (let i = 0; i < len2; i++) {
+                this.array[dest + i] = this.array[cursor2 + i];
+            }
+            this.array[dest + len2] = this.tmp[cursor1];
+            return;
+        }
+        let minGallop = this.minGallop;
+        outer: while (true) {
+            let count1 = 0; // Number of times run1 won in a row
+            let count2 = 0; // Number of times run2 won in a row
+            // Simple merge until one run starts "winning" consistently
+            do {
+                if (this.comparator(this.array[cursor2], this.tmp[cursor1]) < 0) {
+                    this.array[dest++] = this.array[cursor2++];
+                    count2++;
+                    count1 = 0;
+                    len2--;
+                    if (len2 === 0)
+                        break outer;
+                }
+                else {
+                    this.array[dest++] = this.tmp[cursor1++];
+                    count1++;
+                    count2 = 0;
+                    len1--;
+                    if (len1 === 1)
+                        break outer;
+                }
+            } while ((count1 | count2) < minGallop);
+            // One run is winning consistently - switch to galloping mode
+            do {
+                count1 = this.gallopRightInTmp(this.array[cursor2], cursor1, len1, 0);
+                if (count1 !== 0) {
+                    for (let i = 0; i < count1; i++) {
+                        this.array[dest++] = this.tmp[cursor1++];
+                    }
+                    len1 -= count1;
+                    if (len1 <= 1)
+                        break outer;
+                }
+                this.array[dest++] = this.array[cursor2++];
+                len2--;
+                if (len2 === 0)
+                    break outer;
+                count2 = this.gallopLeft(this.tmp[cursor1], cursor2, len2, 0);
+                if (count2 !== 0) {
+                    for (let i = 0; i < count2; i++) {
+                        this.array[dest++] = this.array[cursor2++];
+                    }
+                    len2 -= count2;
+                    if (len2 === 0)
+                        break outer;
+                }
+                this.array[dest++] = this.tmp[cursor1++];
+                len1--;
+                if (len1 === 1)
+                    break outer;
+                minGallop--;
+            } while (count1 >= MIN_GALLOP || count2 >= MIN_GALLOP);
+            if (minGallop < 0)
+                minGallop = 0;
+            minGallop += 2; // Penalize leaving gallop mode
+        }
+        this.minGallop = minGallop < 1 ? 1 : minGallop;
+        // Handle remaining elements
+        if (len1 === 1) {
+            for (let i = 0; i < len2; i++) {
+                this.array[dest + i] = this.array[cursor2 + i];
+            }
+            this.array[dest + len2] = this.tmp[cursor1];
+        }
+        else if (len1 > 0) {
+            for (let i = 0; i < len1; i++) {
+                this.array[dest + i] = this.tmp[cursor1 + i];
+            }
+        }
+    }
+    /**
+     * Merge with run2 in temporary array (run2 is smaller)
+     */
+    mergeHi(base1, len1, base2, len2) {
+        // Copy run2 to tmp
+        for (let i = 0; i < len2; i++) {
+            this.tmp[i] = this.array[base2 + i];
+        }
+        let cursor1 = base1 + len1 - 1; // Index in array (run1, from end)
+        let cursor2 = len2 - 1; // Index in tmp (from end)
+        let dest = base2 + len2 - 1; // Index in array (from end)
+        // Move last element of run1
+        this.array[dest--] = this.array[cursor1--];
+        len1--;
+        if (len1 === 0) {
+            // Run1 exhausted, copy remaining tmp
+            for (let i = 0; i < len2; i++) {
+                this.array[dest - len2 + 1 + i] = this.tmp[i];
+            }
+            return;
+        }
+        if (len2 === 1) {
+            // Run2 has single element
+            dest -= len1;
+            cursor1 -= len1;
+            for (let i = len1 - 1; i >= 0; i--) {
+                this.array[dest + 1 + i] = this.array[cursor1 + 1 + i];
+            }
+            this.array[dest] = this.tmp[cursor2];
+            return;
+        }
+        let minGallop = this.minGallop;
+        outer: while (true) {
+            let count1 = 0;
+            let count2 = 0;
+            do {
+                if (this.comparator(this.tmp[cursor2], this.array[cursor1]) < 0) {
+                    this.array[dest--] = this.array[cursor1--];
+                    count1++;
+                    count2 = 0;
+                    len1--;
+                    if (len1 === 0)
+                        break outer;
+                }
+                else {
+                    this.array[dest--] = this.tmp[cursor2--];
+                    count2++;
+                    count1 = 0;
+                    len2--;
+                    if (len2 === 1)
+                        break outer;
+                }
+            } while ((count1 | count2) < minGallop);
+            do {
+                count1 = len1 - this.gallopRight(this.tmp[cursor2], base1, len1, cursor1 - base1);
+                if (count1 !== 0) {
+                    dest -= count1;
+                    cursor1 -= count1;
+                    len1 -= count1;
+                    for (let i = count1 - 1; i >= 0; i--) {
+                        this.array[dest + 1 + i] = this.array[cursor1 + 1 + i];
+                    }
+                    if (len1 === 0)
+                        break outer;
+                }
+                this.array[dest--] = this.tmp[cursor2--];
+                len2--;
+                if (len2 === 1)
+                    break outer;
+                count2 = len2 - this.gallopLeftInTmp(this.array[cursor1], 0, len2, cursor2);
+                if (count2 !== 0) {
+                    dest -= count2;
+                    cursor2 -= count2;
+                    len2 -= count2;
+                    for (let i = 0; i < count2; i++) {
+                        this.array[dest + 1 + i] = this.tmp[cursor2 + 1 + i];
+                    }
+                    if (len2 <= 1)
+                        break outer;
+                }
+                this.array[dest--] = this.array[cursor1--];
+                len1--;
+                if (len1 === 0)
+                    break outer;
+                minGallop--;
+            } while (count1 >= MIN_GALLOP || count2 >= MIN_GALLOP);
+            if (minGallop < 0)
+                minGallop = 0;
+            minGallop += 2;
+        }
+        this.minGallop = minGallop < 1 ? 1 : minGallop;
+        if (len2 === 1) {
+            dest -= len1;
+            cursor1 -= len1;
+            for (let i = len1 - 1; i >= 0; i--) {
+                this.array[dest + 1 + i] = this.array[cursor1 + 1 + i];
+            }
+            this.array[dest] = this.tmp[cursor2];
+        }
+        else if (len2 > 0) {
+            for (let i = 0; i < len2; i++) {
+                this.array[dest - len2 + 1 + i] = this.tmp[i];
+            }
+        }
+    }
+    /**
+     * Gallop right: Find position where key belongs in array[base:base+len]
+     * Returns offset k where array[base+k-1] < key <= array[base+k]
+     * Uses exponential search followed by binary search
+     */
+    gallopRight(key, base, len, hint) {
+        let lastOfs = 0;
+        let ofs = 1;
+        if (this.comparator(key, this.array[base + hint]) < 0) {
+            // Gallop left until array[base+hint-ofs] < key <= array[base+hint-lastOfs]
+            const maxOfs = hint + 1;
+            while (ofs < maxOfs && this.comparator(key, this.array[base + hint - ofs]) < 0) {
+                lastOfs = ofs;
+                ofs = (ofs << 1) + 1;
+                if (ofs <= 0)
+                    ofs = maxOfs; // Overflow
+            }
+            if (ofs > maxOfs)
+                ofs = maxOfs;
+            // Make offsets relative to base
+            const tmp = lastOfs;
+            lastOfs = hint - ofs;
+            ofs = hint - tmp;
+        }
+        else {
+            // Gallop right until array[base+hint+lastOfs] < key <= array[base+hint+ofs]
+            const maxOfs = len - hint;
+            while (ofs < maxOfs && this.comparator(key, this.array[base + hint + ofs]) >= 0) {
+                lastOfs = ofs;
+                ofs = (ofs << 1) + 1;
+                if (ofs <= 0)
+                    ofs = maxOfs;
+            }
+            if (ofs > maxOfs)
+                ofs = maxOfs;
+            // Make offsets relative to base
+            lastOfs += hint;
+            ofs += hint;
+        }
+        // Binary search in array[base+lastOfs:base+ofs]
+        lastOfs++;
+        while (lastOfs < ofs) {
+            const m = lastOfs + ((ofs - lastOfs) >>> 1);
+            if (this.comparator(key, this.array[base + m]) < 0) {
+                ofs = m;
+            }
+            else {
+                lastOfs = m + 1;
+            }
+        }
+        return ofs;
+    }
+    /**
+     * Gallop left: Like gallopRight, but finds position where key < array[base+k]
+     */
+    gallopLeft(key, base, len, hint) {
+        let lastOfs = 0;
+        let ofs = 1;
+        if (this.comparator(key, this.array[base + hint]) > 0) {
+            const maxOfs = len - hint;
+            while (ofs < maxOfs && this.comparator(key, this.array[base + hint + ofs]) > 0) {
+                lastOfs = ofs;
+                ofs = (ofs << 1) + 1;
+                if (ofs <= 0)
+                    ofs = maxOfs;
+            }
+            if (ofs > maxOfs)
+                ofs = maxOfs;
+            lastOfs += hint;
+            ofs += hint;
+        }
+        else {
+            const maxOfs = hint + 1;
+            while (ofs < maxOfs && this.comparator(key, this.array[base + hint - ofs]) <= 0) {
+                lastOfs = ofs;
+                ofs = (ofs << 1) + 1;
+                if (ofs <= 0)
+                    ofs = maxOfs;
+            }
+            if (ofs > maxOfs)
+                ofs = maxOfs;
+            const tmp = lastOfs;
+            lastOfs = hint - ofs;
+            ofs = hint - tmp;
+        }
+        lastOfs++;
+        while (lastOfs < ofs) {
+            const m = lastOfs + ((ofs - lastOfs) >>> 1);
+            if (this.comparator(key, this.array[base + m]) > 0) {
+                lastOfs = m + 1;
+            }
+            else {
+                ofs = m;
+            }
+        }
+        return ofs;
+    }
+    /**
+     * Gallop right in tmp array: Find position where key belongs in tmp[base:base+len]
+     */
+    gallopRightInTmp(key, base, len, hint) {
+        let lastOfs = 0;
+        let ofs = 1;
+        if (this.comparator(key, this.tmp[base + hint]) < 0) {
+            const maxOfs = hint + 1;
+            while (ofs < maxOfs && this.comparator(key, this.tmp[base + hint - ofs]) < 0) {
+                lastOfs = ofs;
+                ofs = (ofs << 1) + 1;
+                if (ofs <= 0)
+                    ofs = maxOfs;
+            }
+            if (ofs > maxOfs)
+                ofs = maxOfs;
+            const tmp = lastOfs;
+            lastOfs = hint - ofs;
+            ofs = hint - tmp;
+        }
+        else {
+            const maxOfs = len - hint;
+            while (ofs < maxOfs && this.comparator(key, this.tmp[base + hint + ofs]) >= 0) {
+                lastOfs = ofs;
+                ofs = (ofs << 1) + 1;
+                if (ofs <= 0)
+                    ofs = maxOfs;
+            }
+            if (ofs > maxOfs)
+                ofs = maxOfs;
+            lastOfs += hint;
+            ofs += hint;
+        }
+        lastOfs++;
+        while (lastOfs < ofs) {
+            const m = lastOfs + ((ofs - lastOfs) >>> 1);
+            if (this.comparator(key, this.tmp[base + m]) < 0) {
+                ofs = m;
+            }
+            else {
+                lastOfs = m + 1;
+            }
+        }
+        return ofs;
+    }
+    /**
+     * Gallop left in tmp array
+     */
+    gallopLeftInTmp(key, base, len, hint) {
+        let lastOfs = 0;
+        let ofs = 1;
+        if (this.comparator(key, this.tmp[base + hint]) > 0) {
+            const maxOfs = len - hint;
+            while (ofs < maxOfs && this.comparator(key, this.tmp[base + hint + ofs]) > 0) {
+                lastOfs = ofs;
+                ofs = (ofs << 1) + 1;
+                if (ofs <= 0)
+                    ofs = maxOfs;
+            }
+            if (ofs > maxOfs)
+                ofs = maxOfs;
+            lastOfs += hint;
+            ofs += hint;
+        }
+        else {
+            const maxOfs = hint + 1;
+            while (ofs < maxOfs && this.comparator(key, this.tmp[base + hint - ofs]) <= 0) {
+                lastOfs = ofs;
+                ofs = (ofs << 1) + 1;
+                if (ofs <= 0)
+                    ofs = maxOfs;
+            }
+            if (ofs > maxOfs)
+                ofs = maxOfs;
+            const tmp = lastOfs;
+            lastOfs = hint - ofs;
+            ofs = hint - tmp;
+        }
+        lastOfs++;
+        while (lastOfs < ofs) {
+            const m = lastOfs + ((ofs - lastOfs) >>> 1);
+            if (this.comparator(key, this.tmp[base + m]) > 0) {
+                lastOfs = m + 1;
+            }
+            else {
+                ofs = m;
+            }
+        }
+        return ofs;
+    }
+    /**
+     * Compute optimal minRun value
+     * Returns a value in range [32, 64] such that n/minRun is close to a power of 2
+     */
+    computeMinRun(n) {
+        let r = 0;
+        while (n >= MIN_MERGE) {
+            r |= n & 1;
+            n >>= 1;
+        }
+        return n + r;
+    }
+}
+
 /**
  * @fileoverview Timing utilities for performance optimization
  * @module @zengrid/shared/utils/timing
@@ -6208,6 +7344,7 @@ const VERSION = '0.1.0';
 
 exports.Aggregations = Aggregations;
 exports.BaseCoordinator = BaseCoordinator;
+exports.BloomFilter = BloomFilter;
 exports.ColumnStore = ColumnStore;
 exports.CommandStack = CommandStack;
 exports.DependencyGraph = DependencyGraph;
@@ -6238,13 +7375,20 @@ exports.Subject = Subject;
 exports.SuffixArray = SuffixArray;
 exports.Trie = Trie;
 exports.VERSION = VERSION;
+exports.autofill = autofill;
 exports.binarySearch = binarySearch;
 exports.binarySearchLeft = binarySearchLeft;
 exports.binarySearchRight = binarySearchRight;
 exports.createRAFBatchScheduler = createRAFBatchScheduler;
 exports.debounce = debounce;
 exports.delay = delay;
+exports.detectSequence = detectSequence;
+exports.generateSequence = generateSequence;
+exports.numericComparator = numericComparator;
 exports.resolveOperationMode = resolveOperationMode;
 exports.skipListDefaultComparator = defaultComparator;
+exports.stringComparator = stringComparator;
 exports.throttle = throttle;
 exports.timeout = timeout;
+exports.timsort = timsort;
+exports.timsortIndices = timsortIndices;