priority-queue-typed 1.54.3 → 2.0.0

package/dist/data-structures/binary-tree/avl-tree-multi-map.js

@@ -72,37 +72,40 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * provided options.
      */
     createTree(options) {
-        return new AVLTreeMultiMap([], Object.assign({ iterationType: this.iterationType, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
+        return new AVLTreeMultiMap([], Object.assign({ iterationType: this.iterationType, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse, isMapMode: this._isMapMode }, options));
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `createNode` overrides the method to create a new AVLTreeMultiMapNode with a
-     * specified key and an empty array of values.
-     * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
-     * that will be created in the AVLTreeMultiMap.
-     * @returns An AVLTreeMultiMapNode object is being returned, initialized with the provided key and an
-     * empty array.
+     * The `createNode` function in TypeScript overrides the default implementation to create a new
+     * AVLTreeMultiMapNode with a specified key and value array.
+     * @param {K} key - The `key` parameter represents the key of the node being created in the
+     * AVLTreeMultiMap.
+     * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
+     * values associated with a specific key in the AVLTreeMultiMapNode. If no value is provided when
+     * calling the method, an empty array `[]` is used as the default value.
+     * @returns An AVLTreeMultiMapNode object is being returned, with the specified key and value. If the
+     * AVLTreeMultiMap is in map mode, an empty array is used as the value, otherwise the provided value
+     * array is used.
      */
-    createNode(key) {
-        return new AVLTreeMultiMapNode(key, []);
+    createNode(key, value = []) {
+        return new AVLTreeMultiMapNode(key, this._isMapMode ? [] : value);
     }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
-     * The function `add` in TypeScript overrides the superclass method to add key-value pairs to an AVL
-     * tree multi-map.
-     * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `override add` method can be either a key-value pair entry or just a key. If it
-     * is a key-value pair entry, it will be in the format `[key, values]`, where `key` is the key and
-     * `values`
-     * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
-     * you want to add to the AVLTreeMultiMap. It can be a single value or an array of values associated
-     * with a specific key.
-     * @returns The `override add` method is returning a boolean value, which indicates whether the
-     * addition operation was successful or not.
+     * The function `add` in this TypeScript code overrides the superclass method to add key-value pairs
+     * to an AVLTreeMultiMap, handling different input types and scenarios.
+     * @param [key] - The `key` parameter in the `override add` method represents the key of the entry to
+     * be added to the AVLTreeMultiMap. It can be of type `K`, which is the key type of the map. The key
+     * can be a single key value, a node of the AVLTree
+     * @param {V[]} [values] - The `values` parameter in the `add` method represents an array of values
+     * that you want to add to the AVLTreeMultiMap. It can contain one or more values associated with a
+     * specific key.
+     * @returns The `add` method is returning a boolean value, which indicates whether the operation was
+     * successful or not.
      */
     add(keyNodeOrEntry, value) {
         if (this.isRealNode(keyNodeOrEntry))
@@ -110,30 +113,40 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
         const _commonAdd = (key, values) => {
             if (key === undefined || key === null)
                 return false;
-            const existingValues = this.get(key);
-            if (existingValues !== undefined && values !== undefined) {
-                for (const value of values)
-                    existingValues.push(value);
-                return true;
-            }
-            const existingNode = this.getNode(key);
-            if (this.isRealNode(existingNode)) {
-                if (existingValues === undefined) {
-                    super.add(key, values);
-                    return true;
-                }
-                if (values !== undefined) {
+            const _addToValues = () => {
+                const existingValues = this.get(key);
+                if (existingValues !== undefined && values !== undefined) {
                     for (const value of values)
                         existingValues.push(value);
                     return true;
                 }
+                return false;
+            };
+            const _addByNode = () => {
+                const existingNode = this.getNode(key);
+                if (this.isRealNode(existingNode)) {
+                    const existingValues = this.get(existingNode);
+                    if (existingValues === undefined) {
+                        super.add(key, values);
+                        return true;
+                    }
+                    if (values !== undefined) {
+                        for (const value of values)
+                            existingValues.push(value);
+                        return true;
+                    }
+                    else {
+                        return false;
+                    }
+                }
                 else {
-                    return false;
+                    return super.add(key, values);
                 }
+            };
+            if (this._isMapMode) {
+                return _addByNode() || _addToValues();
             }
-            else {
-                return super.add(key, values);
-            }
+            return _addToValues() || _addByNode();
         };
         if (this.isEntry(keyNodeOrEntry)) {
             const [key, values] = keyNodeOrEntry;

package/dist/data-structures/binary-tree/avl-tree.d.ts

@@ -35,6 +35,70 @@ export declare class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
  * 5. Efficient Lookups: Offers O(log n) search time, where 'n' is the number of nodes, due to its balanced nature.
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
+ * @example
+ * // Find elements in a range
+ *     // In interval queries, AVL trees, with their strictly balanced structure and lower height, offer better query efficiency, making them ideal for frequent and high-performance interval queries. In contrast, Red-Black trees, with lower update costs, are more suitable for scenarios involving frequent insertions and deletions where the requirements for interval queries are less demanding.
+ *     type Datum = { timestamp: Date; temperature: number };
+ *     // Fixed dataset of CPU temperature readings
+ *     const cpuData: Datum[] = [
+ *       { timestamp: new Date('2024-12-02T00:00:00'), temperature: 55.1 },
+ *       { timestamp: new Date('2024-12-02T00:01:00'), temperature: 56.3 },
+ *       { timestamp: new Date('2024-12-02T00:02:00'), temperature: 54.8 },
+ *       { timestamp: new Date('2024-12-02T00:03:00'), temperature: 57.2 },
+ *       { timestamp: new Date('2024-12-02T00:04:00'), temperature: 58.0 },
+ *       { timestamp: new Date('2024-12-02T00:05:00'), temperature: 59.4 },
+ *       { timestamp: new Date('2024-12-02T00:06:00'), temperature: 60.1 },
+ *       { timestamp: new Date('2024-12-02T00:07:00'), temperature: 61.3 },
+ *       { timestamp: new Date('2024-12-02T00:08:00'), temperature: 62.0 },
+ *       { timestamp: new Date('2024-12-02T00:09:00'), temperature: 63.5 },
+ *       { timestamp: new Date('2024-12-02T00:10:00'), temperature: 64.0 },
+ *       { timestamp: new Date('2024-12-02T00:11:00'), temperature: 62.8 },
+ *       { timestamp: new Date('2024-12-02T00:12:00'), temperature: 61.5 },
+ *       { timestamp: new Date('2024-12-02T00:13:00'), temperature: 60.2 },
+ *       { timestamp: new Date('2024-12-02T00:14:00'), temperature: 59.8 },
+ *       { timestamp: new Date('2024-12-02T00:15:00'), temperature: 58.6 },
+ *       { timestamp: new Date('2024-12-02T00:16:00'), temperature: 57.4 },
+ *       { timestamp: new Date('2024-12-02T00:17:00'), temperature: 56.2 },
+ *       { timestamp: new Date('2024-12-02T00:18:00'), temperature: 55.7 },
+ *       { timestamp: new Date('2024-12-02T00:19:00'), temperature: 54.5 },
+ *       { timestamp: new Date('2024-12-02T00:20:00'), temperature: 53.2 },
+ *       { timestamp: new Date('2024-12-02T00:21:00'), temperature: 52.8 },
+ *       { timestamp: new Date('2024-12-02T00:22:00'), temperature: 51.9 },
+ *       { timestamp: new Date('2024-12-02T00:23:00'), temperature: 50.5 },
+ *       { timestamp: new Date('2024-12-02T00:24:00'), temperature: 49.8 },
+ *       { timestamp: new Date('2024-12-02T00:25:00'), temperature: 48.7 },
+ *       { timestamp: new Date('2024-12-02T00:26:00'), temperature: 47.5 },
+ *       { timestamp: new Date('2024-12-02T00:27:00'), temperature: 46.3 },
+ *       { timestamp: new Date('2024-12-02T00:28:00'), temperature: 45.9 },
+ *       { timestamp: new Date('2024-12-02T00:29:00'), temperature: 45.0 }
+ *     ];
+ *
+ *     // Create an AVL tree to store CPU temperature data
+ *     const cpuTemperatureTree = new AVLTree<Date, number, Datum>(cpuData, {
+ *       toEntryFn: ({ timestamp, temperature }) => [timestamp, temperature]
+ *     });
+ *
+ *     // Query a specific time range (e.g., from 00:05 to 00:15)
+ *     const rangeStart = new Date('2024-12-02T00:05:00');
+ *     const rangeEnd = new Date('2024-12-02T00:15:00');
+ *     const rangeResults = cpuTemperatureTree.rangeSearch([rangeStart, rangeEnd], node => ({
+ *       minute: node ? node.key.getMinutes() : 0,
+ *       temperature: cpuTemperatureTree.get(node ? node.key : undefined)
+ *     }));
+ *
+ *     console.log(rangeResults); // [
+ *  //      { minute: 5, temperature: 59.4 },
+ *  //      { minute: 6, temperature: 60.1 },
+ *  //      { minute: 7, temperature: 61.3 },
+ *  //      { minute: 8, temperature: 62 },
+ *  //      { minute: 9, temperature: 63.5 },
+ *  //      { minute: 10, temperature: 64 },
+ *  //      { minute: 11, temperature: 62.8 },
+ *  //      { minute: 12, temperature: 61.5 },
+ *  //      { minute: 13, temperature: 60.2 },
+ *  //      { minute: 14, temperature: 59.8 },
+ *  //      { minute: 15, temperature: 58.6 }
+ *  //    ]
  */
 export declare class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = object> extends BST<K, V, R, MK, MV, MR> implements IBinaryTree<K, V, R, MK, MV, MR> {
     /**

package/dist/data-structures/binary-tree/avl-tree.js

@@ -53,6 +53,70 @@ exports.AVLTreeNode = AVLTreeNode;
  * 5. Efficient Lookups: Offers O(log n) search time, where 'n' is the number of nodes, due to its balanced nature.
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
+ * @example
+ * // Find elements in a range
+ *     // In interval queries, AVL trees, with their strictly balanced structure and lower height, offer better query efficiency, making them ideal for frequent and high-performance interval queries. In contrast, Red-Black trees, with lower update costs, are more suitable for scenarios involving frequent insertions and deletions where the requirements for interval queries are less demanding.
+ *     type Datum = { timestamp: Date; temperature: number };
+ *     // Fixed dataset of CPU temperature readings
+ *     const cpuData: Datum[] = [
+ *       { timestamp: new Date('2024-12-02T00:00:00'), temperature: 55.1 },
+ *       { timestamp: new Date('2024-12-02T00:01:00'), temperature: 56.3 },
+ *       { timestamp: new Date('2024-12-02T00:02:00'), temperature: 54.8 },
+ *       { timestamp: new Date('2024-12-02T00:03:00'), temperature: 57.2 },
+ *       { timestamp: new Date('2024-12-02T00:04:00'), temperature: 58.0 },
+ *       { timestamp: new Date('2024-12-02T00:05:00'), temperature: 59.4 },
+ *       { timestamp: new Date('2024-12-02T00:06:00'), temperature: 60.1 },
+ *       { timestamp: new Date('2024-12-02T00:07:00'), temperature: 61.3 },
+ *       { timestamp: new Date('2024-12-02T00:08:00'), temperature: 62.0 },
+ *       { timestamp: new Date('2024-12-02T00:09:00'), temperature: 63.5 },
+ *       { timestamp: new Date('2024-12-02T00:10:00'), temperature: 64.0 },
+ *       { timestamp: new Date('2024-12-02T00:11:00'), temperature: 62.8 },
+ *       { timestamp: new Date('2024-12-02T00:12:00'), temperature: 61.5 },
+ *       { timestamp: new Date('2024-12-02T00:13:00'), temperature: 60.2 },
+ *       { timestamp: new Date('2024-12-02T00:14:00'), temperature: 59.8 },
+ *       { timestamp: new Date('2024-12-02T00:15:00'), temperature: 58.6 },
+ *       { timestamp: new Date('2024-12-02T00:16:00'), temperature: 57.4 },
+ *       { timestamp: new Date('2024-12-02T00:17:00'), temperature: 56.2 },
+ *       { timestamp: new Date('2024-12-02T00:18:00'), temperature: 55.7 },
+ *       { timestamp: new Date('2024-12-02T00:19:00'), temperature: 54.5 },
+ *       { timestamp: new Date('2024-12-02T00:20:00'), temperature: 53.2 },
+ *       { timestamp: new Date('2024-12-02T00:21:00'), temperature: 52.8 },
+ *       { timestamp: new Date('2024-12-02T00:22:00'), temperature: 51.9 },
+ *       { timestamp: new Date('2024-12-02T00:23:00'), temperature: 50.5 },
+ *       { timestamp: new Date('2024-12-02T00:24:00'), temperature: 49.8 },
+ *       { timestamp: new Date('2024-12-02T00:25:00'), temperature: 48.7 },
+ *       { timestamp: new Date('2024-12-02T00:26:00'), temperature: 47.5 },
+ *       { timestamp: new Date('2024-12-02T00:27:00'), temperature: 46.3 },
+ *       { timestamp: new Date('2024-12-02T00:28:00'), temperature: 45.9 },
+ *       { timestamp: new Date('2024-12-02T00:29:00'), temperature: 45.0 }
+ *     ];
+ *
+ *     // Create an AVL tree to store CPU temperature data
+ *     const cpuTemperatureTree = new AVLTree<Date, number, Datum>(cpuData, {
+ *       toEntryFn: ({ timestamp, temperature }) => [timestamp, temperature]
+ *     });
+ *
+ *     // Query a specific time range (e.g., from 00:05 to 00:15)
+ *     const rangeStart = new Date('2024-12-02T00:05:00');
+ *     const rangeEnd = new Date('2024-12-02T00:15:00');
+ *     const rangeResults = cpuTemperatureTree.rangeSearch([rangeStart, rangeEnd], node => ({
+ *       minute: node ? node.key.getMinutes() : 0,
+ *       temperature: cpuTemperatureTree.get(node ? node.key : undefined)
+ *     }));
+ *
+ *     console.log(rangeResults); // [
+ *  //      { minute: 5, temperature: 59.4 },
+ *  //      { minute: 6, temperature: 60.1 },
+ *  //      { minute: 7, temperature: 61.3 },
+ *  //      { minute: 8, temperature: 62 },
+ *  //      { minute: 9, temperature: 63.5 },
+ *  //      { minute: 10, temperature: 64 },
+ *  //      { minute: 11, temperature: 62.8 },
+ *  //      { minute: 12, temperature: 61.5 },
+ *  //      { minute: 13, temperature: 60.2 },
+ *  //      { minute: 14, temperature: 59.8 },
+ *  //      { minute: 15, temperature: 58.6 }
+ *  //    ]
  */
 class AVLTree extends bst_1.BST {
     /**

package/dist/data-structures/binary-tree/binary-tree.js

@@ -451,7 +451,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         const queue = new queue_1.Queue([this._root]);
         let potentialParent; // Record the parent node of the potential insertion location
-        while (queue.size > 0) {
+        while (queue.length > 0) {
             const cur = queue.shift();
             if (!cur)
                 continue;
@@ -1275,7 +1275,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                 startNode
             ]);
             const dfs = (level) => {
-                if (queue.size === 0)
+                if (queue.length === 0)
                     return;
                 const current = queue.shift();
                 ans.push(callback(current));
@@ -1297,8 +1297,8 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         else {
             const queue = new queue_1.Queue([startNode]);
-            while (queue.size > 0) {
-                const levelSize = queue.size;
+            while (queue.length > 0) {
+                const levelSize = queue.length;
                 for (let i = 0; i < levelSize; i++) {
                     const current = queue.shift();
                     ans.push(callback(current));
@@ -1358,7 +1358,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         else {
             const queue = new queue_1.Queue([startNode]);
-            while (queue.size > 0) {
+            while (queue.length > 0) {
                 const cur = queue.shift();
                 if (this.isRealNode(cur)) {
                     if (this.isLeaf(cur)) {

package/dist/data-structures/binary-tree/bst.js

@@ -359,23 +359,22 @@ class BST extends binary_tree_1.BinaryTree {
             return 0;
         });
         const _dfs = (arr) => {
-            var _a;
             if (arr.length === 0)
                 return;
             const mid = Math.floor((arr.length - 1) / 2);
-            let { key, value } = arr[mid];
+            const { key, value } = arr[mid];
             const { orgIndex } = arr[mid];
             if (this.isRaw(key)) {
                 const entry = this._toEntryFn(key);
-                key = entry[0];
-                value = (_a = entry[1]) !== null && _a !== void 0 ? _a : value;
+                inserted[orgIndex] = this.add(entry);
+            }
+            else {
+                inserted[orgIndex] = this.add(key, value);
             }
-            inserted[orgIndex] = this.add(key, value);
             _dfs(arr.slice(0, mid));
             _dfs(arr.slice(mid + 1));
         };
         const _iterate = () => {
-            var _a;
             const n = sorted.length;
             const stack = [[0, n - 1]];
             while (stack.length > 0) {
@@ -384,14 +383,15 @@ class BST extends binary_tree_1.BinaryTree {
                     const [l, r] = popped;
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
-                        let { key, value } = sorted[m];
+                        const { key, value } = sorted[m];
                         const { orgIndex } = sorted[m];
                         if (this.isRaw(key)) {
                             const entry = this._toEntryFn(key);
-                            key = entry[0];
-                            value = (_a = entry[1]) !== null && _a !== void 0 ? _a : value;
+                            inserted[orgIndex] = this.add(entry);
+                        }
+                        else {
+                            inserted[orgIndex] = this.add(key, value);
                         }
-                        inserted[orgIndex] = this.add(key, value);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -659,7 +659,7 @@ class BST extends binary_tree_1.BinaryTree {
         }
         else {
             const queue = new queue_1.Queue([this._root]);
-            while (queue.size > 0) {
+            while (queue.length > 0) {
                 const cur = queue.shift();
                 if (this.isRealNode(cur)) {
                     const compared = this._compare(cur.key, targetKey);

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

@@ -19,7 +19,7 @@ export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode
      * @param {V[]} value - The `value` parameter in the constructor represents an array of values of
      * type `V`.
      */
-    constructor(key: K, value: V[]);
+    constructor(key: K, value?: V[]);
     _left?: TreeMultiMapNode<K, V> | null | undefined;
     get left(): TreeMultiMapNode<K, V> | null | undefined;
     set left(v: TreeMultiMapNode<K, V> | null | undefined);
@@ -30,11 +30,169 @@ export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode
 /**
  *
  * @example
- * // Find elements in a range
- *     const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
- *     console.log(tmm.search(new Range(5, 10))); // [5, 7, 10]
- *     console.log(tmm.search(new Range(4, 12))); // [5, 7, 10, 12]
- *     console.log(tmm.search(new Range(15, 20))); // [15, 18]
+ * // 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));
+ *     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 }
+ *  //      ]
+ *  //    ]
  */
 export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR = object> extends RedBlackTree<K, V[], R, MK, MV[], MR> implements IBinaryTree<K, V[], R, MK, MV, MR> {
     /**
@@ -67,15 +225,18 @@ export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = a
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `createNode` overrides the method to create a new `TreeMultiMapNode` with a specified
-     * key and an empty array of values.
-     * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
-     * that will be created in the TreeMultiMap data structure.
-     * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned, with the specified key and
-     * an empty array as its value.
+     * The function `createNode` overrides the creation of a new TreeMultiMapNode with a specified key
+     * and value array.
+     * @param {K} key - The `key` parameter represents the key of the node being created in the
+     * `TreeMultiMap`.
+     * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
+     * values associated with a specific key in the TreeMultiMap data structure.
+     * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned with the specified key and
+     * value. If `_isMapMode` is true, an empty array is passed as the value, otherwise the provided
+     * value is used.
      */
-    createNode(key: K): TreeMultiMapNode<K, V>;
-    add(node: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
+    createNode(key: K, value?: V[]): TreeMultiMapNode<K, V>;
+    add(keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
     add(key: K, value: V): boolean;
     /**
      * Time Complexity: O(log n)