data-structure-typed 1.51.9 → 1.52.0

package/dist/umd/data-structure-typed.js

@@ -173,8 +173,17 @@ var dataStructureTyped = (() => {
     uuidV4: () => uuidV4
   });
 
-  // src/data-structures/base/iterable-base.ts
+  // src/data-structures/base/iterable-entry-base.ts
   var IterableEntryBase = class {
+    // protected _toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
+    //
+    // /**
+    //  * The function returns the value of the _toEntryFn property.
+    //  * @returns The function being returned is `this._toEntryFn`.
+    //  */
+    // get toEntryFn() {
+    //   return this._toEntryFn;
+    // }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -439,11 +448,44 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The print function logs the elements of an array to the console.
+     */
     print() {
       console.log([...this]);
     }
   };
+
+  // src/data-structures/base/iterable-element-base.ts
   var IterableElementBase = class {
+    /**
+     * The protected constructor initializes the options for the IterableElementBase class, including the
+     * toElementFn function.
+     * @param [options] - An optional object that contains the following properties:
+     */
+    constructor(options) {
+      __publicField(this, "_toElementFn");
+      if (options) {
+        const { toElementFn } = options;
+        if (typeof toElementFn === "function")
+          this._toElementFn = toElementFn;
+        else if (toElementFn)
+          throw new TypeError("toElementFn must be a function type");
+      }
+    }
+    /**
+     * The function returns the _toElementFn property, which is a function that converts a raw element to
+     * a specific type.
+     * @returns The function `get toElementFn()` is returning either a function that takes a raw element
+     * `rawElement` of type `R` and returns an element `E`, or `undefined` if no function is assigned to
+     * `_toElementFn`.
+     */
+    get toElementFn() {
+      return this._toElementFn;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -630,6 +672,12 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The print function logs the elements of an array to the console.
+     */
     print() {
       console.log([...this]);
     }
@@ -1641,20 +1689,19 @@ var dataStructureTyped = (() => {
     }
   };
   var SinglyLinkedList = class _SinglyLinkedList extends 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);
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(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);
+          }
+        }
       }
     }
     /**
@@ -2199,7 +2246,7 @@ var dataStructureTyped = (() => {
      * is a clone of the original list.
      */
     clone() {
-      return new _SinglyLinkedList(this.values());
+      return new _SinglyLinkedList(this, { toElementFn: this.toElementFn });
     }
     /**
      * Time Complexity: O(n)
@@ -2223,7 +2270,7 @@ var dataStructureTyped = (() => {
      * 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)) {
@@ -2238,21 +2285,24 @@ var dataStructureTyped = (() => {
      * 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.
+     * 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, thisArg) {
-      const mappedList = new _SinglyLinkedList();
+    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));
@@ -2337,14 +2387,8 @@ var dataStructureTyped = (() => {
     }
   };
   var DoublyLinkedList = class _DoublyLinkedList extends 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);
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_size");
@@ -2353,7 +2397,10 @@ var dataStructureTyped = (() => {
       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);
         }
       }
     }
@@ -2924,7 +2971,7 @@ var dataStructureTyped = (() => {
      * is a copy of the original list.
      */
     clone() {
-      return new _DoublyLinkedList(this.values());
+      return new _DoublyLinkedList(this);
     }
     /**
      * Time Complexity: O(n)
@@ -2948,7 +2995,7 @@ var dataStructureTyped = (() => {
      * 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)) {
@@ -2963,24 +3010,24 @@ var dataStructureTyped = (() => {
      * 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.
+     * 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, thisArg) {
-      const mappedList = new _DoublyLinkedList();
+    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));
@@ -3277,18 +3324,17 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/stack/stack.ts
   var Stack = class _Stack extends IterableElementBase {
-    /**
-     * The constructor initializes an array of elements, which can be provided as an optional parameter.
-     * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
-     * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
-     * is provided and is an array, it is assigned to the `_elements
-     */
-    constructor(elements = []) {
-      super();
+    constructor(elements = [], options) {
+      super(options);
       __publicField(this, "_elements", []);
       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);
+          }
+        }
       }
     }
     /**
@@ -3434,7 +3480,7 @@ var dataStructureTyped = (() => {
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
     clone() {
-      return new _Stack(this.elements.slice());
+      return new _Stack(this, { toElementFn: this.toElementFn });
     }
     /**
      * Time Complexity: O(n)
@@ -3457,7 +3503,7 @@ var dataStructureTyped = (() => {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-      const newStack = new _Stack();
+      const newStack = new _Stack([], { toElementFn: this.toElementFn });
       let index = 0;
       for (const el of this) {
         if (predicate.call(thisArg, el, index, this)) {
@@ -3472,20 +3518,21 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
      * The `map` function takes a callback function and applies it to each element in the stack,
      * returning a new stack with the results.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the stack. 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` method is returning a new `Stack` object.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * stack. It takes three arguments: the current element, the index of the element, and the stack
+     * itself. It should return a new value that will be added to the new stack.
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * transform the raw element (`RM`) into a new element (`EM`) before pushing it into the new stack.
+     * @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 Stack object with elements of type EM and raw elements of type RM.
      */
