linked-list-typed 1.54.3 → 2.0.1

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

@@ -41,11 +41,169 @@ exports.TreeMultiMapNode = TreeMultiMapNode;
 /**
  *
  * @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 }
+ *  //      ]
+ *  //    ]
  */
 class TreeMultiMap extends red_black_tree_1.RedBlackTree {
     /**
@@ -60,7 +218,7 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
      * additional options for configuring the TreeMultiMap instance.
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
-        super([], Object.assign(Object.assign({}, options), { isMapMode: true }));
+        super([], Object.assign({}, options));
         if (keysNodesEntriesOrRaws) {
             this.addMany(keysNodesEntriesOrRaws);
         }
@@ -79,34 +237,36 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
      * data and the provided options merged with the existing properties of the current object.
      */
     createTree(options) {
-        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
+        return new TreeMultiMap([], 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 `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) {
-        return new TreeMultiMapNode(key, []);
+    createNode(key, value = []) {
+        return new TreeMultiMapNode(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 a
-     * TreeMultiMapNode, handling different input types and scenarios.
-     * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `override add` method can be either a `BTNRep` object containing a key, an array
-     * of values, and a `TreeMultiMapNode`, or just a key.
-     * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
-     * you want to add to the TreeMultiMap. If the key is already present in the map, the new value will
-     * be added to the existing list of values associated with that key. If the key is not present,
+     * The function overrides the add method to handle different types of input for a TreeMultiMap data
+     * structure.
+     * @param [key] - The `key` parameter in the `override add` method represents the key of the entry to
+     * be added to the TreeMultiMap. It can be of type `K`, which is the key type of the TreeMultiMap, or
+     * it can be a TreeMultiMapNode containing the key and its
+     * @param {V[]} [values] - The `values` parameter in the `add` method represents an array of values
+     * that you want to add to the TreeMultiMap. It can contain one or more values of type `V`.
      * @returns The `add` method is returning a boolean value, which indicates whether the operation was
      * successful or not.
      */
@@ -116,30 +276,40 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
         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/graph/abstract-graph.js

@@ -250,7 +250,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
             isWeight = false;
         if (isWeight) {
             const allPaths = this.getAllPathsBetween(v1, v2);
-            let min = Infinity;
+            let min = Number.MAX_SAFE_INTEGER;
             for (const path of allPaths) {
                 min = Math.min(this.getPathSumWeight(path), min);
             }
@@ -267,8 +267,8 @@ class AbstractGraph extends base_1.IterableEntryBase {
             const queue = new queue_1.Queue([vertex1]);
             visited.set(vertex1, true);
             let cost = 0;
-            while (queue.size > 0) {
-                for (let i = 0; i < queue.size; i++) {
+            while (queue.length > 0) {
+                for (let i = 0; i < queue.length; i++) {
                     const cur = queue.shift();
                     if (cur === vertex2) {
                         return cost;
@@ -315,7 +315,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         if (isWeight) {
             if (isDFS) {
                 const allPaths = this.getAllPathsBetween(v1, v2, 10000);
-                let min = Infinity;
+                let min = Number.MAX_SAFE_INTEGER;
                 let minIndex = -1;
                 let index = 0;
                 for (const path of allPaths) {
@@ -379,7 +379,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
      * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
      */
     dijkstraWithoutHeap(src, dest = undefined, getMinDist = false, genPaths = false) {
-        let minDist = Infinity;
+        let minDist = Number.MAX_SAFE_INTEGER;
         let minDest = undefined;
         let minPath = [];
         const paths = [];
@@ -395,12 +395,12 @@ class AbstractGraph extends base_1.IterableEntryBase {
         for (const vertex of vertexMap) {
             const vertexOrKey = vertex[1];
             if (vertexOrKey instanceof AbstractVertex)
-                distMap.set(vertexOrKey, Infinity);
+                distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
         }
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, undefined);
         const getMinOfNoSeen = () => {
-            let min = Infinity;
+            let min = Number.MAX_SAFE_INTEGER;
             let minV = undefined;
             for (const [key, value] of distMap) {
                 if (!seen.has(key)) {
@@ -435,7 +435,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
                 seen.add(cur);
                 if (destVertex && destVertex === cur) {
                     if (getMinDist) {
-                        minDist = distMap.get(destVertex) || Infinity;
+                        minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
                     }
                     if (genPaths) {
                         getPaths(destVertex);
@@ -497,7 +497,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
      */
     dijkstra(src, dest = undefined, getMinDist = false, genPaths = false) {
         var _a;
-        let minDist = Infinity;
+        let minDist = Number.MAX_SAFE_INTEGER;
         let minDest = undefined;
         let minPath = [];
         const paths = [];
@@ -512,7 +512,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         for (const vertex of vertexMap) {
             const vertexOrKey = vertex[1];
             if (vertexOrKey instanceof AbstractVertex)
-                distMap.set(vertexOrKey, Infinity);
+                distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
         }
         const heap = new heap_1.Heap([], { comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, value: srcVertex });
@@ -549,7 +549,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
                     seen.add(cur);
                     if (destVertex && destVertex === cur) {
                         if (getMinDist) {
-                            minDist = distMap.get(destVertex) || Infinity;
+                            minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
                         }
                         if (genPaths) {
                             getPaths(destVertex);
@@ -618,7 +618,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         const paths = [];
         const distMap = new Map();
         const preMap = new Map(); // predecessor
-        let min = Infinity;
+        let min = Number.MAX_SAFE_INTEGER;
         let minPath = [];
         // TODO
         let hasNegativeCycle;
@@ -631,7 +631,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         const edgeMap = this.edgeSet();
         const numOfEdges = edgeMap.length;
         this._vertexMap.forEach(vertex => {
-            distMap.set(vertex, Infinity);
+            distMap.set(vertex, Number.MAX_SAFE_INTEGER);
         });
         distMap.set(srcVertex, 0);
         for (let i = 1; i < numOfVertices; ++i) {
@@ -643,7 +643,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
                     const sWeight = distMap.get(s);
                     const dWeight = distMap.get(d);
                     if (sWeight !== undefined && dWeight !== undefined) {
-                        if (distMap.get(s) !== Infinity && sWeight + weight < dWeight) {
+                        if (distMap.get(s) !== Number.MAX_SAFE_INTEGER && sWeight + weight < dWeight) {
                             distMap.set(d, sWeight + weight);
                             if (genPath)
                                 preMap.set(d, s);
@@ -688,7 +688,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
                 const weight = edgeMap[j].weight;
                 const sWeight = distMap.get(s);
                 if (sWeight) {
-                    if (sWeight !== Infinity && sWeight + weight < sWeight)
+                    if (sWeight !== Number.MAX_SAFE_INTEGER && sWeight + weight < sWeight)
                         hasNegativeCycle = true;
                 }
             }
@@ -738,7 +738,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         }
         for (let i = 0; i < n; i++) {
             for (let j = 0; j < n; j++) {
-                costs[i][j] = ((_a = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])) === null || _a === void 0 ? void 0 : _a.weight) || Infinity;
+                costs[i][j] = ((_a = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])) === null || _a === void 0 ? void 0 : _a.weight) || Number.MAX_SAFE_INTEGER;
             }
         }
         for (let k = 0; k < n; k++) {

package/dist/data-structures/hash/hash-map.d.ts

@@ -13,6 +13,52 @@ import { IterableEntryBase } from '../base';
  * 3. Unique Keys: Keys are unique.
  * If you try to insert another entry with the same key, the new one will replace the old entry.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
+ * @example
+ * // should maintain insertion order
+ *     const linkedHashMap = new LinkedHashMap<number, string>();
+ *     linkedHashMap.set(1, 'A');
+ *     linkedHashMap.set(2, 'B');
+ *     linkedHashMap.set(3, 'C');
+ *
+ *     const result = Array.from(linkedHashMap);
+ *     console.log(result); // [
+ *  //      [1, 'A'],
+ *  //      [2, 'B'],
+ *  //      [3, 'C']
+ *  //    ]
+ * @example
+ * // fast lookup of values by key
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(3, 'C');
+ *
+ *     console.log(hashMap.get(1)); // 'A'
+ *     console.log(hashMap.get(2)); // 'B'
+ *     console.log(hashMap.get(3)); // 'C'
+ *     console.log(hashMap.get(99)); // undefined
+ * @example
+ * // remove duplicates when adding multiple entries
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(1, 'C'); // Update value for key 1
+ *
+ *     console.log(hashMap.size); // 2
+ *     console.log(hashMap.get(1)); // 'C'
+ *     console.log(hashMap.get(2)); // 'B'
+ * @example
+ * // count occurrences of keys
+ *     const data = [1, 2, 1, 3, 2, 1];
+ *
+ *     const countMap = new HashMap<number, number>();
+ *     for (const key of data) {
+ *       countMap.set(key, (countMap.get(key) || 0) + 1);
+ *     }
+ *
+ *     console.log(countMap.get(1)); // 3
+ *     console.log(countMap.get(2)); // 2
+ *     console.log(countMap.get(3)); // 1
  */
 export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
     /**

package/dist/data-structures/hash/hash-map.js

@@ -9,6 +9,52 @@ const utils_1 = require("../../utils");
  * 3. Unique Keys: Keys are unique.
  * If you try to insert another entry with the same key, the new one will replace the old entry.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
+ * @example
+ * // should maintain insertion order
+ *     const linkedHashMap = new LinkedHashMap<number, string>();
+ *     linkedHashMap.set(1, 'A');
+ *     linkedHashMap.set(2, 'B');
+ *     linkedHashMap.set(3, 'C');
+ *
+ *     const result = Array.from(linkedHashMap);
+ *     console.log(result); // [
+ *  //      [1, 'A'],
+ *  //      [2, 'B'],
+ *  //      [3, 'C']
+ *  //    ]
+ * @example
+ * // fast lookup of values by key
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(3, 'C');
+ *
+ *     console.log(hashMap.get(1)); // 'A'
+ *     console.log(hashMap.get(2)); // 'B'
+ *     console.log(hashMap.get(3)); // 'C'
+ *     console.log(hashMap.get(99)); // undefined
+ * @example
+ * // remove duplicates when adding multiple entries
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(1, 'C'); // Update value for key 1
+ *
+ *     console.log(hashMap.size); // 2
+ *     console.log(hashMap.get(1)); // 'C'
+ *     console.log(hashMap.get(2)); // 'B'
+ * @example
+ * // count occurrences of keys
+ *     const data = [1, 2, 1, 3, 2, 1];
+ *
+ *     const countMap = new HashMap<number, number>();
+ *     for (const key of data) {
+ *       countMap.set(key, (countMap.get(key) || 0) + 1);
+ *     }
+ *
+ *     console.log(countMap.get(1)); // 3
+ *     console.log(countMap.get(2)); // 2
+ *     console.log(countMap.get(3)); // 1
  */
 class HashMap extends base_1.IterableEntryBase {
     /**

package/dist/data-structures/heap/heap.d.ts

@@ -183,7 +183,7 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>> {
+export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
     /**
      * The constructor initializes a heap data structure with optional elements and options.
      * @param elements - The `elements` parameter is an iterable object that contains the initial
@@ -308,14 +308,6 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, He
      * @returns An array containing elements traversed in the specified order.
      */
     dfs(order?: DFSOrderPattern): E[];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * Convert the heap to an array.
-     * @returns An array containing the elements of the heap.
-     */
-    toArray(): E[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -355,7 +347,7 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, He
      * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
      * the filter condition specified by the `callback` function.
      */
-    filter(callback: ElementCallback<E, R, boolean, Heap<E, R>>, thisArg?: any): Heap<E, R>;
+    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): Heap<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -377,7 +369,7 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, He
      * value of
      * @returns a new instance of the `Heap` class with the mapped elements.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, Heap<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Heap<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Heap<EM, RM>;
     protected _DEFAULT_COMPARATOR: (a: E, b: E) => number;
     protected _comparator: Comparator<E>;
     /**

package/dist/data-structures/heap/heap.js

@@ -413,16 +413,6 @@ class Heap extends base_1.IterableElementBase {
         _dfs(0); // Traverse starting from the root node
         return result;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * Convert the heap to an array.
-     * @returns An array containing the elements of the heap.
-     */
-    toArray() {
-        return [...this.elements];
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/data-structures/heap/max-heap.d.ts

@@ -42,7 +42,7 @@ export declare class MaxHeap<E = any, R = any> extends Heap<E, R> {
      * @returns The `filter` method is returning a new `MaxHeap` object that contains the elements that pass
      * the filter condition specified by the `callback` function.
      */
-    filter(callback: ElementCallback<E, R, boolean, MaxHeap<E, R>>, thisArg?: any): MaxHeap<E, R>;
+    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MaxHeap<E, R>;
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -64,5 +64,5 @@ export declare class MaxHeap<E = any, R = any> extends Heap<E, R> {
      * value of
      * @returns a new instance of the `MaxHeap` class with the mapped elements.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, MaxHeap<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MaxHeap<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MaxHeap<EM, RM>;
 }

package/dist/data-structures/heap/min-heap.d.ts

@@ -42,7 +42,7 @@ export declare class MinHeap<E = any, R = any> extends Heap<E, R> {
      * @returns The `filter` method is returning a new `MinHeap` object that contains the elements that pass
      * the filter condition specified by the `callback` function.
      */
-    filter(callback: ElementCallback<E, R, boolean, MinHeap<E, R>>, thisArg?: any): MinHeap<E, R>;
+    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MinHeap<E, R>;
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -64,5 +64,5 @@ export declare class MinHeap<E = any, R = any> extends Heap<E, R> {
      * value of
      * @returns a new instance of the `MinHeap` class with the mapped elements.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, MinHeap<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MinHeap<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MinHeap<EM, RM>;
 }