data-structure-typed 1.51.9 → 1.52.0

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNCallback, BTNEntry, Comparable, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, KeyOrNodeOrEntry, NodeDisplayLayout } from '../../types';
+import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNCallback, BTNEntry, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, KeyOrNodeOrEntry, NodeDisplayLayout } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { IterableEntryBase } from '../base';
 /**
@@ -13,7 +13,7 @@ import { IterableEntryBase } from '../base';
  * @template V - The type of data stored in the node.
  * @template NODE - The type of the family relationship in the binary tree.
  */
-export declare class BinaryTreeNode<K extends Comparable, V = any, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> {
+export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> {
     key: K;
     value?: V;
     parent?: NODE;
@@ -65,11 +65,11 @@ export declare class BinaryTreeNode<K extends Comparable, V = any, NODE extends
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
  */
-export declare class BinaryTree<K extends Comparable, V = any, R = BTNEntry<K, V>, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTree<K, V, R, NODE, BinaryTreeNested<K, V, R, NODE>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTree<K, V, R, NODE, BinaryTreeNested<K, V, R, NODE>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, R, NODE, TREE> {
     iterationType: IterationType;
     /**
      * The constructor function initializes a binary tree object with optional keysOrNodesOrEntriesOrRawElements and options.
-     * @param [keysOrNodesOrEntriesOrRawElements] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * @param [keysOrNodesOrEntriesOrRawElements] - Optional iterable of KeyOrNodeOrEntry objects. These objects represent the
      * nodes to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type

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

@@ -98,7 +98,7 @@ export class BinaryTree extends IterableEntryBase {
     iterationType = 'ITERATIVE';
     /**
      * The constructor function initializes a binary tree object with optional keysOrNodesOrEntriesOrRawElements and options.
-     * @param [keysOrNodesOrEntriesOrRawElements] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * @param [keysOrNodesOrEntriesOrRawElements] - Optional iterable of KeyOrNodeOrEntry objects. These objects represent the
      * nodes to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
@@ -113,6 +113,8 @@ export class BinaryTree extends IterableEntryBase {
                 this.iterationType = iterationType;
             if (typeof toEntryFn === 'function')
                 this._toEntryFn = toEntryFn;
+            else if (toEntryFn)
+                throw TypeError('toEntryFn must be a function type');
         }
         if (keysOrNodesOrEntriesOrRawElements)
             this.addMany(keysOrNodesOrEntriesOrRawElements);
@@ -1698,12 +1700,12 @@ export class BinaryTree extends IterableEntryBase {
         }
         else if (node !== null && node !== undefined) {
             // Display logic of normal nodes
-            const key = node.key, line = this.isNIL(node) ? 'S' : key.toString(), width = line.length;
+            const key = node.key, line = this.isNIL(node) ? 'S' : String(key), width = line.length;
             return _buildNodeDisplay(line, width, this._displayAux(node.left, options), this._displayAux(node.right, options));
         }
         else {
             // For cases where none of the conditions are met, null, undefined, and NaN nodes are not displayed
-            const line = node === undefined ? 'U' : 'NODE', width = line.length;
+            const line = node === undefined ? 'U' : 'N', width = line.length;
             return _buildNodeDisplay(line, width, [[''], 1, 0, 0], [[''], 1, 0, 0]);
         }
         function _buildNodeDisplay(line, width, left, right) {

package/dist/mjs/data-structures/binary-tree/bst.d.ts

@@ -5,11 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, Comparable, Comparator, CP, DFSOrderPattern, IterationType, KeyOrNodeOrEntry } from '../../types';
+import type { BSTNested, BSTNKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, Comparator, CP, DFSOrderPattern, IterationType, KeyOrNodeOrEntry } from '../../types';
 import { BTNEntry } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
-export declare class BSTNode<K extends Comparable, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, NODE> {
+export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, NODE> {
     parent?: NODE;
     constructor(key: K, value?: V);
     protected _left?: NODE;
@@ -47,7 +47,7 @@ export declare class BSTNode<K extends Comparable, V = any, NODE extends BSTNode
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
  */
-export declare class BST<K extends Comparable, V = any, R = BTNEntry<K, V>, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, R, NODE, TREE> = BST<K, V, R, NODE, BSTNested<K, V, R, NODE>>> extends BinaryTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, R, NODE, TREE> = BST<K, V, R, NODE, BSTNested<K, V, R, NODE>>> extends BinaryTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * This is the constructor function for a Binary Search Tree class in TypeScript.
      * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
@@ -349,15 +349,7 @@ export declare class BST<K extends Comparable, V = any, R = BTNEntry<K, V>, NODE
      * @returns a boolean value.
      */
     isAVLBalanced(iterationType?: IterationType): boolean;
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     protected _DEFAULT_COMPARATOR: (a: K, b: K) => number;
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     protected _comparator: Comparator<K>;
     /**
      * Time Complexity: O(n)

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

@@ -687,13 +687,9 @@ export class BST extends BinaryTree {
         }
         return balanced;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     _DEFAULT_COMPARATOR = (a, b) => {
-        if (typeof a === 'object' && typeof b === 'object' && this.comparator === this._DEFAULT_COMPARATOR) {
-            throw TypeError('When comparing two object types, it is necessary to customize a [comparator] function of options parameter during the instantiation of the data structure.');
+        if (typeof a === 'object' || typeof b === 'object') {
+            throw TypeError(`When comparing object types, a custom comparator must be defined in the constructor's options parameter.`);
         }
         if (a > b)
             return 1;
@@ -701,10 +697,6 @@ export class BST extends BinaryTree {
             return -1;
         return 0;
     };
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     _comparator = this._DEFAULT_COMPARATOR;
     /**
      * Time Complexity: O(n)

package/dist/mjs/data-structures/binary-tree/rb-tree.d.ts

@@ -1,8 +1,8 @@
-import type { BinaryTreeDeleteResult, BTNCallback, Comparable, CRUD, KeyOrNodeOrEntry, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import type { BinaryTreeDeleteResult, BTNCallback, CRUD, KeyOrNodeOrEntry, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BTNEntry } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
-export declare class RedBlackTreeNode<K extends Comparable, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
+export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
     /**
      * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
      * color.
@@ -27,7 +27,7 @@ export declare class RedBlackTreeNode<K extends Comparable, V = any, NODE extend
      */
     set color(value: RBTNColor);
 }
-export declare class RedBlackTree<K extends Comparable, V = any, R = BTNEntry<K, V>, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, R, NODE, TREE> = RedBlackTree<K, V, R, NODE, RedBlackTreeNested<K, V, R, NODE>>> extends BST<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, R, NODE, TREE> = RedBlackTree<K, V, R, NODE, RedBlackTreeNested<K, V, R, NODE>>> extends BST<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
      * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an

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

@@ -5,11 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, Comparable, IterationType, KeyOrNodeOrEntry, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
 import { BTNEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
-export declare class TreeMultiMapNode<K extends Comparable, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
+export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
     /**
      * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
      * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
@@ -36,7 +36,7 @@ export declare class TreeMultiMapNode<K extends Comparable, V = any, NODE extend
      */
     set count(value: number);
 }
-export declare class TreeMultiMap<K extends Comparable, V = any, R = BTNEntry<K, V>, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, R, NODE, TREE> = TreeMultiMap<K, V, R, NODE, TreeMultiMapNested<K, V, R, NODE>>> extends RedBlackTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, R, NODE, TREE> = TreeMultiMap<K, V, R, NODE, TreeMultiMapNested<K, V, R, NODE>>> extends RedBlackTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
      * @param keysOrNodesOrEntriesOrRawElements - The parameter `keysOrNodesOrEntriesOrRawElements` is an

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

@@ -150,7 +150,7 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
      * the provided callback function.
      */
-    map<U>(callbackfn: EntryCallback<K, V, U>, thisArg?: any): HashMap<K, U>;
+    map<VM>(callbackfn: EntryCallback<K, V, VM>, thisArg?: any): HashMap<K, VM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -482,7 +482,7 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
      * function.
      */
-    map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
+    map<VM>(callback: EntryCallback<K, V, VM>, thisArg?: any): LinkedHashMap<K, VM>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -16,30 +16,27 @@ import { IterableElementBase } from '../base';
  * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
  * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
  * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
- * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
+ * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prime's minimum-spanning tree algorithm, which use heaps to improve performance.
  */
-export declare class Heap<E = any> extends IterableElementBase<E> {
+export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<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
-     * elements to be added to the heap. It is an optional parameter and if not provided, the heap will
+     * elements to be added to the heap.
+     * It is an optional parameter, and if not provided, the heap will
      * be initialized as empty.
      * @param [options] - The `options` parameter is an optional object that can contain additional
-     * configuration options for the heap. In this case, it is used to specify a custom comparator
-     * function for comparing elements in the heap. The comparator function is used to determine the
+     * configuration options for the heap.
+     * In this case, it is used to specify a custom comparator
+     * function for comparing elements in the heap.
+     * The comparator function is used to determine the
      * order of elements in the heap.
      */
-    constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
-    protected _comparator: (a: E, b: E) => number;
-    /**
-     * The function returns the value of the _comparator property.
-     * @returns The `_comparator` property is being returned.
-     */
-    get comparator(): (a: E, b: E) => number;
+    constructor(elements?: Iterable<E> | Iterable<R>, options?: HeapOptions<E, R>);
     protected _elements: E[];
     /**
      * The function returns an array of elements.
-     * @returns The elements array is being returned.
+     * @returns The element array is being returned.
      */
     get elements(): E[];
     /**
@@ -57,12 +54,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @param elements
      * @param options
      */
-    static heapify<E>(elements: Iterable<E>, options: HeapOptions<E>): Heap<E>;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     * where n is the number of elements in the heap.
-     */
+    static heapify<E = any, R = any>(elements: Iterable<E>, options: HeapOptions<E, R>): Heap<E>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -71,23 +63,14 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @param element - The element to be inserted.
      */
     add(element: E): boolean;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     * where n is the number of elements in the heap.
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Remove and return the top element (smallest or largest element) from the heap.
+     * Remove and return the top element (the smallest or largest element) from the heap.
      * @returns The top element or undefined if the heap is empty.
      */
     poll(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -105,10 +88,6 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * Reset the elements of the heap. Make the elements empty.
      */
     clear(): void;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -117,10 +96,6 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @param elements
      */
     refill(elements: E[]): boolean[];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -131,12 +106,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     has(element: E): boolean;
     /**
-     * Time Complexity:  O(n)
-     * Space Complexity: O(1)
-     * The worst-case  O(n) This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
-     */
-    /**
-     * Time Complexity:  O(n)
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes an element from an array-like data structure, maintaining the order
@@ -147,11 +117,6 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * successfully deleted from the array, and `false` if the element was not found in the array.
      */
     delete(element: E): boolean;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     * where log n is the height of the heap.
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -161,10 +126,6 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @returns An array containing elements traversed in the specified order.
      */
     dfs(order?: DFSOrderPattern): E[];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -173,10 +134,6 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @returns An array containing the elements of the heap.
      */
     toArray(): E[];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -184,11 +141,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * Clone the heap, creating a new heap with the same elements.
      * @returns A new Heap instance containing the same elements.
      */
-    clone(): Heap<E>;
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     */
+    clone(): Heap<E, R>;
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -197,10 +150,6 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @returns An array containing the elements sorted in ascending order.
      */
     sort(): E[];
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -208,10 +157,6 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * Fix the entire heap to maintain heap properties.
      */
     fix(): boolean[];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -228,40 +173,40 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @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, boolean>, thisArg?: any): Heap<E>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
+    filter(callback: ElementCallback<E, R, boolean, Heap<E, R>>, thisArg?: any): Heap<E, R>;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(n log n)
      * Space Complexity: O(n)
      *
      * The `map` function creates a new heap by applying a callback function to each element of the
      * original heap.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * original heap. It takes three arguments: the current element, the index of the current element,
-     * and the original heap itself. The callback function should return a value of type T, which will be
-     * added to the mapped heap.
-     * @param comparator - The `comparator` parameter is a function that is used to compare elements in
-     * the heap. It takes two arguments, `a` and `b`, and returns a negative number if `a` is less than
-     * `b`, a positive number if `a` is greater than `b`, or
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
+     * element), and `this` (the heap itself). The callback function should return a value of
+     * @param comparator - The `comparator` parameter is a function that defines the order of the
+     * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
+     * if `a` should be placed before `b`, a positive number if `a` should be placed after
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
+     * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
+     * returns a value of type `T`. This function is used to transform the elements of the original
      * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-     * specify the value of `this` within the callback function. It is used when you want to bind a
-     * specific object as the context for the callback function. If `thisArg` is not provided,
-     * `undefined` is used as
-     * @returns a new instance of the Heap class, which is created using the mapped elements from the
-     * original Heap.
+     * specify the value of `this` within the callback function. It is used to set the context or scope
+     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+     * value of
+     * @returns a new instance of the `Heap` class with the mapped elements.
      */
-    map<T>(callback: ElementCallback<E, T>, comparator: Comparator<T>, thisArg?: any): Heap<T>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM, Heap<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Heap<EM, RM>;
+    protected _DEFAULT_COMPARATOR: (a: E, b: E) => number;
+    protected _comparator: Comparator<E>;
     /**
-     * The function `_getIterator` returns an iterable iterator for the elements in the class.
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
      */
-    protected _getIterator(): IterableIterator<E>;
+    get comparator(): Comparator<E>;
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * The function `_getIterator` returns an iterable iterator for the elements in the class.
      */
+    protected _getIterator(): IterableIterator<E>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -270,10 +215,6 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @param index - The index of the newly added element.
      */
     protected _bubbleUp(index: number): boolean;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -343,10 +284,6 @@ export declare class FibonacciHeap<E> {
      * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.
      */
     clear(): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -356,10 +293,6 @@ export declare class FibonacciHeap<E> {
      * @returns {FibonacciHeap<E>} FibonacciHeap<E> - The heap itself.
      */
     add(element: E): FibonacciHeap<E>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -369,10 +302,6 @@ export declare class FibonacciHeap<E> {
      * @returns {FibonacciHeap<E>} FibonacciHeap<E> - The heap itself.
      */
     push(element: E): FibonacciHeap<E>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -412,7 +341,7 @@ export declare class FibonacciHeap<E> {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Remove and return the top element (smallest or largest element) from the heap.
+     * Remove and return the top element (the smallest or largest element) from the heap.
      * @returns The top element or undefined if the heap is empty.
      */
     poll(): E | undefined;
@@ -424,7 +353,7 @@ export declare class FibonacciHeap<E> {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Remove and return the top element (smallest or largest element) from the heap.
+     * Remove and return the top element (the smallest or largest element) from the heap.
      * @returns The top element or undefined if the heap is empty.
      */
     pop(): E | undefined;
@@ -472,8 +401,8 @@ export declare class FibonacciHeap<E> {
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     *.
-     * Remove and return the top element (smallest or largest element) from the heap.
+     *
+     * Remove and return the top element (the smallest or largest element) from the heap.
      * @param node - The node to be removed.
      * @protected
      */
@@ -486,7 +415,7 @@ export declare class FibonacciHeap<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * Remove and return the top element (smallest or largest element) from the heap.
+     * Remove and return the top element (the smallest or largest element) from the heap.
      * @param y
      * @param x
      * @protected
@@ -500,7 +429,7 @@ export declare class FibonacciHeap<E> {
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
      *
-     * Remove and return the top element (smallest or largest element) from the heap.
+     * Remove and return the top element (the smallest or largest element) from the heap.
      * @protected
      */
     protected _consolidate(): void;