linked-list-typed 1.48.1 → 1.48.2

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

@@ -5,8 +5,9 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
-export declare class HashMap<K = any, V = any> {
+import { HashMapLinkedNode, HashMapOptions, HashMapStoreItem, PairCallback } from '../../types';
+import { IterablePairBase } from "../base";
+export declare class HashMap<K = any, V = any> extends IterablePairBase<K, V> {
     protected _store: {
         [key: string]: HashMapStoreItem<K, V>;
     };
@@ -67,55 +68,13 @@ export declare class HashMap<K = any, V = any> {
      */
     delete(key: K): boolean;
     /**
-     * The function returns an iterator that yields key-value pairs from both an object store and an
-     * object map.
-     */
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    /**
-     * The function returns an iterator that yields key-value pairs from the object.
-     */
-    entries(): IterableIterator<[K, V]>;
-    /**
-     * The function `keys()` returns an iterator that yields all the keys of the object.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    /**
-     * The `every` function checks if every element in a HashMap satisfies a given predicate function.
-     * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
-     * index, and map. It is used to test each element in the map against a condition. If the predicate
-     * function returns false for any element, the every() method will return false. If the predicate
-     * function returns true for all
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `predicate` function. If `thisArg` is
-     * @returns The method is returning a boolean value. It returns true if the predicate function
-     * returns true for every element in the map, and false otherwise.
-     */
-    every(predicate: (value: V, key: K, index: number, map: HashMap<K, V>) => boolean, thisArg?: any): boolean;
-    /**
-     * The "some" function checks if at least one element in a HashMap satisfies a given predicate.
-     * @param predicate - The `predicate` parameter is a function that takes four arguments: `value`,
-     * `key`, `index`, and `map`. It is used to determine whether a specific condition is met for a given
-     * key-value pair in the `HashMap`.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `predicate` function. If `thisArg` is
-     * @returns a boolean value. It returns true if the predicate function returns true for any element
-     * in the map, and false otherwise.
-     */
-    some(predicate: (value: V, key: K, index: number, map: HashMap<K, V>) => boolean, thisArg?: any): boolean;
-    /**
-     * The `forEach` function iterates over the elements of a HashMap and applies a callback function to
-     * each element.
-     * @param callbackfn - A function that will be called for each key-value pair in the HashMap. It
-     * takes four parameters:
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
-     * be passed as the `this` value inside the `callbackfn` function. If `thisArg
-     */
-    forEach(callbackfn: (value: V, key: K, index: number, map: HashMap<K, V>) => void, thisArg?: any): void;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The `map` function in TypeScript creates a new HashMap by applying a callback function to each
      * key-value pair in the original HashMap.
      * @param callbackfn - The callback function that will be called for each key-value pair in the
@@ -126,8 +85,15 @@ export declare class HashMap<K = any, V = any> {
      * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
      * the provided callback function.
      */
-    map<U>(callbackfn: (value: V, key: K, index: number, map: HashMap<K, V>) => U, thisArg?: any): HashMap<K, U>;
+    map<U>(callbackfn: PairCallback<K, V, U>, thisArg?: any): HashMap<K, U>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The `filter` function creates a new HashMap containing key-value pairs from the original HashMap
      * that satisfy a given predicate function.
      * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
@@ -140,25 +106,18 @@ export declare class HashMap<K = any, V = any> {
      * @returns The `filter` method is returning a new `HashMap` object that contains the key-value pairs
      * from the original `HashMap` that pass the provided `predicate` function.
      */
-    filter(predicate: (value: V, key: K, index: number, map: HashMap<K, V>) => boolean, thisArg?: any): HashMap<K, V>;
+    filter(predicate: PairCallback<K, V, boolean>, thisArg?: any): HashMap<K, V>;
+    print(): void;
     /**
-     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
-     * each element, accumulating a single value.
-     * @param callbackfn - The callback function that will be called for each element in the HashMap. It
-     * takes five parameters:
-     * @param {U} initialValue - The initialValue parameter is the initial value of the accumulator. It
-     * is the value that will be used as the first argument of the callback function when reducing the
-     * elements of the map.
-     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
-     * all the elements in the `HashMap`.
+     * The function returns an iterator that yields key-value pairs from both an object store and an
+     * object map.
      */
-    reduce<U>(callbackfn: (accumulator: U, currentValue: V, currentKey: K, index: number, map: HashMap<K, V>) => U, initialValue: U): U;
-    print(): void;
+    protected _getIterator(): IterableIterator<[K, V]>;
     protected _hashFn: (key: K) => string;
     protected _isObjKey(key: any): key is (object | ((...args: any[]) => any));
     protected _getNoObjKey(key: K): string;
 }
-export declare class LinkedHashMap<K = any, V = any> {
+export declare class LinkedHashMap<K = any, V = any> extends IterablePairBase<K, V> {
     protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
     protected _objMap: WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
     protected _head: HashMapLinkedNode<K, V | undefined>;
@@ -211,8 +170,6 @@ export declare class LinkedHashMap<K = any, V = any> {
     set(key: K, value?: V): number;
     has(key: K): boolean;
     setMany(entries: Iterable<[K, V]>): void;
-    keys(): K[];
-    values(): V[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -278,53 +235,55 @@ export declare class LinkedHashMap<K = any, V = any> {
     clear(): void;
     clone(): LinkedHashMap<K, V>;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in a LinkedHashMap and executes a callback function on
-     * each element.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * LinkedHashMap. It takes three arguments:
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    forEach(callback: (element: [K, V], index: number, hashMap: LinkedHashMap<K, V>) => void): void;
     /**
-     * The `filter` function takes a predicate function and returns a new LinkedHashMap containing only the
-     * key-value pairs that satisfy the predicate.
-     * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
-     * `map`.
-     * @returns a new LinkedHashMap object that contains the key-value pairs from the original LinkedHashMap that
-     * satisfy the given predicate function.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new `LinkedHashMap` containing key-value pairs from the original
+     * map that satisfy a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+     * `value`, `key`, `index`, and `this`. It should return a boolean value indicating whether the
+     * current element should be included in the filtered map or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is not provided, `this
+     * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
+     * `LinkedHashMap` object that satisfy the given predicate function.
      */
-    filter(predicate: (element: [K, V], index: number, map: LinkedHashMap<K, V>) => boolean): LinkedHashMap<K, V>;
+    filter(predicate: PairCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V>;
     /**
-     * The `map` function takes a callback function and returns a new LinkedHashMap with the values transformed
-     * by the callback.
-     * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
-     * `map`.
-     * @returns a new LinkedHashMap object with the values mapped according to the provided callback function.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    map<NV>(callback: (element: [K, V], index: number, map: LinkedHashMap<K, V>) => NV): LinkedHashMap<K, NV>;
     /**
-     * The `reduce` function iterates over the elements of a LinkedHashMap and applies a callback function to
-     * each element, accumulating a single value.
-     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
-     * element, and map. It is called for each element in the LinkedHashMap and is used to accumulate a single
-     * result.
-     * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
-     * is the value that will be passed as the first argument to the `callback` function when reducing
-     * the elements of the map.
-     * @returns The `reduce` function is returning the final value of the accumulator after iterating
-     * over all the elements in the LinkedHashMap and applying the callback function to each element.
-     */
-    reduce<A>(callback: (accumulator: A, element: [K, V], index: number, map: LinkedHashMap<K, V>) => A, initialValue: A): A;
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new `LinkedHashMap` by applying a callback function to
+     * each key-value pair in the original map.
+     * @param callback - The callback parameter is a function that will be called for each key-value pair
+     * in the map. It takes four arguments: the value of the current key-value pair, the key of the
+     * current key-value pair, the index of the current key-value pair, and the map itself. The callback
+     * function should
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If provided, the callback function will
+     * be called with `thisArg` as its `this` value. If not provided, `this` will refer to the current
+     * map
+     * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
+     * function.
+     */
+    map<NV>(callback: PairCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
+    print(): void;
     /**
      * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.
      */
-    [Symbol.iterator](): Generator<[K, V], void, unknown>;
-    print(): void;
+    protected _getIterator(): Generator<[K, V], void, unknown>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -9,7 +9,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LinkedHashMap = exports.HashMap = void 0;
 const utils_1 = require("../../utils");
-class HashMap {
+const base_1 = require("../base");
+class HashMap extends base_1.IterablePairBase {
     /**
      * The constructor function initializes a new instance of a class with optional elements and options.
      * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
@@ -19,6 +20,7 @@ class HashMap {
      * configuration options for the constructor. In this case, it has one property:
      */
     constructor(elements = [], options) {
+        super();
         this._store = {};
         this._objMap = new Map();
         this._size = 0;
@@ -135,95 +137,13 @@ class HashMap {
         }
     }
     /**
-     * The function returns an iterator that yields key-value pairs from both an object store and an
-     * object map.
-     */
-    *[Symbol.iterator]() {
-        for (const node of Object.values(this._store)) {
-            yield [node.key, node.value];
-        }
-        for (const node of this._objMap) {
-            yield node;
-        }
-    }
-    /**
-     * The function returns an iterator that yields key-value pairs from the object.
-     */
-    *entries() {
-        for (const item of this) {
-            yield item;
-        }
-    }
-    /**
-     * The function `keys()` returns an iterator that yields all the keys of the object.
-     */
-    *keys() {
-        for (const [key] of this) {
-            yield key;
-        }
-    }
-    *values() {
-        for (const [, value] of this) {
-            yield value;
-        }
-    }
-    /**
-     * The `every` function checks if every element in a HashMap satisfies a given predicate function.
-     * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
-     * index, and map. It is used to test each element in the map against a condition. If the predicate
-     * function returns false for any element, the every() method will return false. If the predicate
-     * function returns true for all
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `predicate` function. If `thisArg` is
-     * @returns The method is returning a boolean value. It returns true if the predicate function
-     * returns true for every element in the map, and false otherwise.
-     */
-    every(predicate, thisArg) {
-        let index = 0;
-        for (const [key, value] of this) {
-            if (!predicate.call(thisArg, value, key, index++, this)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * The "some" function checks if at least one element in a HashMap satisfies a given predicate.
-     * @param predicate - The `predicate` parameter is a function that takes four arguments: `value`,
-     * `key`, `index`, and `map`. It is used to determine whether a specific condition is met for a given
-     * key-value pair in the `HashMap`.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `predicate` function. If `thisArg` is
-     * @returns a boolean value. It returns true if the predicate function returns true for any element
-     * in the map, and false otherwise.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    some(predicate, thisArg) {
-        let index = 0;
-        for (const [key, value] of this) {
-            if (predicate.call(thisArg, value, key, index++, this)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * The `forEach` function iterates over the elements of a HashMap and applies a callback function to
-     * each element.
-     * @param callbackfn - A function that will be called for each key-value pair in the HashMap. It
-     * takes four parameters:
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
-     * be passed as the `this` value inside the `callbackfn` function. If `thisArg
-     */
-    forEach(callbackfn, thisArg) {
-        let index = 0;
-        for (const [key, value] of this) {
-            callbackfn.call(thisArg, value, key, index++, this);
-        }
-    }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The `map` function in TypeScript creates a new HashMap by applying a callback function to each
      * key-value pair in the original HashMap.
      * @param callbackfn - The callback function that will be called for each key-value pair in the
@@ -243,6 +163,13 @@ class HashMap {
         return resultMap;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The `filter` function creates a new HashMap containing key-value pairs from the original HashMap
      * that satisfy a given predicate function.
      * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
@@ -265,27 +192,20 @@ class HashMap {
         }
         return filteredMap;
     }
+    print() {
+        console.log([...this.entries()]);
+    }
     /**
-     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
-     * each element, accumulating a single value.
-     * @param callbackfn - The callback function that will be called for each element in the HashMap. It
-     * takes five parameters:
-     * @param {U} initialValue - The initialValue parameter is the initial value of the accumulator. It
-     * is the value that will be used as the first argument of the callback function when reducing the
-     * elements of the map.
-     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
-     * all the elements in the `HashMap`.
+     * The function returns an iterator that yields key-value pairs from both an object store and an
+     * object map.
      */
-    reduce(callbackfn, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const [key, value] of this) {
-            accumulator = callbackfn(accumulator, value, key, index++, this);
+    *_getIterator() {
+        for (const node of Object.values(this._store)) {
+            yield [node.key, node.value];
+        }
+        for (const node of this._objMap) {
+            yield node;
         }
-        return accumulator;
-    }
-    print() {
-        console.log([...this.entries()]);
     }
     _isObjKey(key) {
         const keyType = typeof key;
@@ -310,11 +230,12 @@ class HashMap {
     }
 }
 exports.HashMap = HashMap;
-class LinkedHashMap {
+class LinkedHashMap extends base_1.IterablePairBase {
     constructor(elements, options = {
         hashFn: (key) => String(key),
         objHashFn: (key) => key
     }) {
+        super();
         this._noObjMap = {};
         this._objMap = new WeakMap();
         this._size = 0;
@@ -450,18 +371,6 @@ class LinkedHashMap {
             this.set(key, value);
         }
     }
-    keys() {
-        const keys = [];
-        for (const [key] of this)
-            keys.push(key);
-        return keys;
-    }
-    values() {
-        const values = [];
-        for (const [, value] of this)
-            values.push(value);
-        return values;
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -591,35 +500,29 @@ class LinkedHashMap {
         return cloned;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in a LinkedHashMap and executes a callback function on
-     * each element.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * LinkedHashMap. It takes three arguments:
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    forEach(callback) {
-        let index = 0;
-        let node = this._head;
-        while (node !== this._sentinel) {
-            callback([node.key, node.value], index++, this);
-            node = node.next;
-        }
-    }
     /**
-     * The `filter` function takes a predicate function and returns a new LinkedHashMap containing only the
-     * key-value pairs that satisfy the predicate.
-     * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
-     * `map`.
-     * @returns a new LinkedHashMap object that contains the key-value pairs from the original LinkedHashMap that
-     * satisfy the given predicate function.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new `LinkedHashMap` containing key-value pairs from the original
+     * map that satisfy a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+     * `value`, `key`, `index`, and `this`. It should return a boolean value indicating whether the
+     * current element should be included in the filtered map or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is not provided, `this
+     * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
+     * `LinkedHashMap` object that satisfy the given predicate function.
      */
-    filter(predicate) {
+    filter(predicate, thisArg) {
         const filteredMap = new LinkedHashMap();
         let index = 0;
         for (const [key, value] of this) {
-            if (predicate([key, value], index, this)) {
+            if (predicate.call(thisArg, value, key, index, this)) {
                 filteredMap.set(key, value);
             }
             index++;
@@ -627,42 +530,38 @@ class LinkedHashMap {
         return filteredMap;
     }
     /**
-     * The `map` function takes a callback function and returns a new LinkedHashMap with the values transformed
-     * by the callback.
-     * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
-     * `map`.
-     * @returns a new LinkedHashMap object with the values mapped according to the provided callback function.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    map(callback) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new `LinkedHashMap` by applying a callback function to
+     * each key-value pair in the original map.
+     * @param callback - The callback parameter is a function that will be called for each key-value pair
+     * in the map. It takes four arguments: the value of the current key-value pair, the key of the
+     * current key-value pair, the index of the current key-value pair, and the map itself. The callback
+     * function should
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If provided, the callback function will
+     * be called with `thisArg` as its `this` value. If not provided, `this` will refer to the current
+     * map
+     * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
+     * function.
+     */
+    map(callback, thisArg) {
         const mappedMap = new LinkedHashMap();
         let index = 0;
         for (const [key, value] of this) {
-            const newValue = callback([key, value], index, this);
+            const newValue = callback.call(thisArg, value, key, index, this);
             mappedMap.set(key, newValue);
             index++;
         }
         return mappedMap;
     }
-    /**
-     * The `reduce` function iterates over the elements of a LinkedHashMap and applies a callback function to
-     * each element, accumulating a single value.
-     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
-     * element, and map. It is called for each element in the LinkedHashMap and is used to accumulate a single
-     * result.
-     * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
-     * is the value that will be passed as the first argument to the `callback` function when reducing
-     * the elements of the map.
-     * @returns The `reduce` function is returning the final value of the accumulator after iterating
-     * over all the elements in the LinkedHashMap and applying the callback function to each element.
-     */
-    reduce(callback, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const entry of this) {
-            accumulator = callback(accumulator, entry, index, this);
-            index++;
-        }
-        return accumulator;
+    print() {
+        console.log([...this]);
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
@@ -670,16 +569,13 @@ class LinkedHashMap {
      *
      * The above function is an iterator that yields key-value pairs from a linked list.
      */
-    *[Symbol.iterator]() {
+    *_getIterator() {
         let node = this._head;
         while (node !== this._sentinel) {
             yield [node.key, node.value];
             node = node.next;
         }
     }
-    print() {
-        console.log([...this]);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -4,9 +4,10 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { Comparator, DFSOrderPattern } from '../../types';
+import type { Comparator, DFSOrderPattern, ElementCallback } from '../../types';
 import { HeapOptions } from "../../types";
-export declare class Heap<E = any> {
+import { IterableElementBase } from "../base";
+export declare class Heap<E = any> extends IterableElementBase<E> {
     options: HeapOptions<E>;
     constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
     protected _elements: E[];
@@ -192,16 +193,58 @@ export declare class Heap<E = any> {
      * Fix the entire heap to maintain heap properties.
      */
     fix(): void;
-    [Symbol.iterator](): Generator<E, void, unknown>;
-    forEach(callback: (element: E, index: number, heap: this) => void): void;
-    filter(predicate: (element: E, index: number, heap: Heap<E>) => boolean): Heap<E>;
-    map<T>(callback: (element: E, index: number, heap: Heap<E>) => T, comparator: Comparator<T>): Heap<T>;
-    reduce<T>(callback: (accumulator: T, currentValue: E, currentIndex: number, heap: Heap<E>) => T, initialValue: T): T;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new Heap object containing elements that pass a given callback
+     * function.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: the current element, the index of the current element, and the
+     * heap itself. The callback function should return a boolean value indicating whether the current
+     * element should be included in the filtered list
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @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)
+     */
+    /**
+     * Time Complexity: O(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 {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.
+     */
+    map<T>(callback: ElementCallback<E, T>, comparator: Comparator<T>, thisArg?: any): Heap<T>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     print(): void;
+    protected _getIterator(): Generator<E, void, unknown>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)