binary-tree-typed 2.5.2 → 2.6.0

package/dist/types/data-structures/binary-tree/tree-multi-map.d.ts

@@ -209,14 +209,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Check if empty
-   *  console.log(new TreeMultiMap().isEmpty()); // true;
-     */
-    isEmpty(): boolean;
-    /**
-     * Removes all entries from the map.
-     * @remarks Time O(1), Space O(1)
      
      
      
@@ -252,6 +244,32 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Check if empty
+   *  console.log(new TreeMultiMap().isEmpty()); // true;
+     */
+    isEmpty(): boolean;
+    /**
+     * Removes all entries from the map.
+     * @remarks Time O(1), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -375,17 +393,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Remove all entries
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.clear();
-   *       console.log(mm.isEmpty()); // true;
-     */
-    clear(): void;
-    /**
-     * Bucket length for a key (missing => 0).
-     * @remarks Time O(log n), Space O(1)
      
      
      
@@ -412,17 +419,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Count values for key
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(1, 'b');
-   *       console.log(mm.count(1)); // 2;
-     */
-    count(key: K): number;
-    /**
-     * Total number of values across all buckets (Σ bucket.length).
-     * @remarks Time O(n), Space O(1)
      
      
      
@@ -450,16 +446,15 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
       * @example
-   * // Total number of values
+   * // Remove all entries
    *  const mm = new TreeMultiMap<number, string>();
    *       mm.add(1, 'a');
-   *       mm.add(1, 'b');
-   *       mm.add(2, 'c');
-   *       console.log(mm.totalSize); // 3;
+   *       mm.clear();
+   *       console.log(mm.isEmpty()); // true;
      */
-    get totalSize(): number;
+    clear(): void;
     /**
-     * Whether the map contains the given key.
+     * Bucket length for a key (missing => 0).
      * @remarks Time O(log n), Space O(1)
      
      
@@ -494,6 +489,17 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Count values for key
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(1, 'b');
+   *       console.log(mm.count(1)); // 2;
+     */
+    count(key: K): number;
+    /**
+     * Total number of values across all buckets (Σ bucket.length).
+     * @remarks Time O(n), Space O(1)
      
      
      
@@ -527,6 +533,18 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Total number of values
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(1, 'b');
+   *       mm.add(2, 'c');
+   *       console.log(mm.totalSize); // 3;
+     */
+    get totalSize(): number;
+    /**
+     * Whether the map contains the given key.
+     * @remarks Time O(log n), Space O(1)
      
      
      
@@ -657,19 +675,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Check key existence
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       console.log(mm.has(1)); // true;
-   *       console.log(mm.has(2)); // false;
-     */
-    has(key: K): boolean;
-    /**
-     * Live bucket reference (do not auto-delete key if bucket becomes empty via mutation).
-     * @remarks Time O(log n), Space O(1)
-     
-     
      
      
      
@@ -778,6 +783,17 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Check key existence
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       console.log(mm.has(1)); // true;
+   *       console.log(mm.has(2)); // false;
+     */
+    has(key: K): boolean;
+    /**
+     * Live bucket reference (do not auto-delete key if bucket becomes empty via mutation).
+     * @remarks Time O(log n), Space O(1)
      
      
      
@@ -864,17 +880,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Get values for key
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(1, 'b');
-   *       console.log(mm.get(1)); // ['a', 'b'];
-     */
-    get(key: K): V[] | undefined;
-    /**
-     * Append a single value.
-     * @remarks Time O(log n), Space O(1)
      
      
      
@@ -1028,24 +1033,16 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
       * @example
-   * // Add key-value pair
+   * // Get values for key
    *  const mm = new TreeMultiMap<number, string>();
    *       mm.add(1, 'a');
    *       mm.add(1, 'b');
-   *       mm.add(2, 'c');
    *       console.log(mm.get(1)); // ['a', 'b'];
      */