-    map(callback, thisArg) {
-      const newStack = new _Stack();
+    map(callback, toElementFn, thisArg) {
+      const newStack = new _Stack([], { toElementFn });
       let index = 0;
       for (const el of this) {
         newStack.push(callback.call(thisArg, el, index, this));
@@ -3513,19 +3560,17 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/queue/queue.ts
   var Queue = class _Queue extends IterableElementBase {
-    /**
-     * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
-     * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
-     * will be used to initialize the `_elements` property of the class. If not provided, the `_elements` property will be
-     * initialized as an empty array.
-     */
-    constructor(elements = []) {
-      super();
+    constructor(elements = [], options) {
+      super(options);
       __publicField(this, "_elements", []);
       __publicField(this, "_offset", 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);
+        }
       }
     }
     /**
@@ -3665,7 +3710,7 @@ var dataStructureTyped = (() => {
      * @param index
      */
     at(index) {
-      return this.elements[index];
+      return this.elements[index + this._offset];
     }
     /**
      * Time Complexity: O(1)
@@ -3722,7 +3767,7 @@ var dataStructureTyped = (() => {
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     clone() {
-      return new _Queue(this.elements.slice(this.offset));
+      return new _Queue(this.elements.slice(this.offset), { toElementFn: this.toElementFn });
     }
     /**
      * Time Complexity: O(n)
@@ -3745,7 +3790,7 @@ var dataStructureTyped = (() => {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-      const newDeque = new _Queue([]);
+      const newDeque = new _Queue([], { toElementFn: this.toElementFn });
       let index = 0;
       for (const el of this) {
         if (predicate.call(thisArg, el, index, this)) {
@@ -3759,22 +3804,8 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function takes a callback function and applies it to each element in the queue,
-     * returning a new queue with the results.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * queue. It takes three arguments: the current element, the index of the current element, and the
-     * queue itself. The callback function should return a new value that will be added to the new queue.
-     * @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 `Queue` object with the transformed elements.
-     */
-    map(callback, thisArg) {
-      const newDeque = new _Queue([]);
+    map(callback, toElementFn, thisArg) {
+      const newDeque = new _Queue([], { toElementFn });
       let index = 0;
       for (const el of this) {
         newDeque.push(callback.call(thisArg, el, index, this));
@@ -3793,7 +3824,7 @@ var dataStructureTyped = (() => {
      * The function `_getIterator` returns an iterable iterator for the elements in the class.
      */
     *_getIterator() {
-      for (const item of this.elements) {
+      for (const item of this.elements.slice(this.offset)) {
         yield item;
       }
     }
@@ -3812,14 +3843,14 @@ var dataStructureTyped = (() => {
      * values as the original `LinkedListQueue`.
      */
     clone() {
-      return new _LinkedListQueue(this.values());
+      return new _LinkedListQueue(this, { toElementFn: this.toElementFn });
     }
   };
 
   // src/data-structures/queue/deque.ts
   var Deque = class _Deque extends IterableElementBase {
     /**
-     * The constructor initializes a Deque object with an optional iterable of elements and options.
+     * The constructor initializes a Deque object with optional iterable of elements and options.
      * @param elements - An iterable object (such as an array or a Set) that contains the initial
      * elements to be added to the deque. It can also be an object with a `length` or `size` property
      * that represents the number of elements in the iterable object. If no elements are provided, an
@@ -3830,7 +3861,7 @@ var dataStructureTyped = (() => {
      * or is not a number
      */
     constructor(elements = [], options) {
-      super();
+      super(options);
       __publicField(this, "_bucketSize", 1 << 12);
       __publicField(this, "_bucketFirst", 0);
       __publicField(this, "_firstInBucket", 0);
@@ -3863,8 +3894,12 @@ var dataStructureTyped = (() => {
       const needBucketNum = calcMinUnitsRequired(_size, this._bucketSize);
       this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
       this._firstInBucket = this._lastInBucket = this._bucketSize - _size % this._bucketSize >> 1;
-      for (const element of elements) {
-        this.push(element);
+      for (const el of elements) {
+        if (this.toElementFn) {
+          this.push(this.toElementFn(el));
+        } else {
+          this.push(el);
+        }
       }
     }
     /**
@@ -4501,7 +4536,7 @@ var dataStructureTyped = (() => {
      * elements as the original deque (`this`) and the same bucket size.
      */
     clone() {
-      return new _Deque([...this], { bucketSize: this.bucketSize });
+      return new _Deque(this, { bucketSize: this.bucketSize, toElementFn: this.toElementFn });
     }
     /**
      * Time Complexity: O(n)
@@ -4524,7 +4559,7 @@ var dataStructureTyped = (() => {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-      const newDeque = new _Deque([], { bucketSize: this._bucketSize });
+      const newDeque = new _Deque([], { bucketSize: this._bucketSize, toElementFn: this.toElementFn });
       let index = 0;
       for (const el of this) {
         if (predicate.call(thisArg, el, index, this)) {
@@ -4539,20 +4574,22 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function creates a new Deque by applying a callback function to each element of the
-     * original Deque.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the deque. 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 a new Deque object with the mapped values.
+     * The `map` function takes a callback function and applies it to each element in the deque,
+     * returning a new deque with the results.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * deque. It takes three arguments: the current element, the index of the element, and the deque
+     * itself. It should return a value of type EM.
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * transform the raw element (`RM`) into a new element (`EM`) before adding it to the new deque. If
+     * provided, this function will be called for each raw element in the original deque.
+     * @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 Deque object with elements of type EM and raw elements of type RM.
      */
-    map(callback, thisArg) {
-      const newDeque = new _Deque([], { bucketSize: this._bucketSize });
+    map(callback, toElementFn, thisArg) {
+      const newDeque = new _Deque([], { bucketSize: this._bucketSize, toElementFn });
       let index = 0;
       for (const el of this) {
         newDeque.push(callback.call(thisArg, el, index, this));
@@ -4644,23 +4681,32 @@ var dataStructureTyped = (() => {
     /**
      * 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 = [], options) {
-      super();
-      __publicField(this, "_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;
+      super(options);
+      __publicField(this, "_elements", []);
+      __publicField(this, "_DEFAULT_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;
       });
-      __publicField(this, "_elements", []);
+      __publicField(this, "_comparator", this._DEFAULT_COMPARATOR);
       if (options) {
         const { comparator } = options;
         if (comparator)
@@ -4668,20 +4714,16 @@ var dataStructureTyped = (() => {
       }
       if (elements) {
         for (const el of elements) {
-          this.add(el);
+          if (this.toElementFn)
+            this.add(this.toElementFn(el));
+          else
+            this.add(el);
         }
       }
     }
-    /**
-     * The function returns the value of the _comparator property.
-     * @returns The `_comparator` property is being returned.
-     */
-    get comparator() {
-      return this._comparator;
-    }
     /**
      * The function returns an array of elements.
-     * @returns The elements array is being returned.
+     * @returns The element array is being returned.
      */
     get elements() {
       return this._elements;
@@ -4709,11 +4751,6 @@ var dataStructureTyped = (() => {
     static heapify(elements, options) {
       return new _Heap(elements, options);
     }
-    /**
-     * 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)
@@ -4725,16 +4762,11 @@ var dataStructureTyped = (() => {
       this._elements.push(element);
       return this._bubbleUp(this.elements.length - 1);
     }
-    /**
-     * 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() {
@@ -4748,10 +4780,6 @@ var dataStructureTyped = (() => {
       }
       return value;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -4775,10 +4803,6 @@ var dataStructureTyped = (() => {
     clear() {
       this._elements = [];
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4790,10 +4814,6 @@ var dataStructureTyped = (() => {
       this._elements = elements;
       return this.fix();
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -4806,12 +4826,7 @@ var dataStructureTyped = (() => {
       return this.elements.includes(element);
     }
     /**
-     * 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
@@ -4836,11 +4851,6 @@ var dataStructureTyped = (() => {
       }
       return true;
     }
-    /**
-     * 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)
@@ -4872,10 +4882,6 @@ var dataStructureTyped = (() => {
       _dfs(0);
       return result;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4886,10 +4892,6 @@ var dataStructureTyped = (() => {
     toArray() {
       return [...this.elements];
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4898,14 +4900,8 @@ var dataStructureTyped = (() => {
      * @returns A new Heap instance containing the same elements.
      */
     clone() {
-      const clonedHeap = new _Heap([], { comparator: this.comparator });
-      clonedHeap._elements = [...this.elements];
-      return clonedHeap;
+      return new _Heap(this, { comparator: this.comparator, toElementFn: this.toElementFn });
     }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -4915,18 +4911,14 @@ var dataStructureTyped = (() => {
      */
     sort() {
       const visitedNode = [];
-      const cloned = this.clone();
+      const cloned = new _Heap(this, { comparator: this.comparator });
       while (cloned.size !== 0) {
         const top = cloned.poll();
-        if (top)
+        if (top !== void 0)
           visitedNode.push(top);
       }
       return visitedNode;
     }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -4939,10 +4931,6 @@ var dataStructureTyped = (() => {
         results.push(this._sinkDown(i, this.elements.length >> 1));
       return results;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4960,7 +4948,7 @@ var dataStructureTyped = (() => {
      * the filter condition specified by the `callback` function.
      */
     filter(callback, thisArg) {
-      const filteredList = new _Heap();
+      const filteredList = new _Heap([], { toElementFn: this.toElementFn, comparator: this.comparator });
       let index = 0;
       for (const current of this) {
         if (callback.call(thisArg, current, index, this)) {
@@ -4971,31 +4959,28 @@ var dataStructureTyped = (() => {
       return filteredList;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
-    /**
-     * 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.
-     */
-    map(callback, comparator, thisArg) {
-      const mappedHeap = new _Heap([], { comparator });
+     * 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(callback, comparator, toElementFn, thisArg) {
+      const mappedHeap = new _Heap([], { comparator, toElementFn });
       let index = 0;
       for (const el of this) {
         mappedHeap.add(callback.call(thisArg, el, index, this));
@@ -5003,6 +4988,13 @@ var dataStructureTyped = (() => {
       }
       return mappedHeap;
     }
+    /**
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
+     */
+    get comparator() {
+      return this._comparator;
+    }
     /**
      * The function `_getIterator` returns an iterable iterator for the elements in the class.
      */
@@ -5011,10 +5003,6 @@ var dataStructureTyped = (() => {
         yield element;
       }
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -5035,10 +5023,6 @@ var dataStructureTyped = (() => {
       this.elements[index] = element;
       return true;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -5147,10 +5131,6 @@ var dataStructureTyped = (() => {
       this._min = void 0;
       this._size = 0;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -5162,10 +5142,6 @@ var dataStructureTyped = (() => {
     add(element) {
       return this.push(element);
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -5185,10 +5161,6 @@ var dataStructureTyped = (() => {
       this._size++;
       return this;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -5256,7 +5228,7 @@ var dataStructureTyped = (() => {
      * 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() {
@@ -5270,7 +5242,7 @@ var dataStructureTyped = (() => {
      * 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() {
@@ -5375,8 +5347,8 @@ var dataStructureTyped = (() => {
     /**
      * 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
      */
@@ -5396,7 +5368,7 @@ var dataStructureTyped = (() => {
      * 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
@@ -5417,7 +5389,7 @@ var dataStructureTyped = (() => {
      * 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
      */
     _consolidate() {
@@ -5449,32 +5421,161 @@ var dataStructureTyped = (() => {
   };
 
   // src/data-structures/heap/max-heap.ts
-  var MaxHeap = class extends 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 b - a;
+  var MaxHeap = class _MaxHeap extends Heap {
+    constructor(elements = [], options) {
+      super(elements, __spreadValues({
+        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 `MaxHeap` class with the same properties as the
+     * current instance.
+     * @returns The `clone()` method is returning a new instance of the `MaxHeap` class with the same
+     * properties as the current instance.
+     */
+    clone() {
+      return new _MaxHeap(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new MaxHeap 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 `MaxHeap` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
+      const filteredList = new _MaxHeap([], { 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 `MaxHeap` class with the mapped elements.
+     */
+    map(callback, comparator, toElementFn, thisArg) {
+      const mappedHeap = new _MaxHeap([], { comparator, toElementFn });
+      let index = 0;
+      for (const el of this) {
+        mappedHeap.add(callback.call(thisArg, el, index, this));
+        index++;
+      }
+      return mappedHeap;
     }
   };
 
   // src/data-structures/heap/min-heap.ts
-  var MinHeap = class extends 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;
+  var MinHeap = class _MinHeap extends Heap {
+    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;
     }
   };
 
@@ -7738,7 +7839,7 @@ var dataStructureTyped = (() => {
   var BinaryTree = class _BinaryTree extends IterableEntryBase {
     /**
      * 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
@@ -7759,6 +7860,8 @@ var dataStructureTyped = (() => {
           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);
@@ -9299,7 +9402,7 @@ var dataStructureTyped = (() => {
       } else if (this.isNIL(node) && !isShowRedBlackNIL) {
         return emptyDisplayLayout;
       } else if (node !== null && node !== void 0) {
-        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,
@@ -9307,7 +9410,7 @@ var dataStructureTyped = (() => {
           this._displayAux(node.right, options)
         );
       } else {
-        const line = node === void 0 ? "U" : "NODE", width = line.length;
+        const line = node === void 0 ? "U" : "N", width = line.length;
         return _buildNodeDisplay(line, width, [[""], 1, 0, 0], [[""], 1, 0, 0]);
       }
       function _buildNodeDisplay(line, width, left, right) {
@@ -9499,14 +9602,10 @@ var dataStructureTyped = (() => {
     constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
       super([], options);
       __publicField(this, "_root");
-      /**
-       * Time complexity: O(n)
-       * Space complexity: O(n)
-       */
       __publicField(this, "_DEFAULT_COMPARATOR", (a, b) => {
-        if (typeof a === "object" && typeof b === "object" && this.comparator === this._DEFAULT_COMPARATOR) {
+        if (typeof a === "object" || typeof b === "object") {
           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."
+            `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
           );
         }
         if (a > b)
@@ -9515,10 +9614,6 @@ var dataStructureTyped = (() => {
           return -1;
         return 0;
       });
-      /**
-       * Time complexity: O(n)
-       * Space complexity: O(n)
-       */
       __publicField(this, "_comparator", this._DEFAULT_COMPARATOR);
       if (options) {
         const { comparator } = options;
@@ -12562,11 +12657,11 @@ var dataStructureTyped = (() => {
   };
 
   // src/data-structures/priority-queue/priority-queue.ts
-  var PriorityQueue = class extends Heap {
+  var PriorityQueue = class _PriorityQueue extends Heap {
     /**
      * The constructor initializes a priority queue with optional elements and options.
      * @param elements - The `elements` parameter is an iterable object that contains the initial
-     * elements to be added to the priority queue. It is an optional parameter and if not provided, the
+     * elements to be added to the priority queue. It is an optional parameter, and if not provided, the
      * priority queue will be initialized as empty.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the priority queue. It can contain the following properties:
@@ -12574,10 +12669,79 @@ var dataStructureTyped = (() => {
     constructor(elements = [], options) {
       super(elements, options);
     }
+    /**
+     * The `clone` function returns a new instance of the `PriorityQueue` class with the same comparator
+     * and toElementFn as the original instance.
+     * @returns The method is returning a new instance of the `PriorityQueue` class with the same
+     * elements and properties as the current instance.
+     */
+    clone() {
+      return new _PriorityQueue(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new PriorityQueue 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 `PriorityQueue` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
+      const filteredPriorityQueue = new _PriorityQueue([], {
+        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 `PriorityQueue` class with the mapped elements.
+     */
+    map(callback, comparator, toElementFn, thisArg) {
+      const mappedPriorityQueue = new _PriorityQueue([], { comparator, toElementFn });
+      let index = 0;
+      for (const el of this) {
+        mappedPriorityQueue.add(callback.call(thisArg, el, index, this));
+        index++;
+      }
+      return mappedPriorityQueue;
+    }
   };
 
   // src/data-structures/priority-queue/min-priority-queue.ts
-  var MinPriorityQueue = class extends PriorityQueue {
+  var MinPriorityQueue = class _MinPriorityQueue extends PriorityQueue {
     /**
      * The constructor initializes a PriorityQueue with optional elements and options, including a
      * comparator function.
@@ -12585,25 +12749,86 @@ var dataStructureTyped = (() => {
      * 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. The `comparator` function takes two
-     * parameters `a` and `b`,
+     * parameters `a` and `b`
      */
-    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 `MinPriorityQueue` class with the same
+     * comparator and toElementFn as the original instance.
+     * @returns The method is returning a new instance of the `MinPriorityQueue` class with the same
+     * properties as the current instance.
+     */
+    clone() {
+      return new _MinPriorityQueue(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new MinPriorityQueue 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 `MinPriorityQueue` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
+      const filteredPriorityQueue = new _MinPriorityQueue([], {
+        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++;
       }
-    }) {
-      super(elements, options);
+      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 `MinPriorityQueue` class with the mapped elements.
+     */
+    map(callback, comparator, toElementFn, thisArg) {
+      const mappedPriorityQueue = new _MinPriorityQueue([], { comparator, toElementFn });
+      let index = 0;
+      for (const el of this) {
+        mappedPriorityQueue.add(callback.call(thisArg, el, index, this));
+        index++;
+      }
+      return mappedPriorityQueue;
     }
   };
 
   // src/data-structures/priority-queue/max-priority-queue.ts
-  var MaxPriorityQueue = class extends PriorityQueue {
+  var MaxPriorityQueue = class _MaxPriorityQueue extends PriorityQueue {
     /**
      * The constructor initializes a PriorityQueue with optional elements and options, including a
      * comparator function.
@@ -12611,19 +12836,93 @@ var dataStructureTyped = (() => {
      * 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, __spreadValues({
+        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++;
       }
-    }) {
-      super(elements, options);
+      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++;
+      }
+      return mappedPriorityQueue;
     }
   };
 
@@ -13237,7 +13536,7 @@ var dataStructureTyped = (() => {
      * @return This
      */
     constructor(words = [], options) {
-      super();
+      super(options);
       __publicField(this, "_size", 0);
       __publicField(this, "_caseSensitive", true);
       __publicField(this, "_root", new TrieNode(""));
@@ -13247,8 +13546,13 @@ var dataStructureTyped = (() => {
           this._caseSensitive = caseSensitive;
       }
       if (words) {
-        for (const word of words)
-          this.add(word);
+        for (const word of words) {
+          if (this.toElementFn) {
+            this.add(this.toElementFn(word));
+          } else {
+            this.add(word);
+          }
+        }
       }
     }
     /**
@@ -13586,7 +13890,7 @@ var dataStructureTyped = (() => {
      * @returns A new instance of the Trie class is being returned.
      */
     clone() {
-      return new _Trie(this.values(), { caseSensitive: this.caseSensitive });
+      return new _Trie(this, { caseSensitive: this.caseSensitive, toElementFn: this.toElementFn });
     }
     /**
      * Time Complexity: O(n)
@@ -13607,7 +13911,7 @@ var dataStructureTyped = (() => {
      * @returns The `filter` method is returning an array of strings (`string[]`).
      */
     filter(predicate, thisArg) {
-      const results = new _Trie();
+      const results = new _Trie([], { toElementFn: this.toElementFn, caseSensitive: this.caseSensitive });
       let index = 0;
       for (const word of this) {
         if (predicate.call(thisArg, word, index, this)) {
@@ -13625,17 +13929,22 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function creates a new Trie by applying a callback function to each element in the Trie.
+     * The `map` function creates a new Trie by applying a callback function to each element in the
+     * current Trie.
      * @param callback - The callback parameter is a function that will be called for each element in the
-     * Trie. It takes three arguments: the current element in the Trie, the index of the current element,
-     * and the Trie itself. The callback function should return a new value for the element.
-     * @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 Trie object.
+     * Trie. It takes four arguments:
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * convert the raw element (`RM`) into a string representation. This can be useful if the raw element
+     * is not already a string or if you want to customize how the element is converted into a string. If
+     * this parameter 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 Trie object.
      */
-    map(callback, thisArg) {
-      const newTrie = new _Trie();
+    map(callback, toElementFn, thisArg) {
+      const newTrie = new _Trie([], { toElementFn, caseSensitive: this.caseSensitive });
       let index = 0;
       for (const word of this) {
         newTrie.add(callback.call(thisArg, word, index, this));