data-structure-typed 1.51.9 → 1.52.1

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);
+        }
       }
     }
     /**
@@ -3589,7 +3634,6 @@ var dataStructureTyped = (() => {
      *
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
-     * @static
      * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
      * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
      * array.
@@ -3665,7 +3709,7 @@ var dataStructureTyped = (() => {
      * @param index
      */
     at(index) {
-      return this.elements[index];
+      return this.elements[index + this._offset];
     }
     /**
      * Time Complexity: O(1)
@@ -3722,7 +3766,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 +3789,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 +3803,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 +3823,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 +3842,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,8 +3860,9 @@ var dataStructureTyped = (() => {
      * or is not a number
      */
     constructor(elements = [], options) {
-      super();
+      super(options);
       __publicField(this, "_bucketSize", 1 << 12);
+      __publicField(this, "_maxLen", -1);
       __publicField(this, "_bucketFirst", 0);
       __publicField(this, "_firstInBucket", 0);
       __publicField(this, "_bucketLast", 0);
@@ -3840,9 +3871,11 @@ var dataStructureTyped = (() => {
       __publicField(this, "_buckets", []);
       __publicField(this, "_size", 0);
       if (options) {
-        const { bucketSize } = options;
+        const { bucketSize, maxLen } = options;
         if (typeof bucketSize === "number")
           this._bucketSize = bucketSize;
+        if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0)
+          this._maxLen = maxLen;
       }
       let _size;
       if ("length" in elements) {
@@ -3863,8 +3896,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);
+        }
       }
     }
     /**
@@ -3875,6 +3912,14 @@ var dataStructureTyped = (() => {
     get bucketSize() {
       return this._bucketSize;
     }
+    /**
+     * The maxLen function returns the max length of the deque.
+     *
+     * @return The max length of the deque
+     */
+    get maxLen() {
+      return this._maxLen;
+    }
     /**
      * The function returns the value of the protected variable `_bucketFirst`.
      * @returns The value of the `_bucketFirst` property.
@@ -3974,6 +4019,8 @@ var dataStructureTyped = (() => {
       }
       this._size += 1;
       this._buckets[this._bucketLast][this._lastInBucket] = element;
+      if (this._maxLen > 0 && this._size > this._maxLen)
+        this.shift();
       return true;
     }
     /**
@@ -4036,6 +4083,8 @@ var dataStructureTyped = (() => {
       }
       this._size += 1;
       this._buckets[this._bucketFirst][this._firstInBucket] = element;
+      if (this._maxLen > 0 && this._size > this._maxLen)
+        this.pop();
       return true;
     }
     /**
@@ -4501,7 +4550,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 +4573,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 +4588,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 +4695,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 +4728,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 +4765,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 +4776,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 +4794,6 @@ var dataStructureTyped = (() => {
       }
       return value;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -4775,10 +4817,6 @@ var dataStructureTyped = (() => {
     clear() {
       this._elements = [];
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4790,10 +4828,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 +4840,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 +4865,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 +4896,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 +4906,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 +4914,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 +4925,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 +4945,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 +4962,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 +4973,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 +5002,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 +5017,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 +5037,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 +5145,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 +5156,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 +5175,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 +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.
      */
     poll() {
@@ -5270,7 +5256,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 +5361,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 +5382,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 +5403,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 +5435,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;
     }
   };
 
@@ -6609,7 +6724,7 @@ var dataStructureTyped = (() => {
       if (vertex) {
         const neighbors = this.getNeighbors(vertex);
         for (const neighbor of neighbors) {
-          this._inEdgeMap.delete(neighbor);
+          this.deleteEdgeSrcToDest(vertex, neighbor);
         }
         this._outEdgeMap.delete(vertex);
         this._inEdgeMap.delete(vertex);
@@ -7690,7 +7805,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function sets the left child of a node and updates its parent reference.
-     * @param {NODE | null | undefined} v - The parameter `v` can be of type `NODE`, `null`, or
+     * @param {OptBTNOrNull<NODE>} v - The parameter `v` can be of type `NODE`, `null`, or
      * `undefined`.
      */
     set left(v) {
@@ -7709,7 +7824,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function sets the right child of a node and updates its parent.
-     * @param {NODE | null | undefined} v - The parameter `v` can be of type `NODE`, `null`, or
+     * @param {OptBTNOrNull<NODE>} v - The parameter `v` can be of type `NODE`, `null`, or
      * `undefined`.
      */
     set right(v) {
@@ -7738,7 +7853,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 BTNKeyOrNodeOrEntry 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 +7874,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);
@@ -7814,8 +7931,8 @@ var dataStructureTyped = (() => {
     /**
      * The function `keyValueOrEntryOrRawElementToNode` converts a key-value pair, entry, or raw element
      * into a node object.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `keyValueOrEntryOrRawElementToNode` function. It represents the value associated with a key in a
      * key-value pair. If provided, it will be used to create a node with the specified key and value.
@@ -7859,8 +7976,8 @@ var dataStructureTyped = (() => {
      *
      * The `ensureNode` function checks if the input is a valid node and returns it, or converts it to a
      * node if it is a key or entry.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, `KeyOrNodeOrEntry<K, V, NODE>`, or
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, `BTNKeyOrNodeOrEntry<K, V, NODE>`, or
      * a raw element.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
      * parameter that specifies the type of iteration to be used when searching for a node. It has a
@@ -7895,8 +8012,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of the BinaryTreeNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `BinaryTreeNode` class.
      */
@@ -7905,8 +8022,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if a given node is a valid node in a binary search tree.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
-     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
     isRealNode(node) {
@@ -7916,8 +8033,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if a given node is a real node or null.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
-     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
     isNodeOrNull(node) {
@@ -7925,8 +8042,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if a given node is equal to the NIL value.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
-     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
     isNIL(node) {
@@ -7935,8 +8052,8 @@ var dataStructureTyped = (() => {
     /**
      * The function checks if the input is an array with two elements, indicating it is a binary tree
      * node entry.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
     isEntry(keyOrNodeOrEntryOrRawElement) {
@@ -7984,10 +8101,10 @@ var dataStructureTyped = (() => {
      *
      * The `add` function is used to insert a new node into a binary tree, checking for duplicate keys
      * and finding the appropriate insertion position.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
      * `keyOrNodeOrEntryOrRawElement` parameter can accept a value of type `R`, which represents the key,
      * node, entry, or raw element to be added to the tree. It can also accept a value of type
-     * `KeyOrNodeOrEntry<K, V, NODE>
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key being added to the tree. It represents the value that will be stored in the tree for the given
      * key.
@@ -8082,7 +8199,7 @@ var dataStructureTyped = (() => {
      *
      * The `refill` function clears the current data and adds new data to the collection.
      * @param keysOrNodesOrEntriesOrRawElements - An iterable collection of keys, nodes, entries, or raw
-     * elements. These can be of any type (R) or a specific type (KeyOrNodeOrEntry<K, V, NODE>).
+     * elements. These can be of any type (R) or a specific type (BTNKeyOrNodeOrEntry<K, V, NODE>).
      * @param [values] - The `values` parameter is an optional iterable of values that will be associated
      * with the keys or nodes being added. If provided, the values will be assigned to the corresponding
      * keys or nodes. If not provided, the values will be set to `undefined`.
@@ -8173,7 +8290,7 @@ var dataStructureTyped = (() => {
      * the identifier or all nodes that match the identifier. If set to true, only the first matching
      * node will be returned. If set to false, all matching nodes will be returned. The default value is
      * false.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the search. It can be either a node object, a key-value pair, or a key. If it is not
      * provided, the `root` of the data structure is used as the starting point.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
@@ -8231,7 +8348,7 @@ var dataStructureTyped = (() => {
      * the `C` callback function, or it can be `null` or `undefined`.
      * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
      * node matches the desired criteria. It should return a value that can be used to identify the node.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for searching nodes in a tree structure. It can be either a root node, a key-value pair, or
      * a node entry. If not provided, the search will start from the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -8276,7 +8393,7 @@ var dataStructureTyped = (() => {
      * callback function `C`. It can also be `null` or `undefined` if no identifier is provided.
      * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
      * node matches the given identifier. It is optional and defaults to `this._DEFAULT_CALLBACK`.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the search in the binary tree. It can be either a root node of the tree or a key, node,
      * or entry object that exists in the tree. If no specific starting point is provided, the search
      * will begin from the root of the
@@ -8307,7 +8424,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be used to determine
      * whether a node should be included in the result or not. It is of type `C`, which extends the
      * `BTNCallback<NODE>` type.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the iteration in the data structure. It can be either a root node, a key-value pair, or
      * a node entry. If not specified, it defaults to the root of the data structure.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -8356,10 +8473,10 @@ var dataStructureTyped = (() => {
      *
      * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
      * height of the tree.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The parameter `beginRoot` is optional and
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The parameter `beginRoot` is optional and
      * has a default value of `this.root`. It represents the starting point for checking if the tree is
      * perfectly balanced. It can be either a root node (`R`), a key or node or entry
-     * (`KeyOrNodeOrEntry<K, V, NODE
+     * (`BTNKeyOrNodeOrEntry<K, V, NODE
      * @returns a boolean value.
      */
     isPerfectlyBalanced(beginRoot = this.root) {
@@ -8374,7 +8491,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `isBST` checks if a binary search tree is valid, either recursively or iteratively.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for checking if a binary search tree (BST) is valid. It can be either a root node
      * of the BST, a key value of a node in the BST, or an entry object containing both the key and value
      * of a node in the BST
@@ -8431,10 +8548,10 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function calculates the depth of a given node or key in a tree-like data structure.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} dist - The `dist` parameter can be either a `R`
-     * (representing a root node), or a `KeyOrNodeOrEntry<K, V, NODE>` (representing a key, node, or
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} dist - The `dist` parameter can be either a `R`
+     * (representing a root node), or a `BTNKeyOrNodeOrEntry<K, V, NODE>` (representing a key, node, or
      * entry).
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is optional and
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is optional and
      * represents the starting point from which to calculate the depth. It can be either a reference to a
      * node in the tree or a key-value pair or an entry object. If not provided, the default value is
      * `this.root`, which refers to the root node
@@ -8463,9 +8580,9 @@ var dataStructureTyped = (() => {
      *
      * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
      * or iterative approach.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for calculating the height of a tree. It can be either a root node (`R`), a key or
-     * node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current tree.
+     * node or entry (`BTNKeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current tree.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
      * iteration used to calculate the height of the tree. It can have two possible values:
      * @returns the maximum height of the binary tree.
@@ -8507,9 +8624,9 @@ var dataStructureTyped = (() => {
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for calculating the minimum height of a tree. It can be either a root node (`R`), a
-     * key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current
+     * key or node or entry (`BTNKeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current
      * tree.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
      * iteration to be used when calculating the minimum height of the tree. It can have two possible
@@ -8569,8 +8686,8 @@ var dataStructureTyped = (() => {
      *
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
      * up to the root node, with an option to reverse the order of the nodes.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginNode - The `beginNode` parameter can be either of
-     * type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginNode - The `beginNode` parameter can be either of
+     * type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
      * resulting path should be reversed or not. If `isReverse` is set to `true`, the path will be
      * reversed before returning it. If `isReverse` is set to `false` or not provided, the path will
@@ -8598,9 +8715,9 @@ var dataStructureTyped = (() => {
      *
      * The `getLeftMost` function returns the leftmost node in a binary tree, either using recursive or
      * iterative traversal.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for finding the leftmost node in a binary tree. It can be either a root node (`R`),
-     * a key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
+     * a key or node or entry (`BTNKeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
      * of iteration to be performed. It can have two possible values:
      * @returns The function `getLeftMost` returns the leftmost node in a binary tree.
@@ -8637,9 +8754,9 @@ var dataStructureTyped = (() => {
      *
      * The `getRightMost` function returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for finding the rightmost node in a binary tree. It can be either a root node
-     * (`R`), a key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
+     * (`R`), a key or node or entry (`BTNKeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
      * of iteration to be performed when finding the rightmost node in a binary tree. It can have two
      * possible values:
@@ -8735,7 +8852,7 @@ var dataStructureTyped = (() => {
      * return type of the callback function is determined by the generic type `C`.
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter determines the order in which the
      * nodes are visited during the depth-first search. It can have one of the following values:
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point of the depth-first search. It can be either a node object, a key-value pair, or a key. If it
      * is a key or key-value pair, the method will find the corresponding node in the tree and start the
      * search from there.
@@ -8859,7 +8976,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the breadth-first search traversal. It takes a single argument, which is the current node being
      * visited, and returns a value of any type.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point of the breadth-first search. It can be either a root node of a tree or a key, node,
      * or entry object. If no value is provided, the `root` property of the class is used as the default
      * starting point.
@@ -8934,7 +9051,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the tree. It takes a node as an argument and returns a value. The return type of the callback
      * function is determined by the generic type `C` which extends `BTNCallback<NODE | null>`.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for traversing the tree. It can be either a root node, a key-value pair, or a node
      * entry. If no value is provided, the `root` property of the class is used as the default starting
      * point.
@@ -9009,7 +9126,7 @@ var dataStructureTyped = (() => {
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `morris` function is used
      * to specify the order in which the nodes of a binary tree are traversed. It can take one of the
      * following values:
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the traversal. It can be either a node object, a key, or an entry object. If no value is
      * provided, the `root` of the tree is used as the starting point.
      * @returns The function `morris` returns an array of values that are the return values of the
@@ -9196,7 +9313,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n)
      *
      * The `print` function in TypeScript prints the binary tree structure with customizable options.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for printing the binary tree. It can be either a node of the binary tree or a key or entry
      * that exists in the binary tree. If no value is provided, the root of the binary tree will be used
      * as the starting point.
@@ -9278,7 +9395,7 @@ var dataStructureTyped = (() => {
      *
      * The `_displayAux` function is responsible for generating the display layout of a binary tree node,
      * taking into account various options such as whether to show null, undefined, or NaN nodes.
-     * @param {NODE | null | undefined} node - The `node` parameter represents a node in a binary tree.
+     * @param {OptBTNOrNull<NODE>} node - The `node` parameter represents a node in a binary tree.
      * It can be of type `NODE`, `null`, or `undefined`.
      * @param {BinaryTreePrintOptions} options - The `options` parameter is an object that contains the
      * following properties:
@@ -9299,7 +9416,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 +9424,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) {
@@ -9338,10 +9455,10 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `_swapProperties` swaps the key-value properties between two nodes.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} srcNode - The source node that will be swapped with the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} srcNode - The source node that will be swapped with the
      * destination node. It can be either an instance of the class `R`, or an object of type
-     * `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} destNode - The `destNode` parameter is the node where
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} destNode - The `destNode` parameter is the node where
      * the properties will be swapped with the `srcNode`.
      * @returns either the `destNode` object with its properties swapped with the `srcNode` object's
      * properties, or `undefined` if either `srcNode` or `destNode` is falsy.
@@ -9404,7 +9521,7 @@ var dataStructureTyped = (() => {
      *
      * The function sets the root property of an object to the provided value, and also updates the
      * parent property of the new root.
-     * @param {NODE | null | undefined} v - The parameter `v` is of type `NODE | null | undefined`. This
+     * @param {OptBTNOrNull<NODE>} v - The parameter `v` is of type `OptBTNOrNull<NODE>`. This
      * means that it can accept a value of type `NODE`, `null`, or `undefined`.
      */
     _setRoot(v) {
@@ -9458,7 +9575,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function sets the left child of a node and updates the parent reference of the child.
-     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be an
+     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be an
      * instance of the `NODE` class or `undefined`.
      */
     set left(v) {
@@ -9477,7 +9594,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function sets the right child of a node and updates the parent reference of the child.
-     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be a
+     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be a
      * `NODE` object or `undefined`.
      */
     set right(v) {
@@ -9499,14 +9616,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 +9628,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;
@@ -9561,8 +9670,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
-     * type R or KeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
+     * type R or BTNKeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
      * element.
      * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
      * value associated with a key in a key-value pair.
@@ -9578,7 +9687,7 @@ var dataStructureTyped = (() => {
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
      * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, which represents the key, node,
      * entry, or raw element that needs to be ensured in the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
@@ -9593,8 +9702,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `BSTNode` class.
      */
@@ -9606,8 +9715,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key in the binary search tree. If provided, it will be stored in the node along with the key.
      * @returns a boolean value.
@@ -9766,7 +9875,7 @@ var dataStructureTyped = (() => {
      * @param [onlyOne=false] - A boolean value indicating whether to return only the first matching node
      * or all matching nodes. If set to true, only the first matching node will be returned. If set to
      * false, all matching nodes will be returned. The default value is false.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the search in the binary tree. It can be either a node object, a key-value pair, or an
      * entry object. If it is not provided, the `root` of the binary tree is used as the starting point.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
@@ -9888,7 +9997,7 @@ var dataStructureTyped = (() => {
      * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
      * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
      * take one of the following values:
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
      * node entry. If not specified, the default value is the root of the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
@@ -9912,7 +10021,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * visited during the breadth-first search. It should take a single argument, which is the current
      * node being visited, and it can return a value of any type.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
      * object. If no value is provided, the default value is the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -9936,7 +10045,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
      * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the
      * tree during the iteration process.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for listing the levels of the binary tree. It can be either a root node of the tree, a
      * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
      * value is provided, the root of
@@ -9964,7 +10073,7 @@ var dataStructureTyped = (() => {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
      * 0, or 1, where:
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} targetNode - The `targetNode` parameter is the node in
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} targetNode - The `targetNode` parameter is the node in
      * the binary tree that you want to start traversing from. It can be specified either by providing
      * the key of the node, the node itself, or an entry containing the key and value of the node. If no
      * `targetNode` is provided,
@@ -10134,7 +10243,7 @@ var dataStructureTyped = (() => {
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
-     * @param {NODE | undefined} v - v is a parameter of type NODE or undefined.
+     * @param {OptBSTN<NODE>} v - v is a parameter of type NODE or undefined.
      */
     _setRoot(v) {
       if (v) {
@@ -10784,8 +10893,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of AVLTreeNode.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `AVLTreeNode` class.
      */
@@ -10803,8 +10912,8 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a class and inserts a key-value pair into a data
      * structure, then balances the path.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept values of type `R`, `KeyOrNodeOrEntry<K, V, NODE>`, or
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept values of type `R`, `BTNKeyOrNodeOrEntry<K, V, NODE>`, or
      * `RawElement`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key or node being added to the data structure.
@@ -11123,8 +11232,8 @@ var dataStructureTyped = (() => {
      *
      * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
      * to restore balance in an AVL tree after inserting a node.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The `node` parameter can be of type `R` or
-     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The `node` parameter can be of type `R` or
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      */
     _balancePath(node) {
       node = this.ensureNode(node);
@@ -11272,8 +11381,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `RedBlackTreeNode` class.
      */
@@ -11291,11 +11400,11 @@ var dataStructureTyped = (() => {
     //  *
     //  * The function `keyValueOrEntryOrRawElementToNode` takes a key, value, or entry and returns a node if it is
     //  * valid, otherwise it returns undefined.
-    //  * @param {KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The key, value, or entry to convert.
+    //  * @param {BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The key, value, or entry to convert.
     //  * @param {V} [value] - The value associated with the key (if `keyOrNodeOrEntryOrRawElement` is a key).
     //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
     //  */
-    // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined {
+    // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined {
     //
     //   if (keyOrNodeOrEntryOrRawElement === null || keyOrNodeOrEntryOrRawElement === undefined) return;
     //   if (this.isNode(keyOrNodeOrEntryOrRawElement)) return keyOrNodeOrEntryOrRawElement;
@@ -11340,8 +11449,8 @@ var dataStructureTyped = (() => {
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key in the data structure. It represents the value that you want to add or update in the data
      * structure.
@@ -11847,8 +11956,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of AVLTreeMultiMapNode.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `AVLTreeMultiMapNode` class.
      */
@@ -11858,8 +11967,8 @@ var dataStructureTyped = (() => {
     /**
      * The function `keyValueOrEntryOrRawElementToNode` converts a key, value, entry, or raw element into
      * a node object.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
-     * `keyOrNodeOrEntryOrRawElement` parameter can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * `keyOrNodeOrEntryOrRawElement` parameter can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `override` function. It represents the value associated with the key in the data structure. If no
      * value is provided, it will default to `undefined`.
@@ -11898,9 +12007,9 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a TypeScript class to add a new node to a data structure
      * and update the count.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
      * `keyOrNodeOrEntryOrRawElement` parameter can accept a value of type `R`, which can be any type. It
-     * can also accept a value of type `KeyOrNodeOrEntry<K, V, NODE>`, which represents a key, node,
+     * can also accept a value of type `BTNKeyOrNodeOrEntry<K, V, NODE>`, which represents a key, node,
      * entry, or raw element
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
@@ -12245,8 +12354,8 @@ var dataStructureTyped = (() => {
     /**
      * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that represents the value
      * associated with the key in the node. It is used when creating a new node or updating the value of
      * an existing node.
@@ -12277,8 +12386,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `TreeMultiMapNode` class.
      */
@@ -12295,7 +12404,7 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a class and adds a new node to a data structure, updating
      * the count and returning a boolean indicating success.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
      * `keyOrNodeOrEntryOrRawElement` parameter can accept one of the following types:
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
@@ -12562,11 +12671,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 +12683,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 +12763,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 +12850,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 +13550,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 +13560,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 +13904,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 +13925,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 +13943,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));