-    add(key: K, value: V): boolean;
+    get(key: K): V[] | undefined;
     /**
-     * Alias for compatibility with existing TreeMultiMap semantics.
-     * @remarks Time O(log n), Space O(1) for single value; O(log n + m) for bucket append
-     
-     
-     
-     
-     
-     
-     
+     * Append a single value.
+     * @remarks Time O(log n), Space O(1)
      
      
      
@@ -1234,19 +1231,17 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
       * @example
-   * // Set values for key
+   * // Add key-value pair
    *  const mm = new TreeMultiMap<number, string>();
-   *       mm.set(1, 'a');
-   *       mm.set(1, 'b');
+   *       mm.add(1, 'a');
+   *       mm.add(1, 'b');
+   *       mm.add(2, 'c');
    *       console.log(mm.get(1)); // ['a', 'b'];
      */
-    set(entry: [K | null | undefined, V[] | undefined] | K | null | undefined, value?: V): boolean;
-    set(key: K, value: V): boolean;
+    add(key: K, value: V): boolean;
     /**
-     * Deletes a key and its entire bucket.
-     * @remarks Time O(log n), Space O(1)
-     
-     
+     * Alias for compatibility with existing TreeMultiMap semantics.
+     * @remarks Time O(log n), Space O(1) for single value; O(log n + m) for bucket append
      
      
      
@@ -1441,18 +1436,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Remove key
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(2, 'b');
-   *       mm.delete(1);
-   *       console.log(mm.has(1)); // false;
-     */
-    delete(key: K): boolean;
-    /**
-     * Check if a specific value exists in a key's bucket.
-     * @remarks Time O(log n + m), Space O(1) where m is bucket size
      
      
      
@@ -1479,17 +1462,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Check specific key-value
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       console.log(mm.hasEntry(1, 'a')); // true;
-   *       console.log(mm.hasEntry(1, 'z')); // false;
-     */
-    hasEntry(key: K, value: V, eq?: (a: V, b: V) => boolean): boolean;
-    /**
-     * Delete a single occurrence of a value from a key's bucket.
-     * @remarks Time O(log n + m), Space O(1) where m is bucket size
      
      
      
@@ -1506,6 +1478,18 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Set values for key
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.set(1, 'a');
+   *       mm.set(1, 'b');
+   *       console.log(mm.get(1)); // ['a', 'b'];
+     */
+    set(entry: [K | null | undefined, V[] | undefined] | K | null | undefined, value?: V): boolean;
+    set(key: K, value: V): boolean;
+    /**
+     * Deletes a key and its entire bucket.
+     * @remarks Time O(log n), Space O(1)
      
      
      
@@ -1516,18 +1500,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Delete specific value
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(1, 'b');
-   *       mm.deleteValue(1, 'a');
-   *       console.log(mm.get(1)); // ['b'];
-     */
-    deleteValue(key: K, value: V, eq?: (a: V, b: V) => boolean): boolean;
-    /**
-     * Delete all occurrences of a value from a key's bucket.
-     * @remarks Time O(log n + m), Space O(1) where m is bucket size
      
      
      
@@ -1554,24 +1526,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Delete all matching values
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(1, 'a');
-   *       mm.add(1, 'b');
-   *       const count = mm.deleteValues(1, 'a');
-   *       console.log(count); // 2;
-     */
-    deleteValues(key: K, value: V, eq?: (a: V, b: V) => boolean): number;
-    /**
-     * Iterates over all entries as [key, bucket] pairs.
-     * @remarks Time O(n), Space O(1)
-     */
-    [Symbol.iterator](): Iterator<[K, V[]]>;
-    /**
-     * Iterates over all keys.
-     * @remarks Time O(n), Space O(1)
      
      
      
@@ -1730,17 +1684,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Iterate keys
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(3, 'c');
-   *       mm.add(1, 'a');
-   *       console.log([...mm.keys()]); // [1, 3];
-     */
-    keys(): IterableIterator<K>;
-    /**
-     * Iterates over all buckets.
-     * @remarks Time O(n), Space O(1)
      
      
      
@@ -1785,6 +1728,18 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Remove key
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(2, 'b');
+   *       mm.delete(1);
+   *       console.log(mm.has(1)); // false;
+     */
+    delete(key: K): boolean;
+    /**
+     * Check if a specific value exists in a key's bucket.
+     * @remarks Time O(log n + m), Space O(1) where m is bucket size
      
      
      
@@ -1818,6 +1773,17 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Check specific key-value
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       console.log(mm.hasEntry(1, 'a')); // true;
+   *       console.log(mm.hasEntry(1, 'z')); // false;
+     */
+    hasEntry(key: K, value: V, eq?: (a: V, b: V) => boolean): boolean;
+    /**
+     * Delete a single occurrence of a value from a key's bucket.
+     * @remarks Time O(log n + m), Space O(1) where m is bucket size
      
      
      
@@ -1848,6 +1814,823 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+     
+     
+     
+      * @example
+   * // Delete specific value
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(1, 'b');
+   *       mm.deleteValue(1, 'a');
+   *       console.log(mm.get(1)); // ['b'];
+     */
+    deleteValue(key: K, value: V, eq?: (a: V, b: V) => boolean): boolean;
+    /**
+     * Delete all occurrences of a value from a key's bucket.
+     * @remarks Time O(log n + m), Space O(1) where m is bucket size
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Delete all matching values
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(1, 'a');
+   *       mm.add(1, 'b');
+   *       const count = mm.deleteValues(1, 'a');
+   *       console.log(count); // 2;
+     */
+    deleteValues(key: K, value: V, eq?: (a: V, b: V) => boolean): number;
+    /**
+     * Iterates over all entries as [key, bucket] pairs.
+     * @remarks Time O(n), Space O(1)
+     */
+    [Symbol.iterator](): Iterator<[K, V[]]>;
+    /**
+     * Iterates over all keys.
+     * @remarks Time O(n), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Iterate keys
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(3, 'c');
+   *       mm.add(1, 'a');
+   *       console.log([...mm.keys()]); // [1, 3];
+     */
+    keys(): IterableIterator<K>;
+    /**
+     * Iterates over all buckets.
+     * @remarks Time O(n), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Iterate value arrays
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(1, 'b');
+   *       console.log([...mm.values()]); // [['a', 'b']];
+     */
+    values(): IterableIterator<V[]>;
+    /**
+     * Iterate over all `[key, values[]]` entries (Map-compatible).
+     * @remarks Time O(n), Space O(1) per step.
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Iterate over entries
+   *  const mm = new TreeMultiMap<number, string>();
+   *     mm.set(1, 'a');
+   *     mm.set(1, 'b');
+   *     mm.set(2, 'c');
+   *     console.log([...mm.entries()]); // [
+   *  //      [1, ['a', 'b']],
+   *  //      [2, ['c']]
+   *  //    ];
+     */
+    entries(): IterableIterator<[K, V[]]>;
+    /**
+     * Iterates over all entries for a specific key.
+     * @remarks Time O(log n + m), Space O(1) where m is bucket size
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Get entries for key
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(1, 'b');
+   *       console.log([...mm.entriesOf(1)]); // [[1, 'a'], [1, 'b']];
+     */
+    entriesOf(key: K): IterableIterator<[K, V]>;
+    /**
+     * Iterates over all values for a specific key.
+     * @remarks Time O(log n + m), Space O(1) where m is bucket size
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Get flat values for key
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(1, 'b');
+   *       console.log([...mm.valuesOf(1)]); // ['a', 'b'];
+     */
+    valuesOf(key: K): IterableIterator<V>;
+    /**
+     * Iterates over all [key, value] pairs (flattened from buckets).
+     * @remarks Time O(T), Space O(1) where T is totalSize
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // All key-value pairs flattened
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(1, 'b');
+   *       mm.add(2, 'c');
+   *       console.log([...mm.flatEntries()]); // [[1, 'a'], [1, 'b'], [2, 'c']];
+     */
+    flatEntries(): IterableIterator<[K, V]>;
+    /**
+     * Returns the entry with the smallest key.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // First entry
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(3, 'c');
+   *       mm.add(1, 'a');
+   *       console.log(mm.first()?.[0]); // 1;
+     */
+    first(): [K, V[]] | undefined;
+    /**
+     * Returns the entry with the largest key.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Last entry
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(3, 'c');
+   *       console.log(mm.last()?.[0]); // 3;
+     */
+    last(): [K, V[]] | undefined;
+    /**
+     * Removes and returns the entry with the smallest key.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -1869,6 +2652,23 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Remove and return first
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(2, 'b');
+   *       mm.add(1, 'a');
+   *       const first = mm.pollFirst();
+   *       console.log(first?.[0]); // 1;
+   *       console.log(mm.has(1)); // false;
+     */
+    pollFirst(): [K, V[]] | undefined;
+    /**
+     * Removes and returns the entry with the largest key.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
      
      
      
@@ -1900,16 +2700,74 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
       * @example
-   * // Iterate value arrays
+   * // Remove and return last
    *  const mm = new TreeMultiMap<number, string>();
    *       mm.add(1, 'a');
-   *       mm.add(1, 'b');
-   *       console.log([...mm.values()]); // [['a', 'b']];
+   *       mm.add(3, 'c');
+   *       const last = mm.pollLast();
+   *       console.log(last?.[0]); // 3;
      */
-    values(): IterableIterator<V[]>;
+    pollLast(): [K, V[]] | undefined;
     /**
-     * Iterates over all entries for a specific key.
-     * @remarks Time O(log n + m), Space O(1) where m is bucket size
+     * Returns the entry with the smallest key >= given key.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -1936,17 +2794,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Get entries for key
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(1, 'b');
-   *       console.log([...mm.entriesOf(1)]); // [[1, 'a'], [1, 'b']];
-     */
-    entriesOf(key: K): IterableIterator<[K, V]>;
-    /**
-     * Iterates over all values for a specific key.
-     * @remarks Time O(log n + m), Space O(1) where m is bucket size
      
      
      
@@ -1973,17 +2820,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Get flat values for key
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(1, 'b');
-   *       console.log([...mm.valuesOf(1)]); // ['a', 'b'];
-     */
-    valuesOf(key: K): IterableIterator<V>;
-    /**
-     * Iterates over all [key, value] pairs (flattened from buckets).
-     * @remarks Time O(T), Space O(1) where T is totalSize
      
      
      
@@ -2010,19 +2846,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // All key-value pairs flattened
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(1, 'b');
-   *       mm.add(2, 'c');
-   *       console.log([...mm.flatEntries()]); // [[1, 'a'], [1, 'b'], [2, 'c']];
-     */
-    flatEntries(): IterableIterator<[K, V]>;
-    /**
-     * Returns the entry with the smallest key.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
      
@@ -2085,15 +2908,16 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
       * @example
-   * // First entry
+   * // Least key ≥ target
    *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(3, 'c');
-   *       mm.add(1, 'a');
-   *       console.log(mm.first()?.[0]); // 1;
+   *       mm.add(10, 'a');
+   *       mm.add(20, 'b');
+   *       mm.add(30, 'c');
+   *       console.log(mm.ceiling(15)?.[0]); // 20;
      */
-    first(): [K, V[]] | undefined;
+    ceiling(key: K): [K, V[]] | undefined;
     /**
-     * Returns the entry with the largest key.
+     * Returns the entry with the largest key <= given key.
      * @remarks Time O(log n), Space O(1)
     
      
@@ -2157,18 +2981,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Last entry
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(3, 'c');
-   *       console.log(mm.last()?.[0]); // 3;
-     */
-    last(): [K, V[]] | undefined;
-    /**
-     * Removes and returns the entry with the smallest key.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
      
@@ -2195,20 +3007,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Remove and return first
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(2, 'b');
-   *       mm.add(1, 'a');
-   *       const first = mm.pollFirst();
-   *       console.log(first?.[0]); // 1;
-   *       console.log(mm.has(1)); // false;
-     */
-    pollFirst(): [K, V[]] | undefined;
-    /**
-     * Removes and returns the entry with the largest key.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
      
@@ -2235,19 +3033,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Remove and return last
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(3, 'c');
-   *       const last = mm.pollLast();
-   *       console.log(last?.[0]); // 3;
-     */
-    pollLast(): [K, V[]] | undefined;
-    /**
-     * Returns the entry with the smallest key >= given key.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
      
@@ -2309,6 +3094,94 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Greatest key ≤ target
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(10, 'a');
+   *       mm.add(20, 'b');
+   *       mm.add(30, 'c');
+   *       console.log(mm.floor(25)?.[0]); // 20;
+     */
+    floor(key: K): [K, V[]] | undefined;
+    /**
+     * Returns the entry with the smallest key > given key.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -2409,16 +3282,15 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
       * @example
-   * // Least key ≥ target
+   * // Least key > target
    *  const mm = new TreeMultiMap<number, string>();
    *       mm.add(10, 'a');
    *       mm.add(20, 'b');
-   *       mm.add(30, 'c');
-   *       console.log(mm.ceiling(15)?.[0]); // 20;
+   *       console.log(mm.higher(10)?.[0]); // 20;
      */
-    ceiling(key: K): [K, V[]] | undefined;
+    higher(key: K): [K, V[]] | undefined;
     /**
-     * Returns the entry with the largest key <= given key.
+     * Returns the entry with the largest key < given key.
      * @remarks Time O(log n), Space O(1)
     
      
@@ -2566,13 +3438,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-     
-     
-     
-     
-     
-     
-     
      
      
      
@@ -2582,30 +3447,16 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
       * @example
-   * // Greatest key ≤ target
+   * // Greatest key < target
    *  const mm = new TreeMultiMap<number, string>();
    *       mm.add(10, 'a');
    *       mm.add(20, 'b');
-   *       mm.add(30, 'c');
-   *       console.log(mm.floor(25)?.[0]); // 20;
+   *       console.log(mm.lower(20)?.[0]); // 10;
      */
-    floor(key: K): [K, V[]] | undefined;
+    lower(key: K): [K, V[]] | undefined;
     /**
-     * Returns the entry with the smallest key > given key.
-     * @remarks Time O(log n), Space O(1)
-    
-     
-     
-     
-     
-     
-     
-     
-     
-     
-     
-     
-     
+     * Prints the internal tree structure (for debugging).
+     * @remarks Time O(n), Space O(n)
      
      
      
@@ -2719,18 +3570,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Least key > target
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(10, 'a');
-   *       mm.add(20, 'b');
-   *       console.log(mm.higher(10)?.[0]); // 20;
-     */
-    higher(key: K): [K, V[]] | undefined;
-    /**
-     * Returns the entry with the largest key < given key.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
      
@@ -2811,6 +3650,16 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Display tree
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       expect(() => mm.print()).not.toThrow();
+     */
+    print(): void;
+    /**
+     * Executes a callback for each entry.
+     * @remarks Time O(n), Space O(1)
      
      
      
@@ -2856,17 +3705,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Greatest key < target
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(10, 'a');
-   *       mm.add(20, 'b');
-   *       console.log(mm.lower(20)?.[0]); // 10;
-     */
-    lower(key: K): [K, V[]] | undefined;
-    /**
-     * Prints the internal tree structure (for debugging).
-     * @remarks Time O(n), Space O(n)
      
      
      
@@ -3015,6 +3853,19 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Iterate entries
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(2, 'b');
+   *       const keys: number[] = [];
+   *       mm.forEach((v, k) => keys.push(k));
+   *       console.log(keys); // [1, 2];
+     */
+    forEach(callback: (value: V[], key: K, map: this) => void): void;
+    /**
+     * Creates a new map with entries that pass the predicate.
+     * @remarks Time O(n), Space O(n)
      
      
      
@@ -3025,16 +3876,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Display tree
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       expect(() => mm.print()).not.toThrow();
-     */
-    print(): void;
-    /**
-     * Executes a callback for each entry.
-     * @remarks Time O(n), Space O(1)
      
      
      
@@ -3193,19 +4034,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Iterate entries
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(2, 'b');
-   *       const keys: number[] = [];
-   *       mm.forEach((v, k) => keys.push(k));
-   *       console.log(keys); // [1, 2];
-     */
-    forEach(callback: (value: V[], key: K, map: this) => void): void;
-    /**
-     * Creates a new map with entries that pass the predicate.
-     * @remarks Time O(n), Space O(n)
      
      
      
@@ -3231,6 +4059,19 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Filter entries
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       mm.add(2, 'b');
+   *       mm.add(3, 'c');
+   *       const filtered = mm.filter((v, k) => k > 1);
+   *       console.log([...filtered.keys()]); // [2, 3];
+     */
+    filter(predicate: (value: V[], key: K, map: this) => boolean): TreeMultiMap<K, V, R>;
+    /**
+     * Creates a new map by transforming each entry.
+     * @remarks Time O(n log n), Space O(n)
      
      
      
@@ -3364,19 +4205,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Filter entries
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       mm.add(2, 'b');
-   *       mm.add(3, 'c');
-   *       const filtered = mm.filter((v, k) => k > 1);
-   *       console.log([...filtered.keys()]); // [2, 3];
-     */
-    filter(predicate: (value: V[], key: K, map: this) => boolean): TreeMultiMap<K, V, R>;
-    /**
-     * Creates a new map by transforming each entry.
-     * @remarks Time O(n log n), Space O(n)
      
      
      
@@ -3437,6 +4265,17 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Transform values
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       const mapped = mm.map((v, k) => [k, v.map(s => s.toUpperCase())] as [number, string[]]);
+   *       console.log(mapped.get(1)); // ['A'];
+     */
+    map<V2>(mapper: (value: V[], key: K, map: this) => [K, V2[]]): TreeMultiMap<K, V2, R>;
+    /**
+     * Reduces all entries to a single value.
+     * @remarks Time O(n), Space O(1)
      
      
      
@@ -3535,17 +4374,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Transform values
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       const mapped = mm.map((v, k) => [k, v.map(s => s.toUpperCase())] as [number, string[]]);
-   *       console.log(mapped.get(1)); // ['A'];
-     */
-    map<V2>(mapper: (value: V[], key: K, map: this) => [K, V2[]]): TreeMultiMap<K, V2, R>;
-    /**
-     * Reduces all entries to a single value.
-     * @remarks Time O(n), Space O(1)
      
      
      
@@ -3641,6 +4469,18 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Aggregate
+   *  const mm = new TreeMultiMap<number, number>();
+   *       mm.add(1, 10);
+   *       mm.add(2, 20);
+   *       const sum = mm.reduce((acc, v) => acc + v.reduce((a, b) => a + b, 0), 0);
+   *       console.log(sum); // 30;
+     */
+    reduce<U>(callback: (accumulator: U, value: V[], key: K, map: this) => U, initialValue: U): U;
+    /**
+     * Sets multiple entries at once.
+     * @remarks Time O(m log n), Space O(m) where m is input size
      
      
      
@@ -3704,18 +4544,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Aggregate
-   *  const mm = new TreeMultiMap<number, number>();
-   *       mm.add(1, 10);
-   *       mm.add(2, 20);
-   *       const sum = mm.reduce((acc, v) => acc + v.reduce((a, b) => a + b, 0), 0);
-   *       console.log(sum); // 30;
-     */
-    reduce<U>(callback: (accumulator: U, value: V[], key: K, map: this) => U, initialValue: U): U;
-    /**
-     * Sets multiple entries at once.
-     * @remarks Time O(m log n), Space O(m) where m is input size
      
      
      
@@ -3838,6 +4666,16 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
+      * @example
+   * // Set multiple entries
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.setMany([[1, ['a']], [2, ['b']]]);
+   *       console.log(mm.size); // 2;
+     */
+    setMany(keysNodesEntriesOrRaws: Iterable<K | [K | null | undefined, V[] | undefined]>): boolean[];
+    /**
+     * Searches for entries within a key range.
+     * @remarks Time O(log n + k), Space O(k) where k is result size
      
      
      
@@ -3866,16 +4704,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Set multiple entries
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.setMany([[1, ['a']], [2, ['b']]]);
-   *       console.log(mm.size); // 2;
-     */
-    setMany(keysNodesEntriesOrRaws: Iterable<K | [K | null | undefined, V[] | undefined]>): boolean[];
-    /**
-     * Searches for entries within a key range.
-     * @remarks Time O(log n + k), Space O(k) where k is result size
      
      
      
@@ -4196,8 +5024,22 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
     /**
    * Get elements by rank range
   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
- * // Pagination with rangeByRank
+ * // Pagination by position in tree order
  *  const tree = new TreeMultiMap<number>(
  *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
  *         { enableOrderStatistic: true }
@@ -4218,6 +5060,41 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Deep clone
  *  const mm = new TreeMultiMap<number, string>();