data-structure-typed 2.5.0 → 2.5.1

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

@@ -89,14 +89,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)
      
      
      
@@ -135,44 +127,16 @@ 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)
      
      
-      * @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)
      
      
-      * @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)
+     
+     
+     
+     
+     
+     
      
      
      
@@ -226,16 +190,99 @@ 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;
+   * // Check if empty
+   *  console.log(new TreeMultiMap().isEmpty()); // true;
      */
-    has(key: K): boolean;
+    isEmpty(): boolean;
     /**
-     * Live bucket reference (do not auto-delete key if bucket becomes empty via mutation).
-     * @remarks Time O(log n), Space O(1)
+     * Removes all entries from the map.
+     * @remarks Time O(1), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -289,15 +336,15 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
       * @example
-   * // Get values for key
+   * // Remove all entries
    *  const mm = new TreeMultiMap<number, string>();
    *       mm.add(1, 'a');
-   *       mm.add(1, 'b');
-   *       console.log(mm.get(1)); // ['a', 'b'];
+   *       mm.clear();
+   *       console.log(mm.isEmpty()); // true;
      */
-    get(key: K): V[] | undefined;
+    clear(): void;
     /**
-     * Append a single value.
+     * Bucket length for a key (missing => 0).
      * @remarks Time O(log n), Space O(1)
      
      
@@ -319,6 +366,29 @@ 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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -332,17 +402,17 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
       * @example
-   * // Add key-value pair
+   * // 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.get(1)); // ['a', 'b'];
+   *       console.log(mm.totalSize); // 3;
      */
-    add(key: K, value: V): boolean;
+    get totalSize(): number;
     /**
-     * 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
+     * Whether the map contains the given key.
+     * @remarks Time O(log n), Space O(1)
      
      
      
@@ -393,18 +463,6 @@ 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)
      
      
      
@@ -457,65 +515,12 @@ 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
      
      
-      * @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
      
      
-      * @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)
      
      
      
@@ -554,16 +559,2588 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Add key-value pair
+   *  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;
+    /**
+     * 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
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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];
+   *       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[]>;
+    /**
+     * 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)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // 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;
+     */
+    ceiling(key: K): [K, V[]] | undefined;
+    /**
+     * Returns the entry with the largest key <= given key.
+     * @remarks Time O(log n), Space O(1)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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'];
      */
-    keys(): IterableIterator<K>;
+    map<V2>(mapper: (value: V[], key: K, map: this) => [K, V2[]]): TreeMultiMap<K, V2, R>;
     /**
-     * Iterates over all buckets.
+     * Reduces all entries to a single value.
      * @remarks Time O(n), Space O(1)
      
      
@@ -603,58 +3180,12 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @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[]>;
-    /**
-     * 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)
-    
      
      
      
@@ -668,18 +3199,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @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)
-    
      
      
      
@@ -693,49 +3212,10 @@ 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)
-    
      
      
-      * @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)
-    
      
      
-      * @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)
-    
      
      
      
@@ -776,19 +3256,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');
-   *       mm.add(30, 'c');
-   *       console.log(mm.ceiling(15)?.[0]); // 20;
-     */
-    ceiling(key: K): [K, V[]] | undefined;
-    /**
-     * Returns the entry with the largest key <= given key.
-     * @remarks Time O(log n), Space O(1)
-    
      
      
      
@@ -813,6 +3280,36 @@ 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
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -829,19 +3326,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');
-   *       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)
-    
      
      
      
@@ -871,18 +3355,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)
-    
      
      
      
@@ -912,17 +3384,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)
      
      
      
@@ -962,19 +3423,15 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
       * @example
-   * // Display tree
+   * // Set multiple entries
    *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(1, 'a');
-   *       expect(() => mm.print()).not.toThrow();
+   *       mm.setMany([[1, ['a']], [2, ['b']]]);
+   *       console.log(mm.size); // 2;
      */
-    print(): void;
+    setMany(keysNodesEntriesOrRaws: Iterable<K | [K | null | undefined, V[] | undefined]>): boolean[];
     /**
-     * Executes a callback for each entry.
-     * @remarks Time O(n), Space O(1)
-     
-     
-     
-     
+     * Searches for entries within a key range.
+     * @remarks Time O(log n + k), Space O(k) where k is result size
      
      
      
@@ -1009,19 +3466,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)
      
      
      
@@ -1060,19 +3504,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)
      
      
      
@@ -1112,16 +3543,20 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
       * @example
-   * // Transform values
+   * // Find keys in range
    *  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'];
+   *       mm.add(10, 'a');
+   *       mm.add(20, 'b');
+   *       mm.add(30, 'c');
+   *       const result = mm.rangeSearch([15, 25]);
+   *       console.log(result.length); // 1;
      */
-    map<V2>(mapper: (value: V[], key: K, map: this) => [K, V2[]]): TreeMultiMap<K, V2, R>;
+    rangeSearch<C extends (node: RedBlackTreeNode<K, V[]>) => unknown>(range: Range<K> | [K, K], callback?: C): ReturnType<C>[];
     /**
-     * Reduces all entries to a single value.
-     * @remarks Time O(n), Space O(1)
+     * Creates a shallow clone of this map.
+     * @remarks Time O(n log n), Space O(n)
+     
+     
      
      
      
@@ -1160,18 +3595,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
      
      
      
@@ -1202,16 +3625,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
      
      
      
@@ -1242,19 +3655,6 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
      
      
      
-      * @example
-   * // Find keys in range
-   *  const mm = new TreeMultiMap<number, string>();
-   *       mm.add(10, 'a');
-   *       mm.add(20, 'b');
-   *       mm.add(30, 'c');
-   *       const result = mm.rangeSearch([15, 25]);
-   *       console.log(result.length); // 1;
-     */
-    rangeSearch<C extends (node: RedBlackTreeNode<K, V[]>) => unknown>(range: Range<K> | [K, K], callback?: C): ReturnType<C>[];
-    /**
-     * Creates a shallow clone of this map.
-     * @remarks Time O(n log n), Space O(n)