heap-typed 1.51.9 → 1.52.1

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

@@ -4,26 +4,83 @@ exports.MinHeap = void 0;
 const heap_1 = require("./heap");
 /**
  * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.
- * 2. Heap Properties:  The value of each parent node is less than or equal to the value of its children.
+ * 2. MinHeap Properties:  The value of each parent node is less than or equal to the value of its children.
  * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
  * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
  * 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.
+ * 7. Efficient Sorting Algorithms: For example, heap sort. MinHeap 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.
  */
 class MinHeap extends heap_1.Heap {
-    constructor(elements = [], options = {
-        comparator: (a, b) => {
-            if (!(typeof a === 'number' && typeof b === 'number')) {
-                throw new Error('The a, b params of compare function must be number');
-            }
-            else {
-                return a - b;
+    constructor(elements = [], options) {
+        super(elements, options);
+    }
+    /**
+     * The `clone` function returns a new instance of the `MinHeap` class with the same comparator and
+     * toElementFn as the original instance.
+     * @returns The `clone()` method is returning a new instance of the `MinHeap` class with the same
+     * properties as the current instance.
+     */
+    clone() {
+        return new MinHeap(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new MinHeap 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 `MinHeap` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
+        const filteredList = new MinHeap([], { toElementFn: this.toElementFn, comparator: this.comparator });
+        let index = 0;
+        for (const current of this) {
+            if (callback.call(thisArg, current, index, this)) {
+                filteredList.add(current);
             }
+            index++;
         }
-    }) {
-        super(elements, options);
+        return filteredList;
+    }
+    /**
+     * 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 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 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 `MinHeap` class with the mapped elements.
+     */
+    map(callback, comparator, toElementFn, thisArg) {
+        const mappedHeap = new MinHeap([], { comparator, toElementFn });
+        let index = 0;
+        for (const el of this) {
+            mappedHeap.add(callback.call(thisArg, el, index, this));
+            index++;
+        }
+        return mappedHeap;
     }
 }
 exports.MinHeap = MinHeap;

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback } from '../../types';
+import type { DoublyLinkedListOptions, ElementCallback } from '../../types';
 import { IterableElementBase } from '../base';
 export declare class DoublyLinkedListNode<E = any> {
     /**
@@ -60,14 +60,8 @@ export declare class DoublyLinkedListNode<E = any> {
  * 3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
  * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
  */
-export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
-    /**
-     * The constructor initializes a linked list with optional elements.
-     * @param elements - The `elements` parameter is an optional iterable object that contains the
-     * initial elements to be added to the data structure. It defaults to an empty array if no elements
-     * are provided.
-     */
-    constructor(elements?: Iterable<E>);
+export declare class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R, DoublyLinkedList<E, R>> {
+    constructor(elements?: Iterable<E> | Iterable<R>, options?: DoublyLinkedListOptions<E, R>);
     protected _head: DoublyLinkedListNode<E> | undefined;
     /**
      * The `head` function returns the first node of a doubly linked list.
@@ -125,7 +119,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
      * @returns The `fromArray` function returns a DoublyLinkedList object.
      */
-    static fromArray<E>(data: E[]): DoublyLinkedList<E>;
+    static fromArray<E>(data: E[]): DoublyLinkedList<E, any>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -393,7 +387,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The `clone()` method is returning a new instance of the `DoublyLinkedList` class, which
      * is a copy of the original list.
      */
-    clone(): DoublyLinkedList<E>;
+    clone(): DoublyLinkedList<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -415,29 +409,29 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The `filter` method is returning a new `DoublyLinkedList` object that contains the
      * elements that pass the filter condition specified by the `callback` function.
      */
-    filter(callback: ElementCallback<E, boolean>, thisArg?: any): DoublyLinkedList<E>;
+    filter(callback: ElementCallback<E, R, boolean, DoublyLinkedList<E, R>>, thisArg?: any): DoublyLinkedList<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function creates a new DoublyLinkedList by applying a callback function to each element
-     * in the original list.
+     * The `map` function takes a callback function and returns a new DoublyLinkedList with the results
+     * of applying the callback to each element in the original list.
      * @param callback - The callback parameter is a function that will be called for each element in the
-     * DoublyLinkedList. It takes three arguments: the current element, the index of the current element,
-     * and the DoublyLinkedList itself. The callback function should return a value that will be added to
-     * the new DoublyLinkedList that
-     * @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 `map` function is returning a new `DoublyLinkedList` object that contains the results
-     * of applying the provided `callback` function to each element in the original `DoublyLinkedList`
-     * object.
-     */
-    map<T>(callback: ElementCallback<E, T>, thisArg?: any): DoublyLinkedList<T>;
+     * original DoublyLinkedList. It takes three arguments: current (the current element being
+     * processed), index (the index of the current element), and this (the original DoublyLinkedList).
+     * The callback function should return a value of type
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * convert the raw element (`RR`) to the desired element type (`T`). It takes the raw element as
+     * input and returns the converted element. If this parameter is not provided, the raw element will
+     * be used as is.
+     * @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 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 `DoublyLinkedList` class with elements of type `T` and `RR`.
+     */
+    map<EM, RM>(callback: ElementCallback<E, R, EM, DoublyLinkedList<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): DoublyLinkedList<EM, RM>;
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -70,20 +70,18 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
  */
 class DoublyLinkedList extends base_1.IterableElementBase {
-    /**
-     * The constructor initializes a linked list with optional elements.
-     * @param elements - The `elements` parameter is an optional iterable object that contains the
-     * initial elements to be added to the data structure. It defaults to an empty array if no elements
-     * are provided.
-     */
-    constructor(elements = []) {
-        super();
+    constructor(elements = [], options) {
+        super(options);
         this._head = undefined;
         this._tail = undefined;
         this._size = 0;
         if (elements) {
             for (const el of elements) {
-                this.push(el);
+                if (this.toElementFn) {
+                    this.push(this.toElementFn(el));
+                }
+                else
+                    this.push(el);
             }
         }
     }
@@ -663,7 +661,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * is a copy of the original list.
      */
     clone() {
-        return new DoublyLinkedList(this.values());
+        return new DoublyLinkedList(this);
     }
     /**
      * Time Complexity: O(n)
@@ -687,7 +685,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * elements that pass the filter condition specified by the `callback` function.
      */
     filter(callback, thisArg) {
-        const filteredList = new DoublyLinkedList();
+        const filteredList = new DoublyLinkedList([], { toElementFn: this.toElementFn });
         let index = 0;
         for (const current of this) {
             if (callback.call(thisArg, current, index, this)) {
@@ -702,24 +700,24 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function creates a new DoublyLinkedList by applying a callback function to each element
-     * in the original list.
+     * The `map` function takes a callback function and returns a new DoublyLinkedList with the results
+     * of applying the callback to each element in the original list.
      * @param callback - The callback parameter is a function that will be called for each element in the
-     * DoublyLinkedList. It takes three arguments: the current element, the index of the current element,
-     * and the DoublyLinkedList itself. The callback function should return a value that will be added to
-     * the new DoublyLinkedList that
-     * @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 `map` function is returning a new `DoublyLinkedList` object that contains the results
-     * of applying the provided `callback` function to each element in the original `DoublyLinkedList`
-     * object.
-     */
-    map(callback, thisArg) {
-        const mappedList = new DoublyLinkedList();
+     * original DoublyLinkedList. It takes three arguments: current (the current element being
+     * processed), index (the index of the current element), and this (the original DoublyLinkedList).
+     * The callback function should return a value of type
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * convert the raw element (`RR`) to the desired element type (`T`). It takes the raw element as
+     * input and returns the converted element. If this parameter is not provided, the raw element will
+     * be used as is.
+     * @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 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 `DoublyLinkedList` class with elements of type `T` and `RR`.
+     */
+    map(callback, toElementFn, thisArg) {
+        const mappedList = new DoublyLinkedList([], { toElementFn });
         let index = 0;
         for (const current of this) {
             mappedList.push(callback.call(thisArg, current, index, this));

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback } from '../../types';
+import type { ElementCallback, SinglyLinkedListOptions } from '../../types';
 import { IterableElementBase } from '../base';
 export declare class SinglyLinkedListNode<E = any> {
     /**
@@ -40,14 +40,8 @@ export declare class SinglyLinkedListNode<E = any> {
      */
     set next(value: SinglyLinkedListNode<E> | undefined);
 }
-export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
-    /**
-     * The constructor initializes a new instance of a class with an optional iterable of elements.
-     * @param elements - The `elements` parameter is an optional iterable object that contains the
-     * initial elements to be added to the instance of the class. If no `elements` are provided, an empty
-     * array will be used as the default value.
-     */
-    constructor(elements?: Iterable<E>);
+export declare class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R, SinglyLinkedList<E, R>> {
+    constructor(elements?: Iterable<E> | Iterable<R>, options?: SinglyLinkedListOptions<E, R>);
     protected _head: SinglyLinkedListNode<E> | undefined;
     /**
      * The `head` function returns the first node of a singly linked list.
@@ -93,7 +87,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
      * @returns The `fromArray` function returns a `SinglyLinkedList` object.
      */
-    static fromArray<E>(data: E[]): SinglyLinkedList<E>;
+    static fromArray<E>(data: E[]): SinglyLinkedList<E, any>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -348,7 +342,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The `clone()` method is returning a new instance of the `SinglyLinkedList` class, which
      * is a clone of the original list.
      */
-    clone(): SinglyLinkedList<E>;
+    clone(): SinglyLinkedList<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -370,26 +364,29 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The `filter` method is returning a new `SinglyLinkedList` object that contains the
      * elements that pass the filter condition specified by the `callback` function.
      */
-    filter(callback: ElementCallback<E, boolean>, thisArg?: any): SinglyLinkedList<E>;
+    filter(callback: ElementCallback<E, R, boolean, SinglyLinkedList<E, R>>, thisArg?: any): SinglyLinkedList<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function creates a new SinglyLinkedList by applying a callback function to each element
-     * of the original list.
+     * The `map` function takes a callback function and returns a new SinglyLinkedList with the results
+     * of applying the callback to each element in the original list.
      * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the linked list. It takes three arguments:
-     * @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 `map` function is returning a new `SinglyLinkedList` object that contains the results
-     * of applying the provided `callback` function to each element in the original list.
-     */
-    map<T>(callback: ElementCallback<E, T>, thisArg?: any): SinglyLinkedList<T>;
+     * the original list. It takes three arguments: `current` (the current element being processed),
+     * `index` (the index of the current element), and `this` (the original list). It should return a
+     * value
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * convert the raw element (`RR`) to the desired element type (`T`). It takes the raw element as
+     * input and returns the converted element. If this parameter is not provided, the raw element will
+     * be used as is.
+     * @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 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 `SinglyLinkedList` class with the mapped elements.
+     */
+    map<EM, RM>(callback: ElementCallback<E, R, EM, SinglyLinkedList<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): SinglyLinkedList<EM, RM>;
     /**
      * The function `_getIterator` returns an iterable iterator that yields the values of a linked list.
      */

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -46,18 +46,18 @@ class SinglyLinkedListNode {
 }
 exports.SinglyLinkedListNode = SinglyLinkedListNode;
 class SinglyLinkedList extends base_1.IterableElementBase {
-    /**
-     * The constructor initializes a new instance of a class with an optional iterable of elements.
-     * @param elements - The `elements` parameter is an optional iterable object that contains the
-     * initial elements to be added to the instance of the class. If no `elements` are provided, an empty
-     * array will be used as the default value.
-     */
-    constructor(elements = []) {
-        super();
+    constructor(elements = [], options) {
+        super(options);
         this._size = 0;
         if (elements) {
-            for (const el of elements)
-                this.push(el);
+            for (const el of elements) {
+                if (this.toElementFn) {
+                    this.push(this.toElementFn(el));
+                }
+                else {
+                    this.push(el);
+                }
+            }
         }
     }
     /**
@@ -608,7 +608,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * is a clone of the original list.
      */
     clone() {
-        return new SinglyLinkedList(this.values());
+        return new SinglyLinkedList(this, { toElementFn: this.toElementFn });
     }
     /**
      * Time Complexity: O(n)
@@ -632,7 +632,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * elements that pass the filter condition specified by the `callback` function.
      */
     filter(callback, thisArg) {
-        const filteredList = new SinglyLinkedList();
+        const filteredList = new SinglyLinkedList([], { toElementFn: this.toElementFn });
         let index = 0;
         for (const current of this) {
             if (callback.call(thisArg, current, index, this)) {
@@ -647,21 +647,24 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function creates a new SinglyLinkedList by applying a callback function to each element
-     * of the original list.
+     * The `map` function takes a callback function and returns a new SinglyLinkedList with the results
+     * of applying the callback to each element in the original list.
      * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the linked list. It takes three arguments:
-     * @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 `map` function is returning a new `SinglyLinkedList` object that contains the results
-     * of applying the provided `callback` function to each element in the original list.
-     */
-    map(callback, thisArg) {
-        const mappedList = new SinglyLinkedList();
+     * the original list. It takes three arguments: `current` (the current element being processed),
+     * `index` (the index of the current element), and `this` (the original list). It should return a
+     * value
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * convert the raw element (`RR`) to the desired element type (`T`). It takes the raw element as
+     * input and returns the converted element. If this parameter is not provided, the raw element will
+     * be used as is.
+     * @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 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 `SinglyLinkedList` class with the mapped elements.
+     */
+    map(callback, toElementFn, thisArg) {
+        const mappedList = new SinglyLinkedList([], { toElementFn });
         let index = 0;
         for (const current of this) {
             mappedList.push(callback.call(thisArg, current, index, this));

package/dist/data-structures/priority-queue/max-priority-queue.d.ts

@@ -5,9 +5,9 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { PriorityQueueOptions } from '../../types';
+import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
-export declare class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
+export declare class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
     /**
      * The constructor initializes a PriorityQueue with optional elements and options, including a
      * comparator function.
@@ -15,8 +15,54 @@ export declare class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
      * elements to be added to the priority queue. It is optional and defaults to an empty array if not
      * provided.
      * @param options - The `options` parameter is an object that contains additional configuration
-     * options for the priority queue. In this case, it has a property called `comparator` which is a
+     * options for the priority queue. In this case, it has a property called `comparator,` which is a
      * function used to compare elements in the priority queue.
      */
-    constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>);
+    constructor(elements?: Iterable<E> | Iterable<R>, options?: PriorityQueueOptions<E, R>);
+    /**
+     * The `clone` function returns a new instance of the `MaxPriorityQueue` class with the same
+     * comparator and toElementFn as the current instance.
+     * @returns The method is returning a new instance of the MaxPriorityQueue class with the same
+     * comparator and toElementFn as the current instance.
+     */
+    clone(): MaxPriorityQueue<E, R>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new MaxPriorityQueue 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 `MaxPriorityQueue` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback: ElementCallback<E, R, boolean, MaxPriorityQueue<E, R>>, thisArg?: any): MaxPriorityQueue<E, R>;
+    /**
+     * 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 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 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 `MaxPriorityQueue` class with the mapped elements.
+     */
+    map<EM, RM>(callback: ElementCallback<E, R, EM, MaxPriorityQueue<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MaxPriorityQueue<EM, RM>;
 }

package/dist/data-structures/priority-queue/max-priority-queue.js

@@ -10,20 +10,89 @@ class MaxPriorityQueue extends priority_queue_1.PriorityQueue {
      * elements to be added to the priority queue. It is optional and defaults to an empty array if not
      * provided.
      * @param options - The `options` parameter is an object that contains additional configuration
-     * options for the priority queue. In this case, it has a property called `comparator` which is a
+     * options for the priority queue. In this case, it has a property called `comparator,` which is a
      * function used to compare elements in the priority queue.
      */
-    constructor(elements = [], options = {
-        comparator: (a, b) => {
-            if (!(typeof a === 'number' && typeof b === 'number')) {
-                throw new Error('The a, b params of compare function must be number');
-            }
-            else {
-                return b - a;
+    constructor(elements = [], options) {
+        super(elements, Object.assign({ comparator: (a, b) => {
+                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;
+                if (a > b)
+                    return -1;
+                return 0;
+            } }, options));
+    }
+    /**
+     * The `clone` function returns a new instance of the `MaxPriorityQueue` class with the same
+     * comparator and toElementFn as the current instance.
+     * @returns The method is returning a new instance of the MaxPriorityQueue class with the same
+     * comparator and toElementFn as the current instance.
+     */
+    clone() {
+        return new MaxPriorityQueue(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new MaxPriorityQueue 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 `MaxPriorityQueue` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
+        const filteredPriorityQueue = new MaxPriorityQueue([], {
+            toElementFn: this.toElementFn,
+            comparator: this.comparator
+        });
+        let index = 0;
+        for (const current of this) {
+            if (callback.call(thisArg, current, index, this)) {
+                filteredPriorityQueue.add(current);
             }
+            index++;
+        }
+        return filteredPriorityQueue;
+    }
+    /**
+     * 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 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 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 `MaxPriorityQueue` class with the mapped elements.
+     */
+    map(callback, comparator, toElementFn, thisArg) {
+        const mappedPriorityQueue = new MaxPriorityQueue([], { comparator, toElementFn });
+        let index = 0;
+        for (const el of this) {
+            mappedPriorityQueue.add(callback.call(thisArg, el, index, this));
+            index++;
         }
-    }) {
-        super(elements, options);
+        return mappedPriorityQueue;
     }
 }
 exports.MaxPriorityQueue = MaxPriorityQueue;