max-priority-queue-typed 2.4.4 → 2.5.0

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

@@ -8,14 +8,6 @@
 import type { Comparator, TreeMultiMapOptions } from '../../types';
 import { Range } from '../../common';
 import { RedBlackTreeNode } from './red-black-tree';
-/**
- * Node type used by TreeMultiMap (alias to RedBlackTreeNode for backward compatibility).
- *
- * @deprecated Direct node manipulation is discouraged. Use TreeMultiMap methods instead.
- */
-export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]> {
-    constructor(key: K, value?: V[]);
-}
 /**
  * TreeMultiMap (ordered MultiMap) — key → bucket (Array of values).
  *
@@ -25,169 +17,10 @@ export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode
  * - Default iteration yields bucket entries: `[K, V[]]`.
  * - Navigable operations (`first/last/ceiling/...`) return entry tuples like TreeMap.
  * @example
- * // players ranked by score with their equipment
- *  type Equipment = {
- *       name: string; // Equipment name
- *       quality: 'legendary' | 'epic' | 'rare' | 'common';
- *       level: number;
- *     };
- *
- *     type Player = {
- *       name: string;
- *       score: number;
- *       equipments: Equipment[];
- *     };
- *
- *     // Mock player data with their scores and equipment
- *     const players: Player[] = [
- *       {
- *         name: 'DragonSlayer',
- *         score: 8750,
- *         equipments: [
- *           { name: 'AWM', quality: 'legendary', level: 85 },
- *           { name: 'Level 3 Helmet', quality: 'epic', level: 80 },
- *           { name: 'Extended Quickdraw Mag', quality: 'rare', level: 75 },
- *           { name: 'Compensator', quality: 'epic', level: 78 },
- *           { name: 'Vertical Grip', quality: 'rare', level: 72 }
- *         ]
- *       },
- *       {
- *         name: 'ShadowNinja',
- *         score: 7200,
- *         equipments: [
- *           { name: 'M416', quality: 'epic', level: 75 },
- *           { name: 'Ghillie Suit', quality: 'rare', level: 70 },
- *           { name: 'Red Dot Sight', quality: 'common', level: 65 },
- *           { name: 'Extended QuickDraw Mag', quality: 'rare', level: 68 }
- *         ]
- *       },
- *       {
- *         name: 'RuneMaster',
- *         score: 9100,
- *         equipments: [
- *           { name: 'KAR98K', quality: 'legendary', level: 90 },
- *           { name: 'Level 3 Vest', quality: 'legendary', level: 85 },
- *           { name: 'Holographic Sight', quality: 'epic', level: 82 },
- *           { name: 'Suppressor', quality: 'legendary', level: 88 },
- *           { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
- *         ]
- *       },
- *       {
- *         name: 'BattleKing',
- *         score: 8500,
- *         equipments: [
- *           { name: 'AUG', quality: 'epic', level: 82 },
- *           { name: 'Red Dot Sight', quality: 'rare', level: 75 },
- *           { name: 'Extended Mag', quality: 'common', level: 70 },
- *           { name: 'Tactical Stock', quality: 'rare', level: 76 }
- *         ]
- *       },
- *       {
- *         name: 'SniperElite',
- *         score: 7800,
- *         equipments: [
- *           { name: 'M24', quality: 'legendary', level: 88 },
- *           { name: 'Compensator', quality: 'epic', level: 80 },
- *           { name: 'Scope 8x', quality: 'legendary', level: 85 },
- *           { name: 'Level 2 Helmet', quality: 'rare', level: 75 }
- *         ]
- *       },
- *       {
- *         name: 'RushMaster',
- *         score: 7500,
- *         equipments: [
- *           { name: 'Vector', quality: 'rare', level: 72 },
- *           { name: 'Level 2 Helmet', quality: 'common', level: 65 },
- *           { name: 'Quickdraw Mag', quality: 'common', level: 60 },
- *           { name: 'Laser Sight', quality: 'rare', level: 68 }
- *         ]
- *       },
- *       {
- *         name: 'GhostWarrior',
- *         score: 8200,
- *         equipments: [
- *           { name: 'SCAR-L', quality: 'epic', level: 78 },
- *           { name: 'Extended Quickdraw Mag', quality: 'rare', level: 70 },
- *           { name: 'Holographic Sight', quality: 'epic', level: 75 },
- *           { name: 'Suppressor', quality: 'rare', level: 72 },
- *           { name: 'Vertical Grip', quality: 'common', level: 65 }
- *         ]
- *       },
- *       {
- *         name: 'DeathDealer',
- *         score: 7300,
- *         equipments: [
- *           { name: 'SKS', quality: 'epic', level: 76 },
- *           { name: 'Holographic Sight', quality: 'rare', level: 68 },
- *           { name: 'Extended Mag', quality: 'common', level: 65 }
- *         ]
- *       },
- *       {
- *         name: 'StormRider',
- *         score: 8900,
- *         equipments: [
- *           { name: 'MK14', quality: 'legendary', level: 92 },
- *           { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
- *           { name: 'Scope 8x', quality: 'epic', level: 80 },
- *           { name: 'Suppressor', quality: 'legendary', level: 88 },
- *           { name: 'Tactical Stock', quality: 'rare', level: 75 }
- *         ]
- *       },
- *       {
- *         name: 'CombatLegend',
- *         score: 7600,
- *         equipments: [
- *           { name: 'UMP45', quality: 'rare', level: 74 },
- *           { name: 'Level 2 Vest', quality: 'common', level: 67 },
- *           { name: 'Red Dot Sight', quality: 'common', level: 62 },
- *           { name: 'Extended Mag', quality: 'rare', level: 70 }
- *         ]
- *       }
- *     ];
- *
- *     // Create a TreeMultiMap for player rankings
- *     const playerRankings = new TreeMultiMap<number, Equipment, Player>(players, {
- *       toEntryFn: ({ score, equipments }) => [score, equipments],
- *       isMapMode: false
- *     });
- *
- *     const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node.key));
- *     console.log(topPlayersEquipments); // [
- *  //      [
- *  //        {
- *  //          name: 'MK14',
- *  //          quality: 'legendary',
- *  //          level: 92
- *  //        },
- *  //        { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
- *  //        {
- *  //          name: 'Scope 8x',
- *  //          quality: 'epic',
- *  //          level: 80
- *  //        },
- *  //        { name: 'Suppressor', quality: 'legendary', level: 88 },
- *  //        {
- *  //          name: 'Tactical Stock',
- *  //          quality: 'rare',
- *  //          level: 75
- *  //        }
- *  //      ],
- *  //      [
- *  //        { name: 'KAR98K', quality: 'legendary', level: 90 },
- *  //        {
- *  //          name: 'Level 3 Vest',
- *  //          quality: 'legendary',
- *  //          level: 85
- *  //        },
- *  //        { name: 'Holographic Sight', quality: 'epic', level: 82 },
- *  //        {
- *  //          name: 'Suppressor',
- *  //          quality: 'legendary',
- *  //          level: 88
- *  //        },
- *  //        { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
- *  //      ]
- *  //    ];
+ * // Morris traversal (O(1) space)
+ *  const tmm = new TreeMultiMap<number>([5, 3, 7]);
+ *     const result = tmm.morris(n => n.key, 'IN');
+ *     console.log(result.length); // > 0;
  */
 export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable<[K, V[]]> {
     #private;
@@ -218,62 +51,461 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
     /**
      * Whether the map is empty.
      * @remarks Time O(1), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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;
     /**
@@ -284,136 +516,790 @@ export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable
     /**
      * 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[]>;
     /**
      * 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
-     * const map = new TreeMultiMap([[1, ['a']], [2, ['b']]]);
-     * map.first();  // [1, ['a']]
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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
-     * const map = new TreeMultiMap([[1, ['a']], [2, ['b']]]);
-     * map.last();  // [2, ['b']]
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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
-     * const map = new TreeMultiMap([[1, ['a']], [2, ['b']]]);
-     * map.pollFirst();  // [1, ['a']]
-     * map.has(1);       // false
+    
+     
+     
+      * @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
-     * const map = new TreeMultiMap([[1, ['a']], [2, ['b']]]);
-     * map.pollLast();  // [2, ['b']]
-     * map.has(2);      // false
+    
+     
+     
+      * @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
-     * const map = new TreeMultiMap([[10, ['a']], [20, ['b']], [30, ['c']]]);
-     * map.ceiling(15);  // [20, ['b']]
-     * map.ceiling(20);  // [20, ['b']]
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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
-     * const map = new TreeMultiMap([[10, ['a']], [20, ['b']], [30, ['c']]]);
-     * map.floor(25);  // [20, ['b']]
-     * map.floor(20);  // [20, ['b']]
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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
-     * const map = new TreeMultiMap([[10, ['a']], [20, ['b']], [30, ['c']]]);
-     * map.higher(10);  // [20, ['b']]
-     * map.higher(15);  // [20, ['b']]
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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
-     * const map = new TreeMultiMap([[10, ['a']], [20, ['b']], [30, ['c']]]);
-     * map.lower(20);  // [10, ['a']]
-     * map.lower(15);  // [10, ['a']]
+    
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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'];
      */
     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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @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)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Deep clone
+   *  const mm = new TreeMultiMap<number, string>();
+   *       mm.add(1, 'a');
+   *       const copy = mm.clone();
+   *       copy.delete(1);
+   *       console.log(mm.has(1)); // true;
      */
     clone(): TreeMultiMap<K, V, R>;
     /**