max-priority-queue-typed 2.5.0 → 2.5.1

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

@@ -45,6 +45,27 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      * @remarks Time O(1), Space O(1)
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Unique key count
    *  const ms = new TreeMultiSet<number>();
@@ -73,6 +94,111 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -143,30 +269,8 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Check existence
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1);
-   *       console.log(ms.has(1)); // true;
-   *       console.log(ms.has(2)); // false;
-     */
-    has(key: K): boolean;
-    /**
-     * Returns the count of occurrences for the given key.
-     * @remarks Time O(log n), Space O(1)
      
      
-      * @example
-   * // Get occurrence count
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 5);
-   *       console.log(ms.count(1)); // 5;
-     */
-    count(key: K): number;
-    /**
-     * Add `n` occurrences of `key`.
-     * @returns True if the multiset changed.
-     * @remarks Time O(log n), Space O(1)
      
      
      
@@ -199,33 +303,8 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Add elements
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1);
-   *       ms.add(1);
-   *       ms.add(2);
-   *       console.log(ms.count(1)); // 2;
-   *       console.log(ms.size); // 3;
-     */
-    add(key: K, n?: number): boolean;
-    /**
-     * Set count for `key` to exactly `n`.
-     * @returns True if changed.
-     * @remarks Time O(log n), Space O(1)
      
      
-      * @example
-   * // Set occurrence count
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.setCount(1, 3);
-   *       console.log(ms.count(1)); // 3;
-     */
-    setCount(key: K, n: number): boolean;
-    /**
-     * Delete `n` occurrences of `key` (default 1).
-     * @returns True if any occurrence was removed.
-     * @remarks Time O(log n), Space O(1)
      
      
      
@@ -267,44 +346,10 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Remove one occurrence
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 3);
-   *       ms.delete(1);
-   *       console.log(ms.count(1)); // 2;
-     */
-    delete(key: K, n?: number): boolean;
-    /**
-     * Delete all occurrences of the given key.
-     * @returns True if any occurrence was removed.
-     * @remarks Time O(log n), Space O(1)
      
      
-      * @example
-   * // Remove all occurrences
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 3);
-   *       ms.deleteAll(1);
-   *       console.log(ms.has(1)); // false;
-     */
-    deleteAll(key: K): boolean;
-    /**
-     * Iterates over distinct keys (each key yielded once).
-     * @remarks Time O(n), Space O(1)
      
      
-      * @example
-   * // Iterate unique keys
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 2);
-   *       ms.add(2);
-   *       console.log([...ms.keysDistinct()]); // [1, 2];
-     */
-    keysDistinct(): IterableIterator<K>;
-    /**
-     * Iterates over entries as [key, count] pairs.
-     * @remarks Time O(n), Space O(1)
      
      
      
@@ -322,6 +367,26 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Check existence
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1);
+   *       console.log(ms.has(1)); // true;
+   *       console.log(ms.has(2)); // false;
+     */
+    has(key: K): boolean;
+    /**
+     * Returns the count of occurrences for the given key.
+     * @remarks Time O(log n), Space O(1)
+     
+     
      
      
      
@@ -344,20 +409,2145 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
       * @example
-   * // Iterate entries
+   * // Get occurrence count
    *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 2);
-   *       console.log([...ms.entries()].length); // > 0;
-     */
-    entries(): IterableIterator<[K, number]>;
-    /**
-     * Expanded iteration (default). Each key is yielded `count(key)` times.
-     * @remarks Time O(size), Space O(1) where size is total occurrences
+   *       ms.add(1, 5);
+   *       console.log(ms.count(1)); // 5;
      */
-    [Symbol.iterator](): Iterator<K>;
+    count(key: K): number;
     /**
-     * Returns an array with all elements (expanded).
-     * @remarks Time O(size), Space O(size)
+     * Add `n` occurrences of `key`.
+     * @returns True if the multiset changed.
+     * @remarks Time O(log n), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Add elements
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1);
+   *       ms.add(1);
+   *       ms.add(2);
+   *       console.log(ms.count(1)); // 2;
+   *       console.log(ms.size); // 3;
+     */
+    add(key: K, n?: number): boolean;
+    /**
+     * Set count for `key` to exactly `n`.
+     * @returns True if changed.
+     * @remarks Time O(log n), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Set occurrence count
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.setCount(1, 3);
+   *       console.log(ms.count(1)); // 3;
+     */
+    setCount(key: K, n: number): boolean;
+    /**
+     * Delete `n` occurrences of `key` (default 1).
+     * @returns True if any occurrence was removed.
+     * @remarks Time O(log n), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Remove one occurrence
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1, 3);
+   *       ms.delete(1);
+   *       console.log(ms.count(1)); // 2;
+     */
+    delete(key: K, n?: number): boolean;
+    /**
+     * Delete all occurrences of the given key.
+     * @returns True if any occurrence was removed.
+     * @remarks Time O(log n), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Remove all occurrences
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1, 3);
+   *       ms.deleteAll(1);
+   *       console.log(ms.has(1)); // false;
+     */
+    deleteAll(key: K): boolean;
+    /**
+     * Iterates over distinct keys (each key yielded once).
+     * @remarks Time O(n), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Iterate unique keys
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1, 2);
+   *       ms.add(2);
+   *       console.log([...ms.keysDistinct()]); // [1, 2];
+     */
+    keysDistinct(): IterableIterator<K>;
+    /**
+     * Iterates over entries as [key, count] pairs.
+     * @remarks Time O(n), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Iterate entries
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1, 2);
+   *       console.log([...ms.entries()].length); // > 0;
+     */
+    entries(): IterableIterator<[K, number]>;
+    /**
+     * Expanded iteration (default). Each key is yielded `count(key)` times.
+     * @remarks Time O(size), Space O(1) where size is total occurrences
+     */
+    [Symbol.iterator](): Iterator<K>;
+    /**
+     * Returns an array with all elements (expanded).
+     * @remarks Time O(size), Space O(size)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // All elements (with duplicates)
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1, 2);
+   *       ms.add(2);
+   *       console.log(ms.toArray()); // [1, 1, 2];
+     */
+    toArray(): K[];
+    /**
+     * Returns an array with distinct keys only.
+     * @remarks Time O(n), Space O(n)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Unique keys only
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1, 3);
+   *       ms.add(2);
+   *       console.log(ms.toDistinctArray()); // [1, 2];
+     */
+    toDistinctArray(): K[];
+    /**
+     * Returns an array of [key, count] entries.
+     * @remarks Time O(n), Space O(n)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Key-count pairs
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1, 2);
+   *       ms.add(3);
+   *       console.log(ms.toEntries()); // [[1, 2], [3, 1]];
+     */
+    toEntries(): Array<[K, number]>;
+    /**
+     * Expose comparator for advanced usage/testing (read-only).
+     * @remarks Time O(1), Space O(1)
+     */
+    get comparator(): Comparator<K>;
+    /**
+     * Remove all elements from the multiset.
+     * @remarks Time O(1), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Remove all
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1);
+   *       ms.clear();
+   *       console.log(ms.isEmpty()); // true;
+     */
+    clear(): void;
+    /**
+     * Returns the smallest key, or undefined if empty.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Smallest element
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(3);
+   *       ms.add(1);
+   *       console.log(ms.first()); // 1;
+     */
+    first(): K | undefined;
+    /**
+     * Returns the largest key, or undefined if empty.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Largest element
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1);
+   *       ms.add(3);
+   *       console.log(ms.last()); // 3;
+     */
+    last(): K | undefined;
+    /**
+     * Removes all occurrences of the smallest key and returns it.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Remove and return smallest
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(2);
+   *       ms.add(1);
+   *       console.log(ms.pollFirst()); // 1;
+   *       console.log(ms.has(1)); // false;
+     */
+    pollFirst(): K | undefined;
+    /**
+     * Removes all occurrences of the largest key and returns it.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Remove and return largest
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1);
+   *       ms.add(3);
+   *       console.log(ms.pollLast()); // 3;
+     */
+    pollLast(): K | undefined;
+    /**
+     * Returns the smallest key >= given key, or undefined.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Least key ≥ target
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(10);
+   *       ms.add(20);
+   *       ms.add(30);
+   *       console.log(ms.ceiling(15)); // 20;
+     */
+    ceiling(key: K): K | undefined;
+    /**
+     * Returns the largest key <= given key, or undefined.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Greatest key ≤ target
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(10);
+   *       ms.add(20);
+   *       ms.add(30);
+   *       console.log(ms.floor(25)); // 20;
+     */
+    floor(key: K): K | undefined;
+    /**
+     * Returns the smallest key > given key, or undefined.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Least key > target
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(10);
+   *       ms.add(20);
+   *       console.log(ms.higher(10)); // 20;
+     */
+    higher(key: K): K | undefined;
+    /**
+     * Returns the largest key < given key, or undefined.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Greatest key < target
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(10);
+   *       ms.add(20);
+   *       console.log(ms.lower(20)); // 10;
+     */
+    lower(key: K): K | undefined;
+    /**
+     * Iterates over distinct keys with their counts.
+     * @remarks Time O(n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Iterate
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1, 2);
+   *       ms.add(2);
+   *       const pairs: [number, number][] = [];
+   *       ms.forEach((k, c) => pairs.push([k, c]));
+   *       console.log(pairs); // [[1, 2], [2, 1]];
+     */
+    forEach(callback: (key: K, count: number) => void): void;
+    /**
+     * Creates a new TreeMultiSet with entries that match the predicate.
+     * @remarks Time O(n log n), Space O(n)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Filter
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1, 3);
+   *       ms.add(2, 1);
+   *       ms.add(3, 2);
+   *       const filtered = ms.filter((k, c) => c > 1);
+   *       console.log([...filtered.keysDistinct()]); // [1, 3];
+     */
+    filter(predicate: (key: K, count: number) => boolean): TreeMultiSet<K>;
+    /**
+     * Reduces the multiset to a single value.
+     * @remarks Time O(n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Aggregate
+   *  const ms = new TreeMultiSet<number>();
+   *       ms.add(1, 2);
+   *       ms.add(2, 3);
+   *       const sum = ms.reduce((acc, k, c) => acc + k * c, 0);
+   *       console.log(sum); // 8;
+     */
+    reduce<U>(callback: (accumulator: U, key: K, count: number) => U, initialValue: U): U;
+    /**
+     * Maps keys and counts to a new TreeMultiSet.
+     * When multiple keys map to the same new key, counts are merged (added).
+     * @remarks Time O(n log n), Space O(n)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -396,49 +2586,10 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // All elements (with duplicates)
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 2);
-   *       ms.add(2);
-   *       console.log(ms.toArray()); // [1, 1, 2];
-     */
-    toArray(): K[];
-    /**
-     * Returns an array with distinct keys only.
-     * @remarks Time O(n), Space O(n)
      
      
-      * @example
-   * // Unique keys only
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 3);
-   *       ms.add(2);
-   *       console.log(ms.toDistinctArray()); // [1, 2];
-     */
-    toDistinctArray(): K[];
-    /**
-     * Returns an array of [key, count] entries.
-     * @remarks Time O(n), Space O(n)
      
      
-      * @example
-   * // Key-count pairs
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 2);
-   *       ms.add(3);
-   *       console.log(ms.toEntries()); // [[1, 2], [3, 1]];
-     */
-    toEntries(): Array<[K, number]>;
-    /**
-     * Expose comparator for advanced usage/testing (read-only).
-     * @remarks Time O(1), Space O(1)
-     */
-    get comparator(): Comparator<K>;
-    /**
-     * Remove all elements from the multiset.
-     * @remarks Time O(1), Space O(1)
-    
      
      
      
@@ -478,74 +2629,28 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
       * @example
-   * // Remove all
+   * // Transform
    *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1);
-   *       ms.clear();
-   *       console.log(ms.isEmpty()); // true;
+   *       ms.add(1, 2);
+   *       ms.add(2, 3);
+   *       const doubled = ms.map((k, c) => [k * 10, c] as [number, number]);
+   *       console.log([...doubled.keysDistinct()]); // [10, 20];
      */
-    clear(): void;
+    map<K2>(mapper: (key: K, count: number) => [K2, number], options?: {
+        comparator?: Comparator<K2>;
+    }): TreeMultiSet<K2>;
     /**
-     * Returns the smallest key, or undefined if empty.
-     * @remarks Time O(log n), Space O(1)
+     * Creates an independent copy of this multiset.
+     * @remarks Time O(n log n), Space O(n)
     
      
      
-      * @example
-   * // Smallest element
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(3);
-   *       ms.add(1);
-   *       console.log(ms.first()); // 1;
-     */
-    first(): K | undefined;
-    /**
-     * Returns the largest key, or undefined if empty.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
-      * @example
-   * // Largest element
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1);
-   *       ms.add(3);
-   *       console.log(ms.last()); // 3;
-     */
-    last(): K | undefined;
-    /**
-     * Removes all occurrences of the smallest key and returns it.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
-      * @example
-   * // Remove and return smallest
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(2);
-   *       ms.add(1);
-   *       console.log(ms.pollFirst()); // 1;
-   *       console.log(ms.has(1)); // false;
-     */
-    pollFirst(): K | undefined;
-    /**
-     * Removes all occurrences of the largest key and returns it.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
-      * @example
-   * // Remove and return largest
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1);
-   *       ms.add(3);
-   *       console.log(ms.pollLast()); // 3;
-     */
-    pollLast(): K | undefined;
-    /**
-     * Returns the smallest key >= given key, or undefined.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
      
@@ -575,19 +2680,6 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Least key ≥ target
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(10);
-   *       ms.add(20);
-   *       ms.add(30);
-   *       console.log(ms.ceiling(15)); // 20;
-     */
-    ceiling(key: K): K | undefined;
-    /**
-     * Returns the largest key <= given key, or undefined.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
      
@@ -617,19 +2709,6 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Greatest key ≤ target
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(10);
-   *       ms.add(20);
-   *       ms.add(30);
-   *       console.log(ms.floor(25)); // 20;
-     */
-    floor(key: K): K | undefined;
-    /**
-     * Returns the smallest key > given key, or undefined.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
      
@@ -659,18 +2738,25 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Least key > target
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(10);
-   *       ms.add(20);
-   *       console.log(ms.higher(10)); // 20;
-     */
-    higher(key: K): K | undefined;
-    /**
-     * Returns the largest key < given key, or undefined.
-     * @remarks Time O(log n), Space O(1)
-    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -701,16 +2787,17 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
       * @example
-   * // Greatest key < target
+   * // Deep clone
    *  const ms = new TreeMultiSet<number>();
-   *       ms.add(10);
-   *       ms.add(20);
-   *       console.log(ms.lower(20)); // 10;
+   *       ms.add(1, 3);
+   *       const copy = ms.clone();
+   *       copy.deleteAll(1);
+   *       console.log(ms.has(1)); // true;
      */
-    lower(key: K): K | undefined;
+    clone(): TreeMultiSet<K>;
     /**
-     * Iterates over distinct keys with their counts.
-     * @remarks Time O(n), Space O(1)
+     * Returns keys within the given range.
+     * @remarks Time O(log n + k), Space O(k) where k is result size
     
      
      
@@ -750,21 +2837,6 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Iterate
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 2);
-   *       ms.add(2);
-   *       const pairs: [number, number][] = [];
-   *       ms.forEach((k, c) => pairs.push([k, c]));
-   *       console.log(pairs); // [[1, 2], [2, 1]];
-     */
-    forEach(callback: (key: K, count: number) => void): void;
-    /**
-     * Creates a new TreeMultiSet with entries that match the predicate.
-     * @remarks Time O(n log n), Space O(n)
-    
-     
      
      
      
@@ -802,20 +2874,6 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Filter
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 3);
-   *       ms.add(2, 1);
-   *       ms.add(3, 2);
-   *       const filtered = ms.filter((k, c) => c > 1);
-   *       console.log([...filtered.keysDistinct()]); // [1, 3];
-     */
-    filter(predicate: (key: K, count: number) => boolean): TreeMultiSet<K>;
-    /**
-     * Reduces the multiset to a single value.
-     * @remarks Time O(n), Space O(1)
-    
      
      
      
@@ -855,18 +2913,18 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
       * @example
-   * // Aggregate
+   * // Find in range
    *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 2);
-   *       ms.add(2, 3);
-   *       const sum = ms.reduce((acc, k, c) => acc + k * c, 0);
-   *       console.log(sum); // 8;
+   *       ms.add(10);
+   *       ms.add(20);
+   *       ms.add(30);
+   *       const result = ms.rangeSearch([15, 25]);
+   *       console.log(result.length); // 1;
      */
-    reduce<U>(callback: (accumulator: U, key: K, count: number) => U, initialValue: U): U;
+    rangeSearch<C extends (key: K) => any>(range: [K, K], callback?: C): (C extends undefined ? K : ReturnType<C>)[];
     /**
-     * Maps keys and counts to a new TreeMultiSet.
-     * When multiple keys map to the same new key, counts are merged (added).
-     * @remarks Time O(n log n), Space O(n)
+     * Prints the internal tree structure (for debugging).
+     * @remarks Time O(n), Space O(n)
     
      
      
@@ -906,21 +2964,6 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Transform
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 2);
-   *       ms.add(2, 3);
-   *       const doubled = ms.map((k, c) => [k * 10, c] as [number, number]);
-   *       console.log([...doubled.keysDistinct()]); // [10, 20];
-     */
-    map<K2>(mapper: (key: K, count: number) => [K2, number], options?: {
-        comparator?: Comparator<K2>;
-    }): TreeMultiSet<K2>;
-    /**
-     * Creates an independent copy of this multiset.
-     * @remarks Time O(n log n), Space O(n)
-    
      
      
      
@@ -959,19 +3002,6 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Deep clone
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(1, 3);
-   *       const copy = ms.clone();
-   *       copy.deleteAll(1);
-   *       console.log(ms.has(1)); // true;
-     */
-    clone(): TreeMultiSet<K>;
-    /**
-     * Returns keys within the given range.
-     * @remarks Time O(log n + k), Space O(k) where k is result size
-    
      
      
      
@@ -1001,20 +3031,6 @@ export declare class TreeMultiSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Find in range
-   *  const ms = new TreeMultiSet<number>();
-   *       ms.add(10);
-   *       ms.add(20);
-   *       ms.add(30);
-   *       const result = ms.rangeSearch([15, 25]);
-   *       console.log(result.length); // 1;
-     */
-    rangeSearch<C extends (key: K) => any>(range: [K, K], callback?: C): (C extends undefined ? K : ReturnType<C>)[];
-    /**
-     * Prints the internal tree structure (for debugging).
-     * @remarks Time O(n), Space O(n)
-