data-structure-typed 1.50.1 → 1.50.2

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

@@ -317,6 +317,100 @@ var dataStructureTyped = (() => {
         callbackfn.call(thisArg, value, key, index++, this);
       }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `find` function iterates over the entries of a collection and returns the first value for
+     * which the callback function returns true.
+     * @param callbackfn - The callback function that will be called for each entry in the collection. It
+     * takes three arguments: the value of the entry, the key of the entry, and the index of the entry in
+     * the collection. It should return a boolean value indicating whether the current entry matches the
+     * desired condition.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+     * be passed as the `this` value to the `callbackfn` function. If `thisArg
+     * @returns The method `find` returns the value of the first element in the iterable that satisfies
+     * the provided callback function. If no element satisfies the callback function, `undefined` is
+     * returned.
+     */
+    find(callbackfn, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        const [key, value] = item;
+        if (callbackfn.call(thisArg, value, key, index++, this))
+          return item;
+      }
+      return;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function checks if a given key exists in a collection.
+     * @param {K} key - The parameter "key" is of type K, which means it can be any type. It represents
+     * the key that we want to check for existence in the data structure.
+     * @returns a boolean value. It returns true if the key is found in the collection, and false
+     * otherwise.
+     */
+    has(key) {
+      for (const item of this) {
+        const [itemKey] = item;
+        if (itemKey === key)
+          return true;
+      }
+      return false;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function checks if a given value exists in a collection.
+     * @param {V} value - The parameter "value" is the value that we want to check if it exists in the
+     * collection.
+     * @returns a boolean value, either true or false.
+     */
+    hasValue(value) {
+      for (const [, elementValue] of this) {
+        if (elementValue === value)
+          return true;
+      }
+      return false;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `get` function retrieves the value associated with a given key from a collection.
+     * @param {K} key - K (the type of the key) - This parameter represents the key that is being
+     * searched for in the collection.
+     * @returns The `get` method returns the value associated with the specified key if it exists in the
+     * collection, otherwise it returns `undefined`.
+     */
+    get(key) {
+      for (const item of this) {
+        const [itemKey, value] = item;
+        if (itemKey === key)
+          return value;
+      }
+      return;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -346,13 +440,6 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
-    hasValue(value) {
-      for (const [, elementValue] of this) {
-        if (elementValue === value)
-          return true;
-      }
-      return false;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -470,6 +557,55 @@ var dataStructureTyped = (() => {
         callbackfn.call(thisArg, item, index++, this);
       }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `find` function iterates over the elements of an array-like object and returns the first
+     * element that satisfies the provided callback function.
+     * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
+     * the array. It takes three arguments: the current element being processed, the index of the current
+     * element, and the array itself. The function should return a boolean value indicating whether the
+     * current element matches the desired condition.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+     * be passed as the `this` value to the `callbackfn` function. If `thisArg
+     * @returns The `find` method returns the first element in the array that satisfies the provided
+     * callback function. If no element satisfies the callback function, `undefined` is returned.
+     */
+    find(callbackfn, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        if (callbackfn.call(thisArg, item, index++, this))
+          return item;
+      }
+      return;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function checks if a given element exists in a collection.
+     * @param {E} element - The parameter "element" is of type E, which means it can be any type. It
+     * represents the element that we want to check for existence in the collection.
+     * @returns a boolean value. It returns true if the element is found in the collection, and false
+     * otherwise.
+     */
+    has(element) {
+      for (const ele of this) {
+        if (ele === element)
+          return true;
+      }
+      return false;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -619,18 +755,49 @@ var dataStructureTyped = (() => {
         this.setMany(rawCollection);
       }
     }
+    /**
+     * The function returns the value of the _toEntryFn property.
+     * @returns The function being returned is `this._toEntryFn`.
+     */
     get toEntryFn() {
       return this._toEntryFn;
     }
+    /**
+     * The hasFn function is a function that takes in an item and returns a boolean
+     * indicating whether the item is contained within the hash table.
+     *
+     * @return The hash function
+     */
+    get hasFn() {
+      return this._hashFn;
+    }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size() {
       return this._size;
     }
+    /**
+     * The function checks if a given element is an array with exactly two elements.
+     * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
+     * data type.
+     * @returns a boolean value.
+     */
     isEntry(rawElement) {
       return Array.isArray(rawElement) && rawElement.length === 2;
     }
+    /**
+     * The function checks if the size of an object is equal to zero and returns a boolean value.
+     * @returns A boolean value indicating whether the size of the object is 0 or not.
+     */
     isEmpty() {
       return this.size === 0;
     }
+    /**
+     * The clear() function resets the state of an object by clearing its internal store, object map, and
+     * size.
+     */
     clear() {
       this._store = {};
       this._objMap.clear();
@@ -670,7 +837,15 @@ var dataStructureTyped = (() => {
     setMany(rawCollection) {
       const results = [];
       for (const rawEle of rawCollection) {
-        const [key, value] = this.toEntryFn(rawEle);
+        let key, value;
+        if (this.isEntry(rawEle)) {
+          key = rawEle[0];
+          value = rawEle[1];
+        } else {
+          const item = this.toEntryFn(rawEle);
+          key = item[0];
+          value = item[1];
+        }
         results.push(this.set(key, value));
       }
       return results;
@@ -729,6 +904,16 @@ var dataStructureTyped = (() => {
         return false;
       }
     }
+    /**
+     * The clone function creates a new HashMap with the same key-value pairs as
+     * this one. The clone function is useful for creating a copy of an existing
+     * HashMap, and then modifying that copy without affecting the original.
+     *
+     * @return A new hashmap with the same values as this one
+     */
+    clone() {
+      return new _HashMap(this, { hashFn: this._hashFn, toEntryFn: this.toEntryFn });
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -785,6 +970,14 @@ var dataStructureTyped = (() => {
       }
       return filteredMap;
     }
+    /**
+     * The put function sets a value in a data structure using a specified key.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key being passed
+     * to the function.
+     * @param {V} value - The value parameter represents the value that you want to associate with the
+     * specified key in the data structure.
+     * @returns The method is returning a boolean value.
+     */
     put(key, value) {
       return this.set(key, value);
     }
@@ -820,35 +1013,64 @@ var dataStructureTyped = (() => {
     }
   };
   var LinkedHashMap = class _LinkedHashMap extends IterableEntryBase {
-    constructor(entries, options) {
+    /**
+     * The constructor initializes a LinkedHashMap object with an optional raw collection and options.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements. It is
+     * used to initialize the HashMapLinked instance with key-value pairs. Each element in the
+     * `rawCollection` is converted to a key-value pair using the `toEntryFn` function (if provided) and
+     * then added to the HashMap
+     * @param [options] - The `options` parameter is an optional object that can contain the following
+     * properties:
+     */
+    constructor(rawCollection = [], options) {
       super();
       __publicField(this, "_noObjMap", {});
       __publicField(this, "_objMap", /* @__PURE__ */ new WeakMap());
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_sentinel");
+      __publicField(this, "_toEntryFn", (rawElement) => {
+        if (this.isEntry(rawElement)) {
+          return rawElement;
+        } else {
+          throw new Error(
+            "If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified."
+          );
+        }
+      });
       __publicField(this, "_size", 0);
-      /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(n)
-       */
       __publicField(this, "_hashFn", (key) => String(key));
       __publicField(this, "_objHashFn", (key) => key);
       this._sentinel = {};
       this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
       if (options) {
-        const { hashFn, objHashFn } = options;
+        const { hashFn, objHashFn, toEntryFn } = options;
         if (hashFn)
           this._hashFn = hashFn;
         if (objHashFn)
           this._objHashFn = objHashFn;
+        if (toEntryFn) {
+          this._toEntryFn = toEntryFn;
+        }
       }
-      if (entries) {
-        for (const el of entries) {
-          this.set(el[0], el[1]);
+      if (rawCollection) {
+        for (const el of rawCollection) {
+          const [key, value] = this.toEntryFn(el);
+          this.set(key, value);
         }
       }
     }
+    /**
+     * The function returns the value of the _toEntryFn property.
+     * @returns The function being returned is `this._toEntryFn`.
+     */
+    get toEntryFn() {
+      return this._toEntryFn;
+    }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object.
+     */
     get size() {
       return this._size;
     }
@@ -946,6 +1168,28 @@ var dataStructureTyped = (() => {
       }
       return true;
     }
+    /**
+     * The function `setMany` takes an iterable collection, converts each element into a key-value pair
+     * using a provided function, and sets each key-value pair in the current object, returning an array
+     * of booleans indicating the success of each set operation.
+     * @param rawCollection - The rawCollection parameter is an iterable collection of elements of type
+     * R.
+     * @returns The `setMany` function returns an array of booleans.
+     */
+    setMany(rawCollection) {
+      const results = [];
+      for (const rawEle of rawCollection) {
+        const [key, value] = this.toEntryFn(rawEle);
+        results.push(this.set(key, value));
+      }
+      return results;
+    }
+    /**
+     * The function checks if a given key exists in a map, using different logic depending on whether the
+     * key is a weak key or not.
+     * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.
+     * @returns The method `has` is returning a boolean value.
+     */
     has(key) {
       if (isWeakKey(key)) {
         const hash = this._objHashFn(key);
@@ -955,14 +1199,6 @@ var dataStructureTyped = (() => {
         return hash in this._noObjMap;
       }
     }
-    setMany(entries) {
-      const results = [];
-      for (const entry of entries) {
-        const [key, value] = entry;
-        results.push(this.set(key, value));
-      }
-      return results;
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -991,14 +1227,14 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the index.
      * Space Complexity: O(1)
      *
-     * The function `getAt` retrieves the key-value pair at a specified index in a linked list.
+     * The function `at` retrieves the key-value pair at a specified index in a linked list.
      * @param {number} index - The index parameter is a number that represents the position of the
      * element we want to retrieve from the data structure.
-     * @returns The method `getAt(index: number)` is returning an array containing the key-value pair at
+     * @returns The method `at(index: number)` is returning an array containing the key-value pair at
      * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
      * where `K` is the key and `V` is the value.
      */
-    getAt(index) {
+    at(index) {
       rangeCheck(index, 0, this._size - 1);
       let node = this._head;
       while (index--) {
@@ -1037,7 +1273,7 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(n), where n is the index.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `deleteAt` function deletes a node at a specified index in a linked list.
@@ -1064,6 +1300,15 @@ var dataStructureTyped = (() => {
     isEmpty() {
       return this._size === 0;
     }
+    /**
+     * The function checks if a given element is an array with exactly two elements.
+     * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
+     * data type.
+     * @returns a boolean value.
+     */
+    isEntry(rawElement) {
+      return Array.isArray(rawElement) && rawElement.length === 2;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -1075,6 +1320,19 @@ var dataStructureTyped = (() => {
       this._size = 0;
       this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone` function creates a new instance of a `LinkedHashMap` with the same key-value pairs as
+     * the original.
+     * @returns The `clone()` method is returning a new instance of `LinkedHashMap<K, V>` that is a clone
+     * of the original `LinkedHashMap` object.
+     */
     clone() {
       const cloned = new _LinkedHashMap([], { hashFn: this._hashFn, objHashFn: this._objHashFn });
       for (const entry of this) {
@@ -1137,15 +1395,27 @@ var dataStructureTyped = (() => {
       return mappedMap;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The put function sets a value in a data structure using a specified key.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key being passed
+     * to the function.
+     * @param {V} value - The value parameter represents the value that you want to associate with the
+     * specified key in the data structure.
+     * @returns The method is returning a boolean value.
      */
     put(key, value) {
       return this.set(key, value);
     }
     /**
-     * Time Complexity: O(n), where n is the number of entries in the LinkedHashMap.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
+     * where n is the number of entries in the LinkedHashMap.
      *
      * The above function is an iterator that yields key-value pairs from a linked list.
      */
@@ -1197,7 +1467,10 @@ var dataStructureTyped = (() => {
   };
   var SinglyLinkedList = class _SinglyLinkedList extends IterableElementBase {
     /**
-     * The constructor initializes the linked list with an empty head, tail, and length.
+     * 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();
@@ -1209,22 +1482,36 @@ var dataStructureTyped = (() => {
           this.push(el);
       }
     }
+    /**
+     * The `head` function returns the first node of a singly linked list.
+     * @returns The method is returning either a SinglyLinkedListNode object or undefined.
+     */
     get head() {
       return this._head;
     }
+    /**
+     * The `tail` function returns the last node of a singly linked list.
+     * @returns The method is returning either a SinglyLinkedListNode object or undefined.
+     */
     get tail() {
       return this._tail;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size() {
       return this._size;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the input array, as it performs a loop to push each element into the linked list.
-     * Space Complexity: O(n) - Linear space, as it creates a new node for each element in the array.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * Linear time, where n is the length of the input array, as it performs a loop to push each element into the linked list.
+     * Linear space, as it creates a new node for each element in the array.
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the input array, as it performs a loop to push each element into the linked list.
-     * Space Complexity: O(n) - Linear space, as it creates a new node for each element in the array.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
      * array.
@@ -1239,12 +1526,14 @@ var dataStructureTyped = (() => {
       return singlyLinkedList;
     }
     /**
-     * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
-     * Space Complexity: O(1) - Constant space, as it only creates a new node.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * Constant time, as it involves basic pointer adjustments.
+     * Constant space, as it only creates a new node.
      */
     /**
-     * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
-     * Space Complexity: O(1) - Constant space, as it only creates a new node.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `push` function adds a new node with the given value to the end of a singly linked list.
      * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
@@ -1263,12 +1552,12 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
-     * Space Complexity: O(1) - Constant space, as it only creates a new node.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
-     * Space Complexity: O(1) - Constant space, as it only creates a new node.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `push` function adds a new node with the given value to the end of a singly linked list.
      * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
@@ -1278,12 +1567,13 @@ var dataStructureTyped = (() => {
       return this.push(value);
     }
     /**
-     * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * Linear time in the worst case, as it may need to traverse the list to find the last element.
      */
     /**
-     * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
@@ -1311,12 +1601,12 @@ var dataStructureTyped = (() => {
       return value;
     }
     /**
-     * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The `pollLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
@@ -1327,12 +1617,12 @@ var dataStructureTyped = (() => {
       return this.pop();
     }
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `shift()` function removes and returns the value of the first node in a linked list.
      * @returns The value of the node that is being removed from the beginning of the linked list.
@@ -1346,12 +1636,12 @@ var dataStructureTyped = (() => {
       return removedNode.value;
     }
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `pollFirst()` function removes and returns the value of the first node in a linked list.
      * @returns The value of the node that is being removed from the beginning of the linked list.
@@ -1360,12 +1650,12 @@ var dataStructureTyped = (() => {
       return this.shift();
     }
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The unshift function adds a new node with the given value to the beginning of a singly linked list.
      * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
@@ -1384,12 +1674,12 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
      * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
@@ -1399,20 +1689,21 @@ var dataStructureTyped = (() => {
       return this.unshift(value);
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
-     * The function `getAt` returns the value at a specified index in a linked list, or undefined if the index is out of range.
+     * The function `at` returns the value at a specified index in a linked list, or undefined if the index is out of range.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
      * retrieve from the list.
-     * @returns The method `getAt(index: number): E | undefined` returns the value at the specified index in the linked list, or
+     * @returns The method `at(index: number): E | undefined` returns the value at the specified index in the linked list, or
      * `undefined` if the index is out of bounds.
      */
-    getAt(index) {
+    at(index) {
       if (index < 0 || index >= this.size)
         return void 0;
       let current = this.head;
@@ -1422,12 +1713,12 @@ var dataStructureTyped = (() => {
       return current.value;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The function `getNodeAt` returns the node at a given index in a singly linked list.
      * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
@@ -1443,12 +1734,12 @@ var dataStructureTyped = (() => {
       return current;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
      * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
@@ -1474,12 +1765,12 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The delete function removes a node with a specific value from a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} valueOrNode - The `valueOrNode` parameter can accept either a value of type `E`
@@ -1519,12 +1810,12 @@ var dataStructureTyped = (() => {
       return false;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The `addAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
@@ -1569,12 +1860,14 @@ var dataStructureTyped = (() => {
       this._size = 0;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to traverse the entire list to convert it to an array.
-     * Space Complexity: O(n) - Linear space, as it creates an array with the same length as the list.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * Linear time, where n is the length of the list, as it needs to traverse the entire list to convert it to an array.
+     * Linear space, as it creates an array with the same length as the list.
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to traverse the entire list to convert it to an array.
-     * Space Complexity: O(n) - Linear space, as it creates an array with the same length as the list.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The `toArray` function converts a linked list into an array.
      * @returns The `toArray()` method is returning an array of type `E[]`.
@@ -1589,12 +1882,12 @@ var dataStructureTyped = (() => {
       return array;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The `reverse` function reverses the order of the nodes in a singly linked list.
      * @returns The reverse() method does not return anything. It has a return type of void.
@@ -1615,36 +1908,12 @@ var dataStructureTyped = (() => {
       return this;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
-     */
-    /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
-     *
-     * The `find` function iterates through a linked list and returns the first element that satisfies a given condition.
-     * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
-     * function is used to determine whether a particular value in the linked list satisfies a certain condition.
-     * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
-     * the callback function. If no element satisfies the condition, it returns `undefined`.
-     */
-    find(callback) {
-      let current = this.head;
-      while (current) {
-        if (callback(current.value)) {
-          return current.value;
-        }
-        current = current.next;
-      }
-      return void 0;
-    }
-    /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The `indexOf` function returns the index of the first occurrence of a given value in a linked list.
      * @param {E} value - The value parameter is the value that you want to find the index of in the linked list.
@@ -1664,12 +1933,12 @@ var dataStructureTyped = (() => {
       return -1;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The function finds a node in a singly linked list by its value and returns the node if found, otherwise returns
      * undefined.
@@ -1688,12 +1957,12 @@ var dataStructureTyped = (() => {
       return void 0;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The `addBefore` function inserts a new value before an existing value in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
@@ -1729,12 +1998,12 @@ var dataStructureTyped = (() => {
       return false;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The `addAfter` function inserts a new node with a given value after an existing node in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
@@ -1763,12 +2032,12 @@ var dataStructureTyped = (() => {
       return false;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
      * The function counts the number of occurrences of a given value in a linked list.
      * @param {E} value - The value parameter is the value that you want to count the occurrences of in the linked list.
@@ -1785,6 +2054,22 @@ var dataStructureTyped = (() => {
       }
       return count;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone` function returns a new instance of the `SinglyLinkedList` class with the same values
+     * as the original list.
+     * @returns The `clone()` method is returning a new instance of the `SinglyLinkedList` class, which
+     * is a clone of the original list.
+     */
+    clone() {
+      return new _SinglyLinkedList(this.values());
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -1844,6 +2129,9 @@ var dataStructureTyped = (() => {
       }
       return mappedList;
     }
+    /**
+     * The function `_getIterator` returns an iterable iterator that yields the values of a linked list.
+     */
     *_getIterator() {
       let current = this.head;
       while (current) {
@@ -1871,7 +2159,10 @@ var dataStructureTyped = (() => {
   };
   var DoublyLinkedList = class _DoublyLinkedList extends IterableElementBase {
     /**
-     * The constructor initializes the linked list with an empty head, tail, and size.
+     * 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();
@@ -1887,21 +2178,35 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    /**
+     * The `head` function returns the first node of a doubly linked list.
+     * @returns The method `getHead()` returns either a `DoublyLinkedListNode<E>` object or `undefined`.
+     */
     get head() {
       return this._head;
     }
+    /**
+     * The `tail` function returns the last node of a doubly linked list.
+     * @returns The `get tail()` method is returning either a `DoublyLinkedListNode<E>` object or
+     * `undefined`.
+     */
     get tail() {
       return this._tail;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size() {
       return this._size;
     }
     /**
-     * Time Complexity: O(n), where n is the size of the input array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
+     * where n is the number of elements in the linked list.
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `get first` function returns the first node in a doubly linked list, or undefined if the list is empty.
@@ -1916,7 +2221,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `get last` function returns the last node in a doubly linked list, or undefined if the list is empty.
@@ -1940,11 +2245,7 @@ var dataStructureTyped = (() => {
      * @returns The `fromArray` function returns a DoublyLinkedList object.
      */
     static fromArray(data) {
-      const doublyLinkedList = new _DoublyLinkedList();
-      for (const item of data) {
-        doublyLinkedList.push(item);
-      }
-      return doublyLinkedList;
+      return new _DoublyLinkedList(data);
     }
     /**
      * Time Complexity: O(1)
@@ -1997,7 +2298,7 @@ var dataStructureTyped = (() => {
       return removedNode.value;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
@@ -2023,7 +2324,7 @@ var dataStructureTyped = (() => {
       return removedNode.value;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
@@ -2048,20 +2349,20 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `getAt` function returns the value at a specified index in a linked list, or undefined if the index is out of bounds.
+     * The `at` function returns the value at a specified index in a linked list, or undefined if the index is out of bounds.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
      * retrieve from the list.
      * @returns The method is returning the value at the specified index in the linked list. If the index is out of bounds
      * or the linked list is empty, it will return undefined.
      */
-    getAt(index) {
+    at(index) {
       if (index < 0 || index >= this.size)
         return void 0;
       let current = this.head;
@@ -2071,11 +2372,11 @@ var dataStructureTyped = (() => {
       return current.value;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The function `getNodeAt` returns the node at a given index in a doubly linked list, or undefined if the index is out of
@@ -2095,11 +2396,11 @@ var dataStructureTyped = (() => {
       return current;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The function `findNodeByValue` searches for a node with a specific value in a doubly linked list and returns the
@@ -2119,11 +2420,11 @@ var dataStructureTyped = (() => {
       return void 0;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `insert` function inserts a value at a specified index in a doubly linked list.
@@ -2156,11 +2457,12 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
+     * where n is the number of elements in the linked list.
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `addBefore` function inserts a new value before an existing value or node in a doubly linked list.
@@ -2196,11 +2498,11 @@ var dataStructureTyped = (() => {
       return false;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `addAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
@@ -2235,7 +2537,7 @@ var dataStructureTyped = (() => {
       return false;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
@@ -2264,7 +2566,7 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes a node from a doubly linked list based on either the node itself or its value.
@@ -2297,7 +2599,7 @@ var dataStructureTyped = (() => {
       return false;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -2308,7 +2610,7 @@ var dataStructureTyped = (() => {
       return this.size === 0;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -2320,35 +2622,11 @@ var dataStructureTyped = (() => {
       this._size = 0;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `find` function iterates through a linked list and returns the first element that satisfies a given condition.
-     * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
-     * function is used to determine whether a particular value in the linked list satisfies a certain condition.
-     * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
-     * the callback function. If no element satisfies the condition, it returns `undefined`.
-     */
-    find(callback) {
-      let current = this.head;
-      while (current) {
-        if (callback(current.value)) {
-          return current.value;
-        }
-        current = current.next;
-      }
-      return void 0;
-    }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The function returns the index of the first occurrence of a given value in a linked list.
@@ -2370,11 +2648,11 @@ var dataStructureTyped = (() => {
       return -1;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
@@ -2395,11 +2673,11 @@ var dataStructureTyped = (() => {
       return void 0;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `reverse` function reverses the order of the elements in a doubly linked list.
@@ -2419,7 +2697,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * The `toArray` function converts a linked list into an array.
@@ -2435,11 +2713,11 @@ var dataStructureTyped = (() => {
       return array;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * The `toReversedArray` function converts a doubly linked list into an array in reverse order.
@@ -2454,6 +2732,22 @@ var dataStructureTyped = (() => {
       }
       return array;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone` function creates a new instance of the `DoublyLinkedList` class with the same values
+     * as the original list.
+     * @returns The `clone()` method is returning a new instance of the `DoublyLinkedList` class, which
+     * is a copy of the original list.
+     */
+    clone() {
+      return new _DoublyLinkedList(this.values());
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -2546,7 +2840,7 @@ var dataStructureTyped = (() => {
       return this.pop();
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
@@ -2561,7 +2855,7 @@ var dataStructureTyped = (() => {
       return this.shift();
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
@@ -2599,6 +2893,14 @@ var dataStructureTyped = (() => {
     }
   };
   var SkipList = class {
+    /**
+     * The constructor function initializes a SkipLinkedList object with optional options and elements.
+     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * is used to initialize the SkipLinkedList with the given key-value pairs. If no elements are
+     * provided, the SkipLinkedList will be empty.
+     * @param {SkipLinkedListOptions} [options] - The `options` parameter is an optional object that can
+     * contain two properties:
+     */
     constructor(elements = [], options) {
       __publicField(this, "_head", new SkipListNode(void 0, void 0, this.maxLevel));
       __publicField(this, "_level", 0);
@@ -2616,25 +2918,41 @@ var dataStructureTyped = (() => {
           this.add(key, value);
       }
     }
+    /**
+     * The function returns the head node of a SkipList.
+     * @returns The method is returning a SkipListNode object with generic key type K and value type V.
+     */
     get head() {
       return this._head;
     }
+    /**
+     * The function returns the value of the private variable _level.
+     * @returns The level property of the object.
+     */
     get level() {
       return this._level;
     }
+    /**
+     * The function returns the maximum level.
+     * @returns The value of the variable `_maxLevel` is being returned.
+     */
     get maxLevel() {
       return this._maxLevel;
     }
+    /**
+     * The function returns the probability value.
+     * @returns The probability value stored in the private variable `_probability` is being returned.
+     */
     get probability() {
       return this._probability;
     }
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * Get the value of the first element (the smallest element) in the Skip List.
      * @returns The value of the first element, or undefined if the Skip List is empty.
@@ -2644,12 +2962,12 @@ var dataStructureTyped = (() => {
       return firstNode ? firstNode.value : void 0;
     }
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * Get the value of the last element (the largest element) in the Skip List.
      * @returns The value of the last element, or undefined if the Skip List is empty.
@@ -2664,12 +2982,12 @@ var dataStructureTyped = (() => {
       return current.value;
     }
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The add function adds a new node with a given key and value to a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be added to the skip list.
@@ -2695,12 +3013,12 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function `get` retrieves the value associated with a given key from a skip list data structure.
      * @param {K} key - The `key` parameter is the key of the element that we want to retrieve from the data structure.
@@ -2721,23 +3039,25 @@ var dataStructureTyped = (() => {
       return void 0;
     }
     /**
-     * Time Complexity: O(1) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * The function checks if a key exists in a data structure.
+     * @param {K} key - The parameter "key" is of type K, which represents the type of the key being
+     * checked.
+     * @returns a boolean value.
      */
     has(key) {
       return this.get(key) !== void 0;
     }
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The `delete` function removes a node with a specific key from a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
@@ -2769,12 +3089,12 @@ var dataStructureTyped = (() => {
       return false;
     }
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * Get the value of the first element in the Skip List that is greater than the given key.
      * @param key - the given key.
@@ -2791,12 +3111,12 @@ var dataStructureTyped = (() => {
       return nextNode ? nextNode.value : void 0;
     }
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * Get the value of the last element in the Skip List that is less than the given key.
      * @param key - the given key.
@@ -2816,12 +3136,13 @@ var dataStructureTyped = (() => {
       return lastLess ? lastLess.value : void 0;
     }
     /**
-     * Time Complexity: O(maxLevel) - where maxLevel is the maximum level of the SkipList, as it may iterate up to maxLevel times in the worst case.
-     * Space Complexity: O(1) - constant space.
+     * Time Complexity: O(maxLevel)
+     * Space Complexity: O(1)
+     * where maxLevel is the maximum level of the SkipList, as it may iterate up to maxLevel times in the worst case.
      */
     /**
-     * Time Complexity: O(maxLevel) - where maxLevel is the maximum level of the SkipList, as it may iterate up to maxLevel times in the worst case.
-     * Space Complexity: O(1) - constant space.
+     * Time Complexity: O(maxLevel)
+     * Space Complexity: O(1)
      *
      * The function "_randomLevel" generates a random level based on a given probability and maximum level.
      * @returns the level, which is a number.
@@ -2851,6 +3172,10 @@ var dataStructureTyped = (() => {
           this.push(el);
       }
     }
+    /**
+     * The elements function returns the elements of this set.
+     * @return An array of elements
+     */
     get elements() {
       return this._elements;
     }
@@ -2934,8 +3259,26 @@ var dataStructureTyped = (() => {
       return this.elements.pop();
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * The delete function removes an element from the stack.
+     * @param element: E Specify the element to be deleted
+     * @return A boolean value indicating whether the element was successfully deleted or not
+     */
+    delete(element) {
+      const index = this.elements.indexOf(element);
+      return this.deleteAt(index);
+    }
+    /**
+     * The deleteAt function deletes the element at a given index.
+     * @param index: number Determine the index of the element to be deleted
+     * @return A boolean value
+     */
+    deleteAt(index) {
+      const spliced = this.elements.splice(index, 1);
+      return spliced.length === 1;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n)
@@ -3052,9 +3395,17 @@ var dataStructureTyped = (() => {
           this.push(el);
       }
     }
+    /**
+     * The elements function returns the elements of this set.
+     * @return An array of the elements in the stack
+     */
     get elements() {
       return this._elements;
     }
+    /**
+     * The offset function returns the offset of the current page.
+     * @return The value of the private variable _offset
+     */
     get offset() {
       return this._offset;
     }
@@ -3145,6 +3496,24 @@ var dataStructureTyped = (() => {
       this._offset = 0;
       return first;
     }
+    /**
+     * The delete function removes an element from the list.
+     * @param element: E Specify the element to be deleted
+     * @return A boolean value indicating whether the element was successfully deleted or not
+     */
+    delete(element) {
+      const index = this.elements.indexOf(element);
+      return this.deleteAt(index);
+    }
+    /**
+     * The deleteAt function deletes the element at a given index.
+     * @param index: number Determine the index of the element to be deleted
+     * @return A boolean value
+     */
+    deleteAt(index) {
+      const spliced = this.elements.splice(index, 1);
+      return spliced.length === 1;
+    }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -3213,7 +3582,7 @@ var dataStructureTyped = (() => {
      *
      * @param index
      */
-    getAt(index) {
+    at(index) {
       return this.elements[index];
     }
     /**
@@ -3252,12 +3621,13 @@ var dataStructureTyped = (() => {
       this._offset = 0;
     }
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
-     * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * where n is the number of elements in the queue. It creates a shallow copy of the internal array. the space required is proportional to the number of elements in the queue.
      */
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
-     * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The `clone()` function returns a new Queue object with the same elements as the original Queue.
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
@@ -3333,7 +3703,7 @@ var dataStructureTyped = (() => {
       }
     }
   };
-  var LinkedListQueue = class extends SinglyLinkedList {
+  var LinkedListQueue = class _LinkedListQueue extends SinglyLinkedList {
     /**
      * The `get first` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
      * @returns The `get first()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
@@ -3363,10 +3733,36 @@ var dataStructureTyped = (() => {
     peek() {
       return this.first;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * The `clone` function returns a new instance of the `LinkedListQueue` class with the same values as
+     * the current instance.
+     * @returns The `clone()` method is returning a new instance of `LinkedListQueue` with the same
+     * values as the original `LinkedListQueue`.
+     */
+    clone() {
+      return new _LinkedListQueue(this.values());
+    }
   };
 
   // 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.
+     * @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
+     * empty deque
+     * @param {DequeOptions} [options] - The `options` parameter is an optional object that can contain
+     * configuration options for the deque. In this code, it is used to set the `bucketSize` option,
+     * which determines the size of each bucket in the deque. If the `bucketSize` option is not provided
+     * or is not a number
+     */
     constructor(elements = [], options) {
       super();
       __publicField(this, "_bucketFirst", 0);
@@ -3405,9 +3801,26 @@ var dataStructureTyped = (() => {
         this.push(element);
       }
     }
+    /**
+     * The bucketSize function returns the size of the bucket.
+     *
+     * @return The size of the bucket
+     */
+    get bucketSize() {
+      return this._bucketSize;
+    }
+    /**
+     * The buckets function returns the buckets property of the object.
+     *
+     * @return The buckets property
+     */
     get buckets() {
       return this._buckets;
     }
+    /**
+     * The size function returns the number of items in the stack.
+     * @return The number of values in the set
+     */
     get size() {
       return this._size;
     }
@@ -3421,6 +3834,10 @@ var dataStructureTyped = (() => {
         return;
       return this._buckets[this._bucketFirst][this._firstInBucket];
     }
+    /**
+     * The last function returns the last element in the queue.
+     * @return The last element in the array
+     */
     get last() {
       if (this.size === 0)
         return;
@@ -3573,7 +3990,7 @@ var dataStructureTyped = (() => {
     *begin() {
       let index = 0;
       while (index < this.size) {
-        yield this.getAt(index);
+        yield this.at(index);
         index++;
       }
     }
@@ -3584,7 +4001,7 @@ var dataStructureTyped = (() => {
     *reverseBegin() {
       let index = this.size - 1;
       while (index >= 0) {
-        yield this.getAt(index);
+        yield this.at(index);
         index--;
       }
     }
@@ -3596,13 +4013,13 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `getAt` function retrieves an element at a specified position in an array-like data structure.
+     * The `at` function retrieves an element at a specified position in an array-like data structure.
      * @param {number} pos - The `pos` parameter represents the position of the element that you want to
      * retrieve from the data structure. It is of type `number` and should be a valid index within the
      * range of the data structure.
      * @returns The element at the specified position in the data structure is being returned.
      */
-    getAt(pos) {
+    at(pos) {
       rangeCheck(pos, 0, this.size - 1);
       const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
       return this._buckets[bucketIndex][indexInBucket];
@@ -3658,9 +4075,9 @@ var dataStructureTyped = (() => {
       } else {
         const arr = [];
         for (let i = pos; i < this.size; ++i) {
-          arr.push(this.getAt(i));
+          arr.push(this.at(i));
         }
-        this.cut(pos - 1);
+        this.cut(pos - 1, true);
         for (let i = 0; i < num; ++i)
           this.push(element);
         for (let i = 0; i < arr.length; ++i)
@@ -3680,18 +4097,46 @@ var dataStructureTyped = (() => {
      * updated size.
      * @param {number} pos - The `pos` parameter represents the position at which the string should be
      * cut. It is a number that indicates the index of the character where the cut should be made.
+     * @param {boolean} isCutSelf - If true, the original deque will not be cut, and return a new deque
      * @returns The method is returning the updated size of the data structure.
      */
-    cut(pos) {
-      if (pos < 0) {
-        this.clear();
-        return 0;
+    cut(pos, isCutSelf = false) {
+      if (isCutSelf) {
+        if (pos < 0) {
+          this.clear();
+          return this;
+        }
+        const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+        this._bucketLast = bucketIndex;
+        this._lastInBucket = indexInBucket;
+        this._size = pos + 1;
+        return this;
+      } else {
+        const newDeque = new _Deque([], { bucketSize: this._bucketSize });
+        for (let i = 0; i <= pos; i++) {
+          newDeque.push(this.at(i));
+        }
+        return newDeque;
+      }
+    }
+    cutRest(pos, isCutSelf = false) {
+      if (isCutSelf) {
+        if (pos < 0) {
+          this.clear();
+          return this;
+        }
+        const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+        this._bucketFirst = bucketIndex;
+        this._firstInBucket = indexInBucket;
+        this._size = this._size - pos;
+        return this;
+      } else {
+        const newDeque = new _Deque([], { bucketSize: this._bucketSize });
+        for (let i = pos; i < this.size; i++) {
+          newDeque.push(this.at(i));
+        }
+        return newDeque;
       }
-      const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
-      this._bucketLast = bucketIndex;
-      this._lastInBucket = indexInBucket;
-      this._size = pos + 1;
-      return this.size;
     }
     /**
      * Time Complexity: O(n)
@@ -3748,14 +4193,14 @@ var dataStructureTyped = (() => {
       let i = 0;
       let index = 0;
       while (i < size) {
-        const oldElement = this.getAt(i);
+        const oldElement = this.at(i);
         if (oldElement !== element) {
           this.setAt(index, oldElement);
           index += 1;
         }
         i += 1;
       }
-      this.cut(index - 1);
+      this.cut(index - 1, true);
       return true;
     }
     /**
@@ -3799,15 +4244,15 @@ var dataStructureTyped = (() => {
         return this;
       }
       let index = 1;
-      let prev = this.getAt(0);
+      let prev = this.at(0);
       for (let i = 1; i < this.size; ++i) {
-        const cur = this.getAt(i);
+        const cur = this.at(i);
         if (cur !== prev) {
           prev = cur;
           this.setAt(index++, cur);
         }
       }
-      this.cut(index - 1);
+      this.cut(index - 1, true);
       return this;
     }
     /**
@@ -3827,7 +4272,7 @@ var dataStructureTyped = (() => {
     sort(comparator) {
       const arr = [];
       for (let i = 0; i < this.size; ++i) {
-        arr.push(this.getAt(i));
+        arr.push(this.at(i));
       }
       arr.sort(comparator);
       for (let i = 0; i < this.size; ++i) {
@@ -3870,30 +4315,6 @@ var dataStructureTyped = (() => {
       this._bucketLast = newBuckets.length - 1;
       this._buckets = newBuckets;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `find` function iterates over the elements in a deque and returns the first element for which
-     * the callback function returns true, or undefined if no such element is found.
-     * @param callback - A function that takes three parameters: element, index, and deque. It should
-     * return a boolean value indicating whether the element satisfies a certain condition.
-     * @returns The method `find` returns the first element in the deque that satisfies the condition
-     * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
-     */
-    find(callback) {
-      for (let i = 0; i < this.size; ++i) {
-        const element = this.getAt(i);
-        if (callback(element, i, this)) {
-          return element;
-        }
-      }
-      return;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -3911,7 +4332,7 @@ var dataStructureTyped = (() => {
      */
     indexOf(element) {
       for (let i = 0; i < this.size; ++i) {
-        if (this.getAt(i) === element) {
+        if (this.at(i) === element) {
           return i;
         }
       }
@@ -3931,6 +4352,22 @@ var dataStructureTyped = (() => {
     toArray() {
       return [...this];
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone()` function returns a new instance of the `Deque` class with the same elements and
+     * bucket size as the original instance.
+     * @returns The `clone()` method is returning a new instance of the `Deque` class with the same
+     * elements as the original deque (`this`) and the same bucket size.
+     */
+    clone() {
+      return new _Deque([...this], { bucketSize: this.bucketSize });
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4048,7 +4485,7 @@ var dataStructureTyped = (() => {
      */
     *_getIterator() {
       for (let i = 0; i < this.size; ++i) {
-        yield this.getAt(i);
+        yield this.at(i);
       }
     }
     /**
@@ -4116,6 +4553,16 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/heap/heap.ts
   var Heap = class _Heap extends IterableElementBase {
+    /**
+     * 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
+     * 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
+     * order of elements in the heap.
+     */
     constructor(elements = [], options) {
       super();
       __publicField(this, "_comparator", (a, b) => {
@@ -4137,9 +4584,17 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    /**
+     * 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.
+     */
     get elements() {
       return this._elements;
     }
@@ -4167,11 +4622,12 @@ var dataStructureTyped = (() => {
       return new _Heap(elements, options);
     }
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
+     * where n is the number of elements in the heap.
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Insert an element into the heap and maintain the heap properties.
@@ -4182,11 +4638,12 @@ var dataStructureTyped = (() => {
       return this._bubbleUp(this.elements.length - 1);
     }
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
+     * where n is the number of elements in the heap.
      */
     /**
-     * Time Complexity: O(log n), 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.
@@ -4204,6 +4661,9 @@ var dataStructureTyped = (() => {
       return value;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Peek at the top element of the heap without removing it.
      * @returns The top element or undefined if the heap is empty.
      */
@@ -4449,6 +4909,9 @@ var dataStructureTyped = (() => {
       }
       return mappedHeap;
     }
+    /**
+     * The function `_getIterator` returns an iterable iterator for the elements in the class.
+     */
     *_getIterator() {
       for (const element of this.elements) {
         yield element;
@@ -4506,6 +4969,16 @@ var dataStructureTyped = (() => {
     }
   };
   var FibonacciHeapNode = class {
+    /**
+     * The constructor function initializes an object with an element and a degree, and sets the marked
+     * property to false.
+     * @param {E} element - The "element" parameter represents the value or data that will be stored in
+     * the node of a data structure. It can be any type of data, such as a number, string, object, or
+     * even another data structure.
+     * @param [degree=0] - The degree parameter represents the degree of the element in a data structure
+     * called a Fibonacci heap. The degree of a node is the number of children it has. By default, the
+     * degree is set to 0 when a new node is created.
+     */
     constructor(element, degree = 0) {
       __publicField(this, "element");
       __publicField(this, "degree");
@@ -4520,6 +4993,13 @@ var dataStructureTyped = (() => {
     }
   };
   var FibonacciHeap = class {
+    /**
+     * The constructor function initializes a FibonacciHeap object with an optional comparator function.
+     * @param [comparator] - The `comparator` parameter is an optional argument that represents a
+     * function used to compare elements in the FibonacciHeap. If a comparator function is provided, it
+     * will be used to determine the order of elements in the heap. If no comparator function is
+     * provided, a default comparator function will be used.
+     */
     constructor(comparator) {
       __publicField(this, "_root");
       __publicField(this, "_size", 0);
@@ -4531,15 +5011,32 @@ var dataStructureTyped = (() => {
         throw new Error("FibonacciHeap constructor: given comparator should be a function.");
       }
     }
+    /**
+     * The function returns the root node of a Fibonacci heap.
+     * @returns The method is returning either a FibonacciHeapNode object or undefined.
+     */
     get root() {
       return this._root;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size() {
       return this._size;
     }
+    /**
+     * The function returns the minimum node in a Fibonacci heap.
+     * @returns The method is returning the minimum node of the Fibonacci heap, which is of type
+     * `FibonacciHeapNode<E>`. If there is no minimum node, it will return `undefined`.
+     */
     get min() {
       return this._min;
     }
+    /**
+     * The function returns the comparator used for comparing elements.
+     * @returns The `_comparator` property of the object.
+     */
     get comparator() {
       return this._comparator;
     }
@@ -4815,11 +5312,11 @@ var dataStructureTyped = (() => {
       y.parent = x;
     }
     /**
-     * Time Complexity: O(n log n), where n is the number of elements in the heap.
+     * Time Complexity: O(n log n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n log n), where n is the number of elements in the heap.
+     * Time Complexity: O(n log n)
      * Space Complexity: O(n)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -4933,6 +5430,9 @@ var dataStructureTyped = (() => {
     get vertexMap() {
       return this._vertexMap;
     }
+    set vertexMap(v) {
+      this._vertexMap = v;
+    }
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -6013,7 +6513,7 @@ var dataStructureTyped = (() => {
       this.dest = dest;
     }
   };
-  var DirectedGraph = class extends AbstractGraph {
+  var DirectedGraph = class _DirectedGraph extends AbstractGraph {
     /**
      * The constructor function initializes an instance of a class.
      */
@@ -6025,9 +6525,15 @@ var dataStructureTyped = (() => {
     get outEdgeMap() {
       return this._outEdgeMap;
     }
+    set outEdgeMap(v) {
+      this._outEdgeMap = v;
+    }
     get inEdgeMap() {
       return this._inEdgeMap;
     }
+    set inEdgeMap(v) {
+      this._inEdgeMap = v;
+    }
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
@@ -6497,6 +7003,26 @@ var dataStructureTyped = (() => {
         return void 0;
       }
     }
+    /**
+     * The isEmpty function checks if the graph is empty.
+     *
+     * @return A boolean value
+     */
+    isEmpty() {
+      return this.vertexMap.size === 0 && this.inEdgeMap.size === 0 && this.outEdgeMap.size === 0;
+    }
+    /**
+     * The clone function creates a new DirectedGraph object with the same vertices and edges as the original.
+     *
+     * @return A new instance of the directedgraph class
+     */
+    clone() {
+      const cloned = new _DirectedGraph();
+      cloned.vertexMap = new Map(this.vertexMap);
+      cloned.inEdgeMap = new Map(this.inEdgeMap);
+      cloned.outEdgeMap = new Map(this.outEdgeMap);
+      return cloned;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -6567,7 +7093,7 @@ var dataStructureTyped = (() => {
       this.vertexMap = [v1, v2];
     }
   };
-  var UndirectedGraph = class extends AbstractGraph {
+  var UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     /**
      * The constructor initializes a new Map object to store edgeMap.
      */
@@ -6579,6 +7105,9 @@ var dataStructureTyped = (() => {
     get edgeMap() {
       return this._edgeMap;
     }
+    set edgeMap(v) {
+      this._edgeMap = v;
+    }
     /**
      * The function creates a new vertex with an optional value and returns it.
      * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is used to distinguish one
@@ -6853,6 +7382,28 @@ var dataStructureTyped = (() => {
         return void 0;
       }
     }
+    /**
+     * The isEmpty function checks if the graph is empty.
+     * @return True if the graph is empty and false otherwise
+     */
+    isEmpty() {
+      return this.vertexMap.size === 0 && this.edgeMap.size === 0;
+    }
+    /**
+     * The clone function creates a new UndirectedGraph object and copies the
+     * vertexMap and edgeMap from this graph to the new one. This is done by
+     * assigning each of these properties to their respective counterparts in the
+     * cloned graph. The clone function returns a reference to this newly created,
+     * cloned UndirectedGraph object.
+     *
+     * @return A new instance of the undirectedgraph class
+     */
+    clone() {
+      const cloned = new _UndirectedGraph();
+      cloned.vertexMap = new Map(this.vertexMap);
+      cloned.edgeMap = new Map(this.edgeMap);
+      return cloned;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -6920,7 +7471,7 @@ var dataStructureTyped = (() => {
       super(src, dest, weight, value);
     }
   };
-  var MapGraph = class extends DirectedGraph {
+  var MapGraph = class _MapGraph extends DirectedGraph {
     /**
      * The constructor function initializes the originCoord and bottomRight properties of a MapGraphCoordinate object.
      * @param {MapGraphCoordinate} originCoord - The `originCoord` parameter is a `MapGraphCoordinate` object that represents the
@@ -6972,6 +7523,20 @@ var dataStructureTyped = (() => {
     createEdge(src, dest, weight, value) {
       return new MapEdge(src, dest, weight, value);
     }
+    /**
+     * The override function is used to override the default behavior of a function.
+     * In this case, we are overriding the clone() function from Graph&lt;V, E&gt;.
+     * The clone() function returns a new graph that is an exact copy of the original graph.
+     *
+     * @return A mapgraph&lt;v, e, vo, eo&gt;
+     */
+    clone() {
+      const cloned = new _MapGraph(this.originCoord, this.bottomRight);
+      cloned.vertexMap = new Map(this.vertexMap);
+      cloned.inEdgeMap = new Map(this.inEdgeMap);
+      cloned.outEdgeMap = new Map(this.outEdgeMap);
+      return cloned;
+    }
   };
 
   // src/types/data-structures/binary-tree/rb-tree.ts
@@ -6993,10 +7558,10 @@ var dataStructureTyped = (() => {
     CP2["gt"] = "gt";
     return CP2;
   })(CP || {});
-  var IterationType = /* @__PURE__ */ ((IterationType3) => {
-    IterationType3["ITERATIVE"] = "ITERATIVE";
-    IterationType3["RECURSIVE"] = "RECURSIVE";
-    return IterationType3;
+  var IterationType = /* @__PURE__ */ ((IterationType2) => {
+    IterationType2["ITERATIVE"] = "ITERATIVE";
+    IterationType2["RECURSIVE"] = "RECURSIVE";
+    return IterationType2;
   })(IterationType || {});
   var FamilyPosition = /* @__PURE__ */ ((FamilyPosition2) => {
     FamilyPosition2["ROOT"] = "ROOT";
@@ -7011,6 +7576,13 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/binary-tree/binary-tree.ts
   var BinaryTreeNode = class {
+    /**
+     * The constructor function initializes an object with a key and an optional value.
+     * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
+     * constructor. It is used to set the value of the "key" property of the object being created.
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
+     * value associated with the key in the constructor.
+     */
     constructor(key, value) {
       __publicField(this, "key");
       __publicField(this, "value");
@@ -7020,18 +7592,39 @@ var dataStructureTyped = (() => {
       this.key = key;
       this.value = value;
     }
+    /**
+     * The function returns the value of the `_left` property, which can be of type `NODE`, `null`, or
+     * `undefined`.
+     * @returns The left node of the current node is being returned. It can be either a NODE object,
+     * null, or undefined.
+     */
     get left() {
       return this._left;
     }
+    /**
+     * 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
+     * `undefined`.
+     */
     set left(v) {
       if (v) {
         v.parent = this;
       }
       this._left = v;
     }
+    /**
+     * The function returns the right node of a binary tree or null if it doesn't exist.
+     * @returns The method is returning the value of the `_right` property, which can be a `NODE` object,
+     * `null`, or `undefined`.
+     */
     get right() {
       return this._right;
     }
+    /**
+     * 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
+     * `undefined`.
+     */
     set right(v) {
       if (v) {
         v.parent = this;
@@ -7083,12 +7676,25 @@ var dataStructureTyped = (() => {
       if (keysOrNodesOrEntries)
         this.addMany(keysOrNodesOrEntries);
     }
+    /**
+     * The function returns the value of the `_extractor` property.
+     * @returns The `_extractor` property is being returned.
+     */
     get extractor() {
       return this._extractor;
     }
+    /**
+     * The function returns the root node, which can be of type NODE, null, or undefined.
+     * @returns The method is returning the value of the `_root` property, which can be of type `NODE`,
+     * `null`, or `undefined`.
+     */
     get root() {
       return this._root;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size() {
       return this._size;
     }
@@ -7096,7 +7702,7 @@ var dataStructureTyped = (() => {
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {K} key - The key for the new node.
      * @param {V} value - The value for the new node.
-     * @returns {N} - The newly created BinaryTreeNode.
+     * @returns {NODE} - The newly created BinaryTreeNode.
      */
     createNode(key, value) {
       return new BinaryTreeNode(key, value);
@@ -7112,14 +7718,14 @@ var dataStructureTyped = (() => {
       return new _BinaryTree([], __spreadValues({ iterationType: this.iterationType }, options));
     }
     /**
-     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If no value
+     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If no value
      * is provided, it will be `undefined`.
-     * @returns a value of type N (node), or null, or undefined.
+     * @returns a value of type NODE (node), or null, or undefined.
      */
-    exemplarToNode(keyOrNodeOrEntry, value) {
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value) {
       if (keyOrNodeOrEntry === void 0)
         return;
       let node;
@@ -7153,7 +7759,7 @@ var dataStructureTyped = (() => {
      *
      * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
-     * @param {K | N | null | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `N`,
+     * @param {K | NODE | null | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `NODE`,
      * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be used when searching for a node by key. It has a default value of
@@ -7180,25 +7786,21 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,N>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the class N.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,NODE>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the class NODE.
      */
     isNode(keyOrNodeOrEntry) {
       return keyOrNodeOrEntry instanceof BinaryTreeNode;
     }
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,N> - A generic type representing a node in a binary tree. It has
-     * two type parameters V and N, representing the value and node type respectively.
+     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
+     * two type parameters V and NODE, representing the value and node type respectively.
      * @returns a boolean value.
      */
     isEntry(keyOrNodeOrEntry) {
       return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     */
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
@@ -7225,21 +7827,21 @@ var dataStructureTyped = (() => {
       return this.isRealNode(node) || node === null;
     }
     /**
-     * Time Complexity O(log n) - O(n)
+     * Time Complexity O(n)
      * Space Complexity O(1)
      */
     /**
-     * Time Complexity O(log n) - O(n)
+     * Time Complexity O(n)
      * Space Complexity O(1)
      *
      * The `add` function adds a new node to a binary tree, either by creating a new node or replacing an
      * existing node with the same key.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
      * @param {V} [value] - The value to be inserted into the binary tree.
-     * @returns The function `add` returns either a node (`N`), `null`, or `undefined`.
+     * @returns The function `add` returns either a node (`NODE`), `null`, or `undefined`.
      */
     add(keyOrNodeOrEntry, value) {
-      const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
+      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
       if (newNode === void 0)
         return false;
       if (!this.root) {
@@ -7279,19 +7881,19 @@ var dataStructureTyped = (() => {
       return false;
     }
     /**
-     * Time Complexity: O(k log n) - O(k * n)
+     * Time Complexity: O(k * n)
      * Space Complexity: O(1)
      * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
      */
     /**
-     * Time Complexity: O(k log n) - O(k * n)
+     * Time Complexity: O(k * n)
      * Space Complexity: O(1)
      *
      * The `addMany` function takes in a collection of keysOrNodesOrEntries and an optional collection of values, and
      * adds each node with its corresponding value to the data structure.
      * @param keysOrNodesOrEntries - An iterable collection of KeyOrNodeOrEntry objects.
      * @param [values] - An optional iterable of values that will be assigned to each node being added.
-     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     * @returns The function `addMany` returns an array of `NODE`, `null`, or `undefined` values.
      */
     addMany(keysOrNodesOrEntries, values) {
       const inserted = [];
@@ -7322,7 +7924,7 @@ var dataStructureTyped = (() => {
      *
      * The `refill` function clears the current data and adds new key-value pairs to the data structure.
      * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries. These can be of type
-     * KeyOrNodeOrEntry<K, V, N>.
+     * KeyOrNodeOrEntry<K, V, NODE>.
      * @param [values] - The `values` parameter is an optional iterable that contains the values to be
      * associated with the keys or nodes or entries in the `keysOrNodesOrEntries` parameter. If provided,
      * the values will be associated with the corresponding keys or nodes or entries in the
@@ -7333,20 +7935,25 @@ var dataStructureTyped = (() => {
       this.addMany(keysOrNodesOrEntries, values);
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function deletes a node from a binary tree and returns an array of the deleted nodes along
-     * with the nodes that need to be balanced.
-     * @param {ReturnType<C> | null | undefined} identifier - The identifier parameter is the value or
-     * object that you want to delete from the binary tree. It can be of any type that is compatible with
-     * the callback function's return type. It can also be null or undefined if you want to delete a
-     * specific node based on its value or object.
-     * @param {C} callback - The `callback` parameter is a function that is used to determine the
-     * identifier of the node to be deleted. It is optional and has a default value of
-     * `this._defaultOneParamCallback`. The `callback` function should return the identifier of the node.
-     * @returns an array of `BinaryTreeDeleteResult<N>`.
-     */
+       * Time Complexity: O(n)
+       * Space Complexity: O(1)
+       * /
+    
+       /**
+       * Time Complexity: O(n)
+       * Space Complexity: O(1)
+       *
+       * The function deletes a node from a binary tree and returns an array of the deleted nodes along
+       * with the nodes that need to be balanced.
+       * @param {ReturnType<C> | null | undefined} identifier - The identifier parameter is the value or
+       * object that you want to delete from the binary tree. It can be of any type that is compatible with
+       * the callback function's return type. It can also be null or undefined if you want to delete a
+       * specific node based on its value or object.
+       * @param {C} callback - The `callback` parameter is a function that is used to determine the
+       * identifier of the node to be deleted. It is optional and has a default value of
+       * `this._defaultOneParamCallback`. The `callback` function should return the identifier of the node.
+       * @returns an array of `BinaryTreeDeleteResult<NODE>`.
+       */
     delete(identifier, callback = this._defaultOneParamCallback) {
       const deletedResult = [];
       if (!this.root)
@@ -7356,36 +7963,35 @@ var dataStructureTyped = (() => {
       const curr = this.getNode(identifier, callback);
       if (!curr)
         return deletedResult;
-      const parent = (curr == null ? void 0 : curr.parent) ? curr.parent : null;
-      let needBalanced = void 0;
+      const parent = curr == null ? void 0 : curr.parent;
+      let needBalanced;
       let orgCurrent = curr;
-      if (!curr.left) {
-        if (!parent) {
-          this._setRoot(null);
-        } else {
-          const { familyPosition: fp } = curr;
-          if (fp === "LEFT" /* LEFT */ || fp === "ROOT_LEFT" /* ROOT_LEFT */) {
-            parent.left = curr.right;
-          } else if (fp === "RIGHT" /* RIGHT */ || fp === "ROOT_RIGHT" /* ROOT_RIGHT */) {
-            parent.right = curr.right;
+      if (!curr.left && !curr.right && !parent) {
+        this._setRoot(void 0);
+      } else if (curr.left) {
+        const leftSubTreeRightMost = this.getRightMost(curr.left);
+        if (leftSubTreeRightMost) {
+          const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+          orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
+          if (parentOfLeftSubTreeMax) {
+            if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
+              parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+            else
+              parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+            needBalanced = parentOfLeftSubTreeMax;
           }
-          needBalanced = parent;
         }
-      } else {
-        if (curr.left) {
-          const leftSubTreeRightMost = this.getRightMost(curr.left);
-          if (leftSubTreeRightMost) {
-            const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-            orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
-            if (parentOfLeftSubTreeMax) {
-              if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
-                parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
-              else
-                parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
-              needBalanced = parentOfLeftSubTreeMax;
-            }
-          }
+      } else if (parent) {
+        const { familyPosition: fp } = curr;
+        if (fp === "LEFT" /* LEFT */ || fp === "ROOT_LEFT" /* ROOT_LEFT */) {
+          parent.left = curr.right;
+        } else if (fp === "RIGHT" /* RIGHT */ || fp === "ROOT_RIGHT" /* ROOT_RIGHT */) {
+          parent.right = curr.right;
         }
+        needBalanced = parent;
+      } else {
+        this._setRoot(curr.right);
+        curr.right = void 0;
       }
       this._size = this.size - 1;
       deletedResult.push({ deleted: orgCurrent, needBalanced });
@@ -7393,186 +7999,36 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function calculates the depth of a given node in a binary tree.
-     * @param {K | N | null | undefined} dist - The `dist` parameter represents the node in
-     * the binary tree whose depth we want to find. It can be of type `K`, `N`, `null`, or
-     * `undefined`.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
-     * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
-     * `N` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
-     * @returns the depth of the `dist` relative to the `beginRoot`.
-     */
-    getDepth(dist, beginRoot = this.root) {
-      dist = this.ensureNode(dist);
-      beginRoot = this.ensureNode(beginRoot);
-      let depth = 0;
-      while (dist == null ? void 0 : dist.parent) {
-        if (dist === beginRoot) {
-          return depth;
-        }
-        depth++;
-        dist = dist.parent;
-      }
-      return depth;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(k + log n)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Space Complexity: O(k + log n).
      *
-     * The function `getHeight` calculates the maximum height of a binary tree using either recursive or
-     * iterative traversal.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node of the binary tree from which we want to calculate the height. It can be of type
-     * `K`, `N`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
-     * @param iterationType - The `iterationType` parameter is used to determine whether to calculate the
-     * height of the tree using a recursive approach or an iterative approach. It can have two possible
-     * values:
-     * @returns the height of the binary tree.
+     * The function `getNodes` retrieves nodes from a binary tree based on a given identifier and
+     * callback function.
+     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
+     * that you want to search for in the binary tree. It can be of any type that is returned by the
+     * callback function `C`. It can also be `null` or `undefined` if you don't want to search for a
+     * specific value.
+     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
+     * input and returns a value of type `C`. It is used to determine if a node matches the given
+     * identifier. If no callback is provided, the `_defaultOneParamCallback` function is used as the
+     * default
+     * @param [onlyOne=false] - A boolean value indicating whether to only return the first node that
+     * matches the identifier. If set to true, the function will stop iterating once it finds a matching
+     * node and return that node. If set to false (default), the function will continue iterating and
+     * return all nodes that match the identifier.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node for the traversal. It can be either a key, a node object, or `null`/`undefined`. If
+     * it is `null` or `undefined`, an empty array will be returned.
+     * @param iterationType - The `iterationType` parameter determines the type of iteration used to
+     * traverse the binary tree. It can have two possible values:
+     * @returns an array of nodes of type `NODE`.
      */
-    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot)
-        return -1;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
-        const _getMaxHeight = (cur) => {
-          if (!cur)
-            return -1;
-          const leftHeight = _getMaxHeight(cur.left);
-          const rightHeight = _getMaxHeight(cur.right);
-          return Math.max(leftHeight, rightHeight) + 1;
-        };
-        return _getMaxHeight(beginRoot);
-      } else {
-        const stack = [{ node: beginRoot, depth: 0 }];
-        let maxHeight = 0;
-        while (stack.length > 0) {
-          const { node, depth } = stack.pop();
-          if (node.left)
-            stack.push({ node: node.left, depth: depth + 1 });
-          if (node.right)
-            stack.push({ node: node.right, depth: depth + 1 });
-          maxHeight = Math.max(maxHeight, depth);
-        }
-        return maxHeight;
-      }
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     *
-     * The `getMinHeight` function calculates the minimum height of a binary tree using either a
-     * recursive or iterative approach.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node of the binary tree from which we want to calculate the minimum height. It can be of
-     * type `K`, `N`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
-     * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
-     * to calculate the minimum height of a binary tree. It can have two possible values:
-     * @returns The function `getMinHeight` returns the minimum height of a binary tree.
-     */
-    getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
-      var _a, _b, _c;
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot)
-        return -1;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
-        const _getMinHeight = (cur) => {
-          if (!cur)
-            return 0;
-          if (!cur.left && !cur.right)
-            return 0;
-          const leftMinHeight = _getMinHeight(cur.left);
-          const rightMinHeight = _getMinHeight(cur.right);
-          return Math.min(leftMinHeight, rightMinHeight) + 1;
-        };
-        return _getMinHeight(beginRoot);
-      } else {
-        const stack = [];
-        let node = beginRoot, last = null;
-        const depths = /* @__PURE__ */ new Map();
-        while (stack.length > 0 || node) {
-          if (node) {
-            stack.push(node);
-            node = node.left;
-          } else {
-            node = stack[stack.length - 1];
-            if (!node.right || last === node.right) {
-              node = stack.pop();
-              if (node) {
-                const leftMinHeight = node.left ? (_a = depths.get(node.left)) != null ? _a : -1 : -1;
-                const rightMinHeight = node.right ? (_b = depths.get(node.right)) != null ? _b : -1 : -1;
-                depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
-                last = node;
-                node = null;
-              }
-            } else
-              node = node.right;
-          }
-        }
-        return (_c = depths.get(beginRoot)) != null ? _c : -1;
-      }
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     *
-     * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
-     * height of the tree.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for calculating the height and minimum height of a binary tree. It can be either a `K` (a key
-     * value of a binary tree node), `N` (a node of a binary tree), `null`, or `undefined`. If
-     * @returns a boolean value.
-     */
-    isPerfectlyBalanced(beginRoot = this.root) {
-      return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n).
-     *
-     * The function `getNodes` retrieves nodes from a binary tree based on a given identifier and
-     * callback function.
-     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
-     * that you want to search for in the binary tree. It can be of any type that is returned by the
-     * callback function `C`. It can also be `null` or `undefined` if you don't want to search for a
-     * specific value.
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` as
-     * input and returns a value of type `C`. It is used to determine if a node matches the given
-     * identifier. If no callback is provided, the `_defaultOneParamCallback` function is used as the
-     * default
-     * @param [onlyOne=false] - A boolean value indicating whether to only return the first node that
-     * matches the identifier. If set to true, the function will stop iterating once it finds a matching
-     * node and return that node. If set to false (default), the function will continue iterating and
-     * return all nodes that match the identifier.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node for the traversal. It can be either a key, a node object, or `null`/`undefined`. If
-     * it is `null` or `undefined`, an empty array will be returned.
-     * @param iterationType - The `iterationType` parameter determines the type of iteration used to
-     * traverse the binary tree. It can have two possible values:
-     * @returns an array of nodes of type `N`.
-     */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
-      if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
-        callback = (node) => node;
+    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+      if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+        callback = (node) => node;
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
@@ -7610,29 +8066,7 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
-     *
-     * The function checks if a Binary Tree Node with a specific identifier exists in the tree.
-     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
-     * that you want to search for in the binary tree. It can be of any type that is returned by the
-     * callback function `C`. It can also be `null` or `undefined` if you don't want to specify a
-     * specific identifier.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the binary tree. It is used to filter the nodes based on certain conditions. The `callback`
-     * function should return a boolean value indicating whether the node should be included in the
-     * result or not.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
-     * node in the binary tree), a node object (`N`), or `null`/`undefined` to start the search from
-     * @param iterationType - The `iterationType` parameter is a variable that determines the type of
-     * iteration to be performed on the binary tree. It is used to specify whether the iteration should
-     * be performed in a pre-order, in-order, or post-order manner.
-     * @returns a boolean value.
      */
-    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-      if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
-        callback = (node) => node;
-      return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -7645,14 +8079,14 @@ var dataStructureTyped = (() => {
      * identifier.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
-     * function should take a single parameter of type `N` (the type of the nodes in the binary tree) and
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * function should take a single parameter of type `NODE` (the type of the nodes in the binary tree) and
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
      * for searching the binary tree. It can be either a key value, a node object, or `null`/`undefined`.
      * If `null` or `undefined` is passed, the search will start from the root of the binary tree.
      * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
      * be performed when searching for nodes in the binary tree. It determines the order in which the
      * nodes are visited during the search.
-     * @returns a value of type `N | null | undefined`.
+     * @returns a value of type `NODE | null | undefined`.
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
       var _a;
@@ -7675,7 +8109,7 @@ var dataStructureTyped = (() => {
      * @param iterationType - The `iterationType` parameter is used to determine whether the search for
      * the node with the given key should be performed iteratively or recursively. It has two possible
      * values:
-     * @returns The function `getNodeByKey` returns a node (`N`) if a node with the specified key is
+     * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
@@ -7706,6 +8140,10 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -7719,9 +8157,9 @@ var dataStructureTyped = (() => {
      * the binary tree. It is used to determine whether a node matches the given identifier. The callback
      * function should return a value that can be compared to the identifier to determine if it is a
      * match.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
      * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
-     * node), a node object of type `N`, or `null`/`undefined` to start the search from the root of
+     * node), a node object of type `NODE`, or `null`/`undefined` to start the search from the root of
      * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
      * be performed when searching for a node in the binary tree. It is an optional parameter with a
      * default value specified by `this.iterationType`.
@@ -7734,6 +8172,36 @@ var dataStructureTyped = (() => {
         callback = (node) => node;
       return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) == null ? void 0 : _a.value) != null ? _b : void 0;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n).
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n).
+     *
+     * The function checks if a Binary Tree Node with a specific identifier exists in the tree.
+     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
+     * that you want to search for in the binary tree. It can be of any type that is returned by the
+     * callback function `C`. It can also be `null` or `undefined` if you don't want to specify a
+     * specific identifier.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+     * the binary tree. It is used to filter the nodes based on certain conditions. The `callback`
+     * function should return a boolean value indicating whether the node should be included in the
+     * result or not.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
+     * node in the binary tree), a node object (`NODE`), or `null`/`undefined` to start the search from
+     * @param iterationType - The `iterationType` parameter is a variable that determines the type of
+     * iteration to be performed on the binary tree. It is used to specify whether the iteration should
+     * be performed in a pre-order, in-order, or post-order manner.
+     * @returns a boolean value.
+     */
+    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+      if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+        callback = (node) => node;
+      return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -7763,19 +8231,231 @@ var dataStructureTyped = (() => {
       return this.size === 0;
     }
     /**
-     * Time Complexity: O(log n)
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n)
      * Space Complexity: O(log n)
      *
-     * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
-     * structure, with the option to reverse the order of the nodes.
-     * @param {K | N | null | undefined} beginNode - The `beginRoot` parameter represents the
-     * starting node from which you want to find the path to the root. It can be of type `K`, `N`,
-     * `null`, or `undefined`.
-     * @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`, the path will be returned as is
-     * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
+     * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
+     * height of the tree.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for calculating the height and minimum height of a binary tree. It can be either a `K` (a key
+     * value of a binary tree node), `NODE` (a node of a binary tree), `null`, or `undefined`. If
+     * @returns a boolean value.
+     */
+    isPerfectlyBalanced(beginRoot = this.root) {
+      return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `isSubtreeBST` checks if a given binary tree is a valid binary search tree.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the root
+     * node of the binary search tree (BST) that you want to check if it is a subtree of another BST.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when checking if a subtree is a binary search tree (BST). It can have two
+     * possible values:
+     * @returns a boolean value.
+     */
+    isBST(beginRoot = this.root, iterationType = this.iterationType) {
+      beginRoot = this.ensureNode(beginRoot);
+      if (!beginRoot)
+        return true;
+      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+        const dfs = (cur, min, max) => {
+          if (!cur)
+            return true;
+          const numKey = this.extractor(cur.key);
+          if (numKey <= min || numKey >= max)
+            return false;
+          return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
+        };
+        const isStandardBST = dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+        const isInverseBST = dfs(beginRoot, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
+        return isStandardBST || isInverseBST;
+      } else {
+        const checkBST = (checkMax = false) => {
+          const stack = [];
+          let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
+          let curr = beginRoot;
+          while (curr || stack.length > 0) {
+            while (curr) {
+              stack.push(curr);
+              curr = curr.left;
+            }
+            curr = stack.pop();
+            const numKey = this.extractor(curr.key);
+            if (!curr || !checkMax && prev >= numKey || checkMax && prev <= numKey)
+              return false;
+            prev = numKey;
+            curr = curr.right;
+          }
+          return true;
+        };
+        const isStandardBST = checkBST(false), isInverseBST = checkBST(true);
+        return isStandardBST || isInverseBST;
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function calculates the depth of a given node in a binary tree.
+     * @param {K | NODE | null | undefined} dist - The `dist` parameter represents the node in
+     * the binary tree whose depth we want to find. It can be of type `K`, `NODE`, `null`, or
+     * `undefined`.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
+     * `NODE` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
+     * @returns the depth of the `dist` relative to the `beginRoot`.
+     */
+    getDepth(dist, beginRoot = this.root) {
+      dist = this.ensureNode(dist);
+      beginRoot = this.ensureNode(beginRoot);
+      let depth = 0;
+      while (dist == null ? void 0 : dist.parent) {
+        if (dist === beginRoot) {
+          return depth;
+        }
+        depth++;
+        dist = dist.parent;
+      }
+      return depth;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     *
+     * The function `getHeight` calculates the maximum height of a binary tree using either recursive or
+     * iterative traversal.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node of the binary tree from which we want to calculate the height. It can be of type
+     * `K`, `NODE`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
+     * @param iterationType - The `iterationType` parameter is used to determine whether to calculate the
+     * height of the tree using a recursive approach or an iterative approach. It can have two possible
+     * values:
+     * @returns the height of the binary tree.
+     */
+    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
+      beginRoot = this.ensureNode(beginRoot);
+      if (!beginRoot)
+        return -1;
+      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+        const _getMaxHeight = (cur) => {
+          if (!cur)
+            return -1;
+          const leftHeight = _getMaxHeight(cur.left);
+          const rightHeight = _getMaxHeight(cur.right);
+          return Math.max(leftHeight, rightHeight) + 1;
+        };
+        return _getMaxHeight(beginRoot);
+      } else {
+        const stack = [{ node: beginRoot, depth: 0 }];
+        let maxHeight = 0;
+        while (stack.length > 0) {
+          const { node, depth } = stack.pop();
+          if (node.left)
+            stack.push({ node: node.left, depth: depth + 1 });
+          if (node.right)
+            stack.push({ node: node.right, depth: depth + 1 });
+          maxHeight = Math.max(maxHeight, depth);
+        }
+        return maxHeight;
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     *
+     * The `getMinHeight` function calculates the minimum height of a binary tree using either a
+     * recursive or iterative approach.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node of the binary tree from which we want to calculate the minimum height. It can be of
+     * type `K`, `NODE`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
+     * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
+     * to calculate the minimum height of a binary tree. It can have two possible values:
+     * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
+    getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
+      var _a, _b, _c;
+      beginRoot = this.ensureNode(beginRoot);
+      if (!beginRoot)
+        return -1;
+      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+        const _getMinHeight = (cur) => {
+          if (!cur)
+            return 0;
+          if (!cur.left && !cur.right)
+            return 0;
+          const leftMinHeight = _getMinHeight(cur.left);
+          const rightMinHeight = _getMinHeight(cur.right);
+          return Math.min(leftMinHeight, rightMinHeight) + 1;
+        };
+        return _getMinHeight(beginRoot);
+      } else {
+        const stack = [];
+        let node = beginRoot, last = null;
+        const depths = /* @__PURE__ */ new Map();
+        while (stack.length > 0 || node) {
+          if (node) {
+            stack.push(node);
+            node = node.left;
+          } else {
+            node = stack[stack.length - 1];
+            if (!node.right || last === node.right) {
+              node = stack.pop();
+              if (node) {
+                const leftMinHeight = node.left ? (_a = depths.get(node.left)) != null ? _a : -1 : -1;
+                const rightMinHeight = node.right ? (_b = depths.get(node.right)) != null ? _b : -1 : -1;
+                depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
+                last = node;
+                node = null;
+              }
+            } else
+              node = node.right;
+          }
+        }
+        return (_c = depths.get(beginRoot)) != null ? _c : -1;
+      }
+    }
+    /**
+       * Time Complexity: O(log n)
+       * Space Complexity: O(log n)
+       * /
+    
+       /**
+       * Time Complexity: O(log n)
+       * Space Complexity: O(log n)
+       *
+       * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
+       * structure, with the option to reverse the order of the nodes.
+       * @param {K | NODE | null | undefined} beginNode - The `beginRoot` parameter represents the
+       * starting node from which you want to find the path to the root. It can be of type `K`, `NODE`,
+       * `null`, or `undefined`.
+       * @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`, the path will be returned as is
+       * @returns The function `getPathToRoot` returns an array of nodes (`NODE[]`).
+       */
     getPathToRoot(beginNode, isReverse = true) {
       const result = [];
       beginNode = this.ensureNode(beginNode);
@@ -7798,12 +8478,12 @@ var dataStructureTyped = (() => {
      *
      * The function `getLeftMost` returns the leftmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for finding the leftmost node in a binary tree. It can be either a `K` (a key value), `N` (a
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for finding the leftmost node in a binary tree. It can be either a `K` (a key value), `NODE` (a
      * node), `null`, or `undefined`. If not provided, it defaults to `this.root`,
      * @param iterationType - The `iterationType` parameter is used to determine the type of iteration to
      * be performed when finding the leftmost node in a binary tree. It can have two possible values:
-     * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
+     * @returns The function `getLeftMost` returns the leftmost node (`NODE`) in the binary tree. If there
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
@@ -7836,13 +8516,13 @@ var dataStructureTyped = (() => {
      *
      * The function `getRightMost` returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node from which we want to find the rightmost node. It can be of type `K`, `N`,
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node from which we want to find the rightmost node. It can be of type `K`, `NODE`,
      * `null`, or `undefined`. If not provided, it defaults to `this.root`, which is a property of the
      * current object.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when finding the rightmost node. It can have one of two values:
-     * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
+     * @returns The function `getRightMost` returns the rightmost node (`NODE`) in a binary tree. If there
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
     getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
@@ -7870,79 +8550,82 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `isSubtreeBST` checks if a given binary tree is a valid binary search tree.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the root
-     * node of the binary search tree (BST) that you want to check if it is a subtree of another BST.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when checking if a subtree is a binary search tree (BST). It can have two
-     * possible values:
-     * @returns a boolean value.
+     * The function returns the predecessor of a given node in a tree.
+     * @param {NODE} node - The parameter `node` is of type `RedBlackTreeNode`, which represents a node in a
+     * tree.
+     * @returns the predecessor of the given 'node'.
      */
-    isBST(beginRoot = this.root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot)
-        return true;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
-        const dfs = (cur, min, max) => {
-          if (!cur)
-            return true;
-          const numKey = this.extractor(cur.key);
-          if (numKey <= min || numKey >= max)
-            return false;
-          return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
-        };
-        const isStandardBST = dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-        const isInverseBST = dfs(beginRoot, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
-        return isStandardBST || isInverseBST;
-      } else {
-        const checkBST = (checkMax = false) => {
-          const stack = [];
-          let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
-          let curr = beginRoot;
-          while (curr || stack.length > 0) {
-            while (curr) {
-              stack.push(curr);
-              curr = curr.left;
-            }
-            curr = stack.pop();
-            const numKey = this.extractor(curr.key);
-            if (!curr || !checkMax && prev >= numKey || checkMax && prev <= numKey)
-              return false;
-            prev = numKey;
-            curr = curr.right;
+    getPredecessor(node) {
+      if (this.isRealNode(node.left)) {
+        let predecessor = node.left;
+        while (!this.isRealNode(predecessor) || this.isRealNode(predecessor.right) && predecessor.right !== node) {
+          if (this.isRealNode(predecessor)) {
+            predecessor = predecessor.right;
           }
-          return true;
-        };
-        const isStandardBST = checkBST(false), isInverseBST = checkBST(true);
-        return isStandardBST || isInverseBST;
+        }
+        return predecessor;
+      } else {
+        return node;
+      }
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function `getSuccessor` returns the next node in a binary tree given a current node.
+     * @param {K | NODE | null} [x] - The parameter `x` can be of type `K`, `NODE`, or `null`.
+     * @returns the successor of the given node or key. The successor is the node that comes immediately
+     * after the given node in the inorder traversal of the binary tree.
+     */
+    getSuccessor(x) {
+      x = this.ensureNode(x);
+      if (!this.isRealNode(x))
+        return void 0;
+      if (this.isRealNode(x.right)) {
+        return this.getLeftMost(x.right);
+      }
+      let y = x.parent;
+      while (this.isRealNode(y) && x === y.right) {
+        x = y;
+        y = y.parent;
       }
+      return y;
     }
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     *
-     * The `dfs` function performs a depth-first search traversal on a binary tree or graph, based on the
-     * specified pattern and iteration type, and returns an array of values obtained from applying a
-     * callback function to each visited node.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree during the depth-first search. It takes a single parameter, which can be of type `N`,
-     * `null`, or `undefined`, and returns a value of any type. The default value for this parameter is
-     * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
-     * nodes are traversed during the depth-first search. It can have one of the following values:
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
-     * for the depth-first search traversal. It can be specified as a key, a node object, or
-     * `null`/`undefined`. If not provided, the `beginRoot` will default to the root node of the tree.
-     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
-     * iteration to use when traversing the tree. It can have one of the following values:
-     * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
-     * whether null or undefined nodes should be included in the traversal. If `includeNull` is set to
-     * `true`, null or undefined nodes will be included in the traversal. If `includeNull` is set to
-     * `false`, null or undefined
-     * @returns an array of values that are the return values of the callback function.
-     */
+       * Time complexity: O(n)
+       * Space complexity: O(n)
+       * /
+    
+       /**
+       * Time complexity: O(n)
+       * Space complexity: O(n)
+       *
+       * The `dfs` function performs a depth-first search traversal on a binary tree or graph, based on the
+       * specified pattern and iteration type, and returns an array of values obtained from applying a
+       * callback function to each visited node.
+       * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+       * the tree during the depth-first search. It takes a single parameter, which can be of type `NODE`,
+       * `null`, or `undefined`, and returns a value of any type. The default value for this parameter is
+       * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
+       * nodes are traversed during the depth-first search. It can have one of the following values:
+       * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+       * for the depth-first search traversal. It can be specified as a key, a node object, or
+       * `null`/`undefined`. If not provided, the `beginRoot` will default to the root node of the tree.
+       * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
+       * iteration to use when traversing the tree. It can have one of the following values:
+       * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
+       * whether null or undefined nodes should be included in the traversal. If `includeNull` is set to
+       * `true`, null or undefined nodes will be included in the traversal. If `includeNull` is set to
+       * `false`, null or undefined
+       * @returns an array of values that are the return values of the callback function.
+       */
     dfs(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root, iterationType = "ITERATIVE" /* ITERATIVE */, includeNull = false) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
@@ -8042,6 +8725,10 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -8051,7 +8738,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 parameter, which is the current node being
      * visited, and returns a value of any type.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node for the breadth-first search traversal. It can be specified as a key, a node object,
      * or `null`/`undefined` to indicate the root of the tree. If not provided, the `root` property of
      * the class is used as
@@ -8112,6 +8799,10 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -8120,10 +8811,10 @@ var dataStructureTyped = (() => {
      * a binary tree and contains the values returned by a callback function applied to the nodes at that
      * level.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It takes a single parameter, which can be of type `N`, `null`, or `undefined`, and
+     * the tree. It takes a single parameter, which can be of type `NODE`, `null`, or `undefined`, and
      * returns a value of any type.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node for traversing the tree. It can be either a node object (`N`), a key value
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node for traversing the tree. It can be either a node object (`NODE`), a key value
      * (`K`), `null`, or `undefined`. If not provided, it defaults to the root node of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
      * performed on the tree. It can have two possible values:
@@ -8179,52 +8870,6 @@ var dataStructureTyped = (() => {
       }
       return levelsNodes;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The function returns the predecessor of a given node in a tree.
-     * @param {N} node - The parameter `node` is of type `RedBlackTreeNode`, which represents a node in a
-     * tree.
-     * @returns the predecessor of the given 'node'.
-     */
-    getPredecessor(node) {
-      if (this.isRealNode(node.left)) {
-        let predecessor = node.left;
-        while (!this.isRealNode(predecessor) || this.isRealNode(predecessor.right) && predecessor.right !== node) {
-          if (this.isRealNode(predecessor)) {
-            predecessor = predecessor.right;
-          }
-        }
-        return predecessor;
-      } else {
-        return node;
-      }
-    }
-    /**
-     * The function `getSuccessor` returns the next node in a binary tree given a current node.
-     * @param {K | N | null} [x] - The parameter `x` can be of type `K`, `N`, or `null`.
-     * @returns the successor of the given node or key. The successor is the node that comes immediately
-     * after the given node in the inorder traversal of the binary tree.
-     */
-    getSuccessor(x) {
-      x = this.ensureNode(x);
-      if (!this.isRealNode(x))
-        return void 0;
-      if (this.isRealNode(x.right)) {
-        return this.getLeftMost(x.right);
-      }
-      let y = x.parent;
-      while (this.isRealNode(y) && x === y.right) {
-        x = y;
-        y = y.parent;
-      }
-      return y;
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -8236,12 +8881,12 @@ var dataStructureTyped = (() => {
      * The `morris` function performs a depth-first traversal on a binary tree using the Morris traversal
      * algorithm.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It takes a single parameter of type `N` (the type of the nodes in the tree) and returns
+     * the tree. It takes a single parameter of type `NODE` (the type of the nodes in the tree) and returns
      * a value of any type.
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
      * determines the order in which the nodes of a binary tree are traversed. It can have one of the
      * following values:
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
      * for the traversal. It can be specified as a key, a node object, or `null`/`undefined` to indicate
      * the root of the tree. If no value is provided, the default value is the root of the tree.
      * @returns The function `morris` returns an array of values that are the result of invoking the
@@ -8343,7 +8988,17 @@ var dataStructureTyped = (() => {
      */
     clone() {
       const cloned = this.createTree();
-      this.bfs((node) => cloned.add([node.key, node.value]));
+      this.bfs(
+        (node) => {
+          if (node === null)
+            cloned.add(null);
+          else
+            cloned.add([node.key, node.value]);
+        },
+        this.root,
+        this.iterationType,
+        true
+      );
       return cloned;
     }
     /**
@@ -8420,7 +9075,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n)
      *
      * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {K | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | N | null |
+     * @param {K | NODE | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | NODE | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * following types:
      * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
@@ -8434,7 +9089,7 @@ var dataStructureTyped = (() => {
         console.log(`U for undefined
       `);
       if (opts.isShowNull)
-        console.log(`N for null
+        console.log(`NODE for null
       `);
       if (opts.isShowRedBlackNIL)
         console.log(`S for Sentinel Node
@@ -8447,6 +9102,15 @@ var dataStructureTyped = (() => {
       };
       display(beginRoot);
     }
+    /**
+     * The function `_getIterator` is a protected generator function that returns an iterator for the
+     * key-value pairs in a binary search tree.
+     * @param node - The `node` parameter represents the current node in the binary search tree. It is an
+     * optional parameter with a default value of `this.root`, which means if no node is provided, the
+     * root node of the tree will be used as the starting point for iteration.
+     * @returns The function `_getIterator` returns an `IterableIterator` of key-value pairs `[K, V |
+     * undefined]`.
+     */
     *_getIterator(node = this.root) {
       if (!node)
         return;
@@ -8474,6 +9138,20 @@ 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.
+     * It can be of type `NODE`, `null`, or `undefined`.
+     * @param {BinaryTreePrintOptions} options - The `options` parameter is an object that contains the
+     * following properties:
+     * @returns The function `_displayAux` returns a `NodeDisplayLayout` which is an array containing the
+     * following elements:
+     * 1. `mergedLines`: An array of strings representing the lines of the node display.
+     * 2. `totalWidth`: The total width of the node display.
+     * 3. `totalHeight`: The total height of the node display.
+     * 4. `middleIndex`: The index of the middle character
+     */
     _displayAux(node, options) {
       const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
       const emptyDisplayLayout = [["\u2500"], 1, 0, 0];
@@ -8492,7 +9170,7 @@ var dataStructureTyped = (() => {
           this._displayAux(node.right, options)
         );
       } else {
-        const line = node === void 0 ? "U" : "N", width = line.length;
+        const line = node === void 0 ? "U" : "NODE", width = line.length;
         return _buildNodeDisplay(line, width, [[""], 1, 0, 0], [[""], 1, 0, 0]);
       }
       function _buildNodeDisplay(line, width, left, right) {
@@ -8516,9 +9194,9 @@ var dataStructureTyped = (() => {
     }
     /**
      * Swap the data of two nodes in the binary tree.
-     * @param {N} srcNode - The source node to swap.
-     * @param {N} destNode - The destination node to swap.
-     * @returns {N} - The destination node after the swap.
+     * @param {NODE} srcNode - The source node to swap.
+     * @param {NODE} destNode - The destination node to swap.
+     * @returns {NODE} - The destination node after the swap.
      */
     _swapProperties(srcNode, destNode) {
       srcNode = this.ensureNode(srcNode);
@@ -8538,9 +9216,9 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function replaces an old node with a new node in a binary tree.
-     * @param {N} oldNode - The oldNode parameter represents the node that needs to be replaced in the
+     * @param {NODE} oldNode - The oldNode parameter represents the node that needs to be replaced in the
      * tree.
-     * @param {N} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
+     * @param {NODE} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
      * tree.
      * @returns The method is returning the newNode.
      */
@@ -8563,8 +9241,8 @@ var dataStructureTyped = (() => {
     /**
      * The function sets the root property of an object to a given value, and if the value is not null,
      * it also sets the parent property of the value to undefined.
-     * @param {N | null | undefined} v - The parameter `v` is of type `N | null | undefined`, which means it can either be of
-     * type `N` or `null`.
+     * @param {NODE | null | undefined} v - The parameter `v` is of type `NODE | null | undefined`, which means it can either be of
+     * type `NODE` or `null`.
      */
     _setRoot(v) {
       if (v) {
@@ -8585,32 +9263,18 @@ var dataStructureTyped = (() => {
       this._left = void 0;
       this._right = void 0;
     }
-    /**
-     * Get the left child node.
-     */
     get left() {
       return this._left;
     }
-    /**
-     * Set the left child node.
-     * @param {N | undefined} v - The left child node.
-     */
     set left(v) {
       if (v) {
         v.parent = this;
       }
       this._left = v;
     }
-    /**
-     * Get the right child node.
-     */
     get right() {
       return this._right;
     }
-    /**
-     * Set the right child node.
-     * @param {N | undefined} v - The right child node.
-     */
     set right(v) {
       if (v) {
         v.parent = this;
@@ -8671,14 +9335,14 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function `exemplarToNode` takes an keyOrNodeOrEntry and returns a node if the keyOrNodeOrEntry is valid,
+     * The function `keyValueOrEntryToNode` takes an keyOrNodeOrEntry and returns a node if the keyOrNodeOrEntry is valid,
      * otherwise it returns undefined.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, where:
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node.
-     * @returns a node of type N or undefined.
+     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node.
+     * @returns a node of type NODE or undefined.
      */
-    exemplarToNode(keyOrNodeOrEntry, value) {
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value) {
       let node;
       if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
         return;
@@ -8701,7 +9365,6 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
-     * Average case for a balanced tree. Space for the recursive call stack in the worst case.
      */
     /**
      * Time Complexity: O(log n)
@@ -8709,11 +9372,11 @@ var dataStructureTyped = (() => {
      *
      * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
      * otherwise it returns the key itself.
-     * @param {K | N | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `N`, or
+     * @param {K | NODE | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `NODE`, or
      * `undefined`.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
-     * @returns either a node object (N) or undefined.
+     * @returns either a node object (NODE) or undefined.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE" /* ITERATIVE */) {
       let res;
@@ -8730,7 +9393,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the BSTNode class.
      */
     isNode(keyOrNodeOrEntry) {
@@ -8739,7 +9402,6 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     *  - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      */
     /**
      * Time Complexity: O(log n)
@@ -8754,7 +9416,7 @@ var dataStructureTyped = (() => {
      * node was not added.
      */
     add(keyOrNodeOrEntry, value) {
-      const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
+      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
       if (newNode === void 0)
         return false;
       if (this.root === void 0) {
@@ -8770,7 +9432,6 @@ var dataStructureTyped = (() => {
         } else if (this._compare(current.key, newNode.key) === "gt" /* gt */) {
           if (current.left === void 0) {
             current.left = newNode;
-            newNode.parent = current;
             this._size++;
             return true;
           }
@@ -8778,7 +9439,6 @@ var dataStructureTyped = (() => {
         } else {
           if (current.right === void 0) {
             current.right = newNode;
-            newNode.parent = current;
             this._size++;
             return true;
           }
@@ -8789,12 +9449,11 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(k log n)
-     * Space Complexity: O(k)
-     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
+     * Space Complexity: O(k + log n)
      */
     /**
      * Time Complexity: O(k log n)
-     * Space Complexity: O(k)
+     * Space Complexity: O(k + log n)
      *
      * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
      * balancing the tree after each addition.
@@ -8810,7 +9469,7 @@ var dataStructureTyped = (() => {
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when adding multiple keys or nodes. It has a default value of
      * `this.iterationType`, which suggests that it is a property of the current object.
-     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
+     * @returns The function `addMany` returns an array of nodes (`NODE`) or `undefined` values.
      */
     addMany(keysOrNodesOrEntries, values, isBalanceAdd = true, iterationType = this.iterationType) {
       const inserted = [];
@@ -8900,7 +9559,7 @@ var dataStructureTyped = (() => {
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when searching for a node in the binary tree. It can have two possible
      * values:
-     * @returns The function `getNodeByKey` returns a node (`N`) if a node with the specified key is
+     * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
@@ -8935,32 +9594,31 @@ var dataStructureTyped = (() => {
     }
     /**
        * Time Complexity: O(log n)
-       * Space Complexity: O(log n)
-       * Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key. Space for the recursive call stack in the worst case.
+       * Space Complexity: O(k + log n)
        * /
     
        /**
        * Time Complexity: O(log n)
-       * Space Complexity: O(log n)
+       * Space Complexity: O(k + log n)
        *
        * The function `getNodes` returns an array of nodes that match a given identifier, using either a
        * recursive or iterative approach.
        * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
        * want to search for in the nodes of the binary tree. It can be of any type that is returned by the
        * callback function `C`.
-       * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` as its
+       * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as its
        * argument and returns a value of type `ReturnType<C>`. The `C` type parameter represents a callback
-       * function type that extends the `BTNCallback<N>` type. The `BTNCallback<N>` type is
+       * function type that extends the `BTNCallback<NODE>` type. The `BTNCallback<NODE>` type is
        * @param [onlyOne=false] - A boolean flag indicating whether to stop searching after finding the
        * first node that matches the identifier. If set to true, the function will return an array
        * containing only the first matching node. If set to false (default), the function will continue
        * searching for all nodes that match the identifier and return an array containing
-       * @param {K | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
+       * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter represents the starting node
        * for the traversal. It can be either a key value or a node object. If it is undefined, the
        * traversal will start from the root of the tree.
        * @param iterationType - The `iterationType` parameter determines the type of iteration to be
        * performed on the binary tree. It can have two possible values:
-       * @returns The method returns an array of nodes (`N[]`).
+       * @returns The method returns an array of nodes (`NODE[]`).
        */
     getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNode(beginRoot);
@@ -9013,25 +9671,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    // /**
-    //  * The function overrides the subTreeTraverse method and returns the result of calling the super
-    //  * method with the provided arguments.
-    //  * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-    //  * the subtree traversal. It should accept a single parameter of type `N`, which represents a node in
-    //  * the tree. The return type of the callback function can be any type.
-    //  * @param beginRoot - The `beginRoot` parameter is the starting point for traversing the subtree. It
-    //  * can be either a key, a node, or an entry.
-    //  * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-    //  * be performed during the traversal of the subtree. It can have one of the following values:
-    //  * @returns The method is returning an array of the return type of the callback function.
-    //  */
-    // override subTreeTraverse<C extends BTNCallback<N>>(
-    //   callback: C = this._defaultOneParamCallback as C,
-    //   beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
-    //   iterationType = this.iterationType
-    // ): ReturnType<C>[] {
-    //   return super.subTreeTraverse(callback, beginRoot, iterationType, false);
-    // }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -9093,7 +9732,7 @@ var dataStructureTyped = (() => {
      * The function overrides the listLevels method and returns an array of arrays containing the return
      * type of the callback function for each level of the tree.
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
-     * `BTNCallback<N>`. It represents a callback function that will be called for each node in the tree
+     * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the tree
      * during the level listing process.
      * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for listing the
      * levels of a binary tree. It can be either a key, a node, or an entry in the binary tree. If not
@@ -9108,18 +9747,17 @@ var dataStructureTyped = (() => {
       return super.listLevels(callback, beginRoot, iterationType, false);
     }
     /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
      * leftmost node if the comparison result is greater than.
-     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
+     * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
+     * type `K`, `NODE`, or `undefined`. It represents the starting point for finding the last key in
      * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
      * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
      * the key of the leftmost node if the comparison result is greater than, and the key of the
@@ -9143,7 +9781,6 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
-     * Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key. Space for the recursive call stack in the worst case.
      */
     /**
      * Time Complexity: O(log n)
@@ -9153,12 +9790,12 @@ var dataStructureTyped = (() => {
      * are either lesser or greater than a target node, depending on the specified comparison type.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * that satisfies the condition specified by the `lesserOrGreater` parameter. It takes a single
-     * parameter of type `N` (the node type) and returns a value of any type.
+     * parameter of type `NODE` (the node type) and returns a value of any type.
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It is of type
      * `CP`, which is a custom type representing the comparison operator. The possible values for
      * `lesserOrGreater` are
-     * @param {K | N | undefined} targetNode - The `targetNode` parameter represents the node in the
+     * @param {K | NODE | undefined} targetNode - The `targetNode` parameter represents the node in the
      * binary tree that you want to traverse from. It can be specified either by its key, by the node
      * object itself, or it can be left undefined to start the traversal from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
@@ -9265,8 +9902,8 @@ var dataStructureTyped = (() => {
      * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
      */
     /**
-     * Time Complexity: O(n) - Building a balanced tree from a sorted array.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(n)
@@ -9779,7 +10416,7 @@ var dataStructureTyped = (() => {
   var AVLTree = class _AVLTree extends BST {
     /**
      * The constructor function initializes an AVLTree object with optional keysOrNodesOrEntries and options.
-     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, NODE>`
      * objects. It represents a collection of nodes that will be added to the AVL tree during
      * initialization.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
@@ -9797,7 +10434,7 @@ var dataStructureTyped = (() => {
      * the new node. It is used to determine the position of the node in the binary search tree.
      * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It is of
      * type `V`, which means it can be any value that is assignable to the `value` property of the
-     * node type `N`.
+     * node type `NODE`.
      * @returns a new AVLTreeNode object with the specified key and value.
      */
     createNode(key, value) {
@@ -9818,7 +10455,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of AVLTreeNode.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeNode class.
      */
     isNode(keyOrNodeOrEntry) {
@@ -9865,8 +10502,8 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
      * default to the `_defaultOneParamCallback` function. The `callback` function should have a single
-     * parameter of type `N
-     * @returns The method is returning an array of `BinaryTreeDeleteResult<N>`.
+     * parameter of type `NODE
+     * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
       if (identifier instanceof AVLTreeNode)
@@ -9882,9 +10519,9 @@ var dataStructureTyped = (() => {
     /**
      * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
      * tree.
-     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node that
-     * needs to be swapped with the destination node. It can be of type `K`, `N`, or `undefined`.
-     * @param {K | N  | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | NODE | undefined} srcNode - The `srcNode` parameter represents the source node that
+     * needs to be swapped with the destination node. It can be of type `K`, `NODE`, or `undefined`.
+     * @param {K | NODE  | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
@@ -9911,14 +10548,13 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * constant time, as it performs a fixed number of operations. constant space, as it only uses a constant amount of memory.
      */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function calculates the balance factor of a node in a binary tree.
-     * @param {N} node - The parameter "node" represents a node in a binary tree data structure.
+     * @param {NODE} node - The parameter "node" represents a node in a binary tree data structure.
      * @returns the balance factor of a given node. The balance factor is calculated by subtracting the
      * height of the left subtree from the height of the right subtree.
      */
@@ -9933,7 +10569,6 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * constant time, as it performs a fixed number of operations. constant space, as it only uses a constant amount of memory.
      */
     /**
      * Time Complexity: O(1)
@@ -9941,7 +10576,7 @@ var dataStructureTyped = (() => {
      *
      * The function updates the height of a node in a binary tree based on the heights of its left and
      * right children.
-     * @param {N} node - The parameter "node" represents a node in a binary tree data structure.
+     * @param {NODE} node - The parameter "node" represents a node in a binary tree data structure.
      */
     _updateHeight(node) {
       if (!node.left && !node.right)
@@ -9954,58 +10589,16 @@ var dataStructureTyped = (() => {
       else
         node.height = 1 + Math.max(node.right.height, node.left.height);
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     * logarithmic time, where "n" is the number of nodes in the tree. The method traverses the path from the inserted node to the root. constant space, as it doesn't use additional data structures that scale with input size.
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * 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 {N} node - The `node` parameter in the `_balancePath` function represents the node in the
-     * AVL tree that needs to be balanced.
-     */
-    _balancePath(node) {
-      node = this.ensureNode(node);
-      const path = this.getPathToRoot(node, false);
-      for (let i = 0; i < path.length; i++) {
-        const A = path[i];
-        this._updateHeight(A);
-        switch (this._balanceFactor(A)) {
-          case -2:
-            if (A && A.left) {
-              if (this._balanceFactor(A.left) <= 0) {
-                this._balanceLL(A);
-              } else {
-                this._balanceLR(A);
-              }
-            }
-            break;
-          case 2:
-            if (A && A.right) {
-              if (this._balanceFactor(A.right) >= 0) {
-                this._balanceRR(A);
-              } else {
-                this._balanceRL(A);
-              }
-            }
-        }
-      }
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * constant time, as these methods perform a fixed number of operations. constant space, as they only use a constant amount of memory.
      */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function `_balanceLL` performs a left-left rotation to balance a binary tree.
-     * @param {N} A - A is a node in a binary tree.
+     * @param {NODE} A - A is a node in a binary tree.
      */
     _balanceLL(A) {
       const parentOfA = A.parent;
@@ -10044,7 +10637,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
-     * @param {N} A - A is a node in a binary tree.
+     * @param {NODE} A - A is a node in a binary tree.
      */
     _balanceLR(A) {
       const parentOfA = A.parent;
@@ -10098,7 +10691,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
-     * @param {N} A - A is a node in a binary tree.
+     * @param {NODE} A - A is a node in a binary tree.
      */
     _balanceRR(A) {
       const parentOfA = A.parent;
@@ -10138,7 +10731,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
-     * @param {N} A - A is a node in a binary tree.
+     * @param {NODE} A - A is a node in a binary tree.
      */
     _balanceRL(A) {
       const parentOfA = A.parent;
@@ -10183,6 +10776,47 @@ var dataStructureTyped = (() => {
       B && this._updateHeight(B);
       C && this._updateHeight(C);
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The method traverses the path from the inserted node to the root. constant space, as it doesn't use additional data structures that scale with input size.
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * 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 {NODE} node - The `node` parameter in the `_balancePath` function represents the node in the
+     * AVL tree that needs to be balanced.
+     */
+    _balancePath(node) {
+      node = this.ensureNode(node);
+      const path = this.getPathToRoot(node, false);
+      for (let i = 0; i < path.length; i++) {
+        const A = path[i];
+        this._updateHeight(A);
+        switch (this._balanceFactor(A)) {
+          case -2:
+            if (A && A.left) {
+              if (this._balanceFactor(A.left) <= 0) {
+                this._balanceLL(A);
+              } else {
+                this._balanceLR(A);
+              }
+            }
+            break;
+          case 2:
+            if (A && A.right) {
+              if (this._balanceFactor(A.right) >= 0) {
+                this._balanceRR(A);
+              } else {
+                this._balanceRL(A);
+              }
+            }
+        }
+      }
+    }
     _replaceNode(oldNode, newNode) {
       newNode.height = oldNode.height;
       return super._replaceNode(oldNode, newNode);
@@ -10201,7 +10835,7 @@ var dataStructureTyped = (() => {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional nodes and options.
-     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, NODE>`
      * objects. It represents the initial nodes that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * nodes to the
@@ -10252,14 +10886,14 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function `exemplarToNode` takes an keyOrNodeOrEntry and converts it into a node object if possible.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, where:
+     * The function `keyValueOrEntryToNode` takes an keyOrNodeOrEntry and converts it into a node object if possible.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If a value
+     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
-     * @returns a node of type N or undefined.
+     * @returns a node of type NODE or undefined.
      */
-    exemplarToNode(keyOrNodeOrEntry, value) {
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value) {
       let node;
       if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
         return;
@@ -10281,17 +10915,13 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of the RedBlackTreeNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the RedBlackTreeNode
      * class.
      */
     isNode(keyOrNodeOrEntry) {
       return keyOrNodeOrEntry instanceof RedBlackTreeNode;
     }
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
     isRealNode(node) {
       if (node === this.Sentinel || node === void 0)
         return false;
@@ -10300,7 +10930,7 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     *  on average (where n is the number of nodes in the tree)
+     * On average (where n is the number of nodes in the tree)
      */
     /**
      * Time Complexity: O(log n)
@@ -10312,10 +10942,10 @@ var dataStructureTyped = (() => {
      * entry.
      * @param {V} [value] - The `value` parameter represents the value associated with the key that is
      * being added to the binary search tree.
-     * @returns The method `add` returns either the newly added node (`N`) or `undefined`.
+     * @returns The method `add` returns either the newly added node (`NODE`) or `undefined`.
      */
     add(keyOrNodeOrEntry, value) {
-      const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
+      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
       if (newNode === void 0)
         return false;
       newNode.left = this.Sentinel;
@@ -10361,7 +10991,6 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     *  on average (where n is the number of nodes in the tree)
      */
     /**
      * Time Complexity: O(log n)
@@ -10373,10 +11002,10 @@ var dataStructureTyped = (() => {
      * that you want to use to identify the node that you want to delete from the binary tree. It can be
      * of any type that is returned by the callback function `C`. It can also be `null` or `undefined` if
      * you don't want to
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
+     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` and
      * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
      * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BinaryTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
       const ans = [];
@@ -10448,14 +11077,14 @@ var dataStructureTyped = (() => {
      * node that matches the other criteria
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
-     * function should take a single parameter of type `N` (the type of the nodes in the binary tree) and
-     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is the starting point for
+     * function should take a single parameter of type `NODE` (the type of the nodes in the binary tree) and
+     * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter is the starting point for
      * searching for a node in a binary tree. It can be either a key value or a node object. If it is not
      * provided, the search will start from the root of the binary tree.
      * @param iterationType - The `iterationType` parameter is a variable that determines the type of
      * iteration to be performed when searching for nodes in the binary tree. It is used in the
      * `getNodes` method, which is called within the `getNode` method.
-     * @returns a value of type `N`, `null`, or `undefined`.
+     * @returns a value of type `NODE`, `null`, or `undefined`.
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
       var _a;
@@ -10464,6 +11093,14 @@ var dataStructureTyped = (() => {
       beginRoot = this.ensureNode(beginRoot);
       return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    clear() {
+      this._root = this.Sentinel;
+      this._size = 0;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -10488,14 +11125,6 @@ var dataStructureTyped = (() => {
       }
       return y;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    clear() {
-      this._root = this.Sentinel;
-      this._size = 0;
-    }
     _setRoot(v) {
       if (v) {
         v.parent = void 0;
@@ -10511,7 +11140,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function performs a left rotation on a binary tree node.
-     * @param {RedBlackTreeNode} x - The parameter `x` is of type `N`, which likely represents a node in a binary tree.
+     * @param {RedBlackTreeNode} x - The parameter `x` is of type `NODE`, which likely represents a node in a binary tree.
      */
     _leftRotate(x) {
       if (x.right) {
@@ -10553,17 +11182,71 @@ var dataStructureTyped = (() => {
           if (y.right)
             y.right.parent = x;
         }
-        y.parent = x.parent;
-        if (x.parent === void 0) {
-          this._setRoot(y);
-        } else if (x === x.parent.right) {
-          x.parent.right = y;
-        } else {
-          x.parent.left = y;
+        y.parent = x.parent;
+        if (x.parent === void 0) {
+          this._setRoot(y);
+        } else if (x === x.parent.right) {
+          x.parent.right = y;
+        } else {
+          x.parent.left = y;
+        }
+        y.right = x;
+        x.parent = y;
+      }
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
+     * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
+     * red-black tree.
+     */
+    _fixInsert(k) {
+      let u;
+      while (k.parent && k.parent.color === 1) {
+        if (k.parent.parent && k.parent === k.parent.parent.right) {
+          u = k.parent.parent.left;
+          if (u && u.color === 1) {
+            u.color = 0 /* BLACK */;
+            k.parent.color = 0 /* BLACK */;
+            k.parent.parent.color = 1 /* RED */;
+            k = k.parent.parent;
+          } else {
+            if (k === k.parent.left) {
+              k = k.parent;
+              this._rightRotate(k);
+            }
+            k.parent.color = 0 /* BLACK */;
+            k.parent.parent.color = 1 /* RED */;
+            this._leftRotate(k.parent.parent);
+          }
+        } else {
+          u = k.parent.parent.right;
+          if (u && u.color === 1) {
+            u.color = 0 /* BLACK */;
+            k.parent.color = 0 /* BLACK */;
+            k.parent.parent.color = 1 /* RED */;
+            k = k.parent.parent;
+          } else {
+            if (k === k.parent.right) {
+              k = k.parent;
+              this._leftRotate(k);
+            }
+            k.parent.color = 0 /* BLACK */;
+            k.parent.parent.color = 1 /* RED */;
+            this._rightRotate(k.parent.parent);
+          }
+        }
+        if (k === this.root) {
+          break;
         }
-        y.right = x;
-        x.parent = y;
       }
+      this.root.color = 0 /* BLACK */;
     }
     /**
      * Time Complexity: O(log n)
@@ -10659,65 +11342,11 @@ var dataStructureTyped = (() => {
       }
       v.parent = u.parent;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
-     * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
-     * red-black tree.
-     */
-    _fixInsert(k) {
-      let u;
-      while (k.parent && k.parent.color === 1) {
-        if (k.parent.parent && k.parent === k.parent.parent.right) {
-          u = k.parent.parent.left;
-          if (u && u.color === 1) {
-            u.color = 0 /* BLACK */;
-            k.parent.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
-            k = k.parent.parent;
-          } else {
-            if (k === k.parent.left) {
-              k = k.parent;
-              this._rightRotate(k);
-            }
-            k.parent.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
-            this._leftRotate(k.parent.parent);
-          }
-        } else {
-          u = k.parent.parent.right;
-          if (u && u.color === 1) {
-            u.color = 0 /* BLACK */;
-            k.parent.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
-            k = k.parent.parent;
-          } else {
-            if (k === k.parent.right) {
-              k = k.parent;
-              this._leftRotate(k);
-            }
-            k.parent.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
-            this._rightRotate(k.parent.parent);
-          }
-        }
-        if (k === this.root) {
-          break;
-        }
-      }
-      this.root.color = 0 /* BLACK */;
-    }
     /**
      * The function replaces an old node with a new node while preserving the color of the old node.
-     * @param {N} oldNode - The `oldNode` parameter represents the node that needs to be replaced in a
-     * data structure. It is of type `N`, which is the type of the nodes in the data structure.
-     * @param {N} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
+     * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in a
+     * data structure. It is of type `NODE`, which is the type of the nodes in the data structure.
+     * @param {NODE} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
      * data structure.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
      * superclass, passing in the `oldNode` and `newNode` as arguments.
@@ -10763,7 +11392,7 @@ var dataStructureTyped = (() => {
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
-     * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
+     * @param {NODE} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
@@ -10778,17 +11407,17 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, which means it
+     * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
      * it defaults to `undefined`.
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
      * times the value should be added to the node. If not provided, it defaults to 1.
-     * @returns a node of type `N` or `undefined`.
+     * @returns a node of type `NODE` or `undefined`.
      */
-    exemplarToNode(keyOrNodeOrEntry, value, count = 1) {
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value, count = 1) {
       let node;
       if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
         return;
@@ -10810,7 +11439,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
      * class.
      */
@@ -10820,7 +11449,6 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
      * Time Complexity: O(log n)
@@ -10839,7 +11467,7 @@ var dataStructureTyped = (() => {
      * was not successful.
      */
     add(keyOrNodeOrEntry, value, count = 1) {
-      const newNode = this.exemplarToNode(keyOrNodeOrEntry, value, count);
+      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
       if (newNode === void 0)
         return false;
       const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
@@ -10850,81 +11478,11 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(1)
-     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
-     */
-    /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(1)
-     *
-     * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
-     * structure.
-     * @param keysOrNodesOrEntries - The parameter `keysOrNodesOrEntries` is an iterable that can contain
-     * either keys, nodes, or entries.
-     * @returns The method is returning an array of type `N | undefined`.
-     */
-    addMany(keysOrNodesOrEntries) {
-      return super.addMany(keysOrNodesOrEntries);
-    }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     * logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node. linear space, as it creates an array to store the sorted nodes.
-     */
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
-     * tree using either a recursive or iterative approach.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when building the balanced binary search tree. It can have two possible
-     * values:
-     * @returns a boolean value.
-     */
-    perfectlyBalance(iterationType = this.iterationType) {
-      const sorted = this.dfs((node) => node, "in"), n = sorted.length;
-      if (sorted.length < 1)
-        return false;
-      this.clear();
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
-        const buildBalanceBST = (l, r) => {
-          if (l > r)
-            return;
-          const m = l + Math.floor((r - l) / 2);
-          const midNode = sorted[m];
-          this.add(midNode.key, midNode.value, midNode.count);
-          buildBalanceBST(l, m - 1);
-          buildBalanceBST(m + 1, r);
-        };
-        buildBalanceBST(0, n - 1);
-        return true;
-      } else {
-        const stack = [[0, n - 1]];
-        while (stack.length > 0) {
-          const popped = stack.pop();
-          if (popped) {
-            const [l, r] = popped;
-            if (l <= r) {
-              const m = l + Math.floor((r - l) / 2);
-              const midNode = sorted[m];
-              this.add(midNode.key, midNode.value, midNode.count);
-              stack.push([m + 1, r]);
-              stack.push([l, m - 1]);
-            }
-          }
-        }
-        return true;
-      }
-    }
-    /**
-     * Time Complexity: O(k log n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     * logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k log n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
@@ -10940,7 +11498,7 @@ var dataStructureTyped = (() => {
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
-     * @returns an array of `BinaryTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
       var _a;
@@ -11008,6 +11566,56 @@ var dataStructureTyped = (() => {
       super.clear();
       this._count = 0;
     }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     *
+     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
+     * tree using either a recursive or iterative approach.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building the balanced binary search tree. It can have two possible
+     * values:
+     * @returns a boolean value.
+     */
+    perfectlyBalance(iterationType = this.iterationType) {
+      const sorted = this.dfs((node) => node, "in"), n = sorted.length;
+      if (sorted.length < 1)
+        return false;
+      this.clear();
+      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+        const buildBalanceBST = (l, r) => {
+          if (l > r)
+            return;
+          const m = l + Math.floor((r - l) / 2);
+          const midNode = sorted[m];
+          this.add(midNode.key, midNode.value, midNode.count);
+          buildBalanceBST(l, m - 1);
+          buildBalanceBST(m + 1, r);
+        };
+        buildBalanceBST(0, n - 1);
+        return true;
+      } else {
+        const stack = [[0, n - 1]];
+        while (stack.length > 0) {
+          const popped = stack.pop();
+          if (popped) {
+            const [l, r] = popped;
+            if (l <= r) {
+              const m = l + Math.floor((r - l) / 2);
+              const midNode = sorted[m];
+              this.add(midNode.key, midNode.value, midNode.count);
+              stack.push([m + 1, r]);
+              stack.push([l, m - 1]);
+            }
+          }
+        }
+        return true;
+      }
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -11026,9 +11634,9 @@ var dataStructureTyped = (() => {
     }
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
-     * which the values will be swapped. It can be of type `K`, `N`, or `undefined`.
-     * @param {K | N | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | NODE | undefined} srcNode - The `srcNode` parameter represents the source node from
+     * which the values will be swapped. It can be of type `K`, `NODE`, or `undefined`.
+     * @param {K | NODE | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
@@ -11180,21 +11788,45 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    /**
+     * The function returns the number of rows.
+     * @returns The number of rows.
+     */
     get rows() {
       return this._rows;
     }
+    /**
+     * The function returns the value of the private variable _cols.
+     * @returns The number of columns.
+     */
     get cols() {
       return this._cols;
     }
+    /**
+     * The function returns a two-dimensional array of numbers.
+     * @returns The data property, which is a two-dimensional array of numbers.
+     */
     get data() {
       return this._data;
     }
+    /**
+     * The above function returns the value of the _addFn property.
+     * @returns The value of the property `_addFn` is being returned.
+     */
     get addFn() {
       return this._addFn;
     }
+    /**
+     * The function returns the value of the _subtractFn property.
+     * @returns The `_subtractFn` property is being returned.
+     */
     get subtractFn() {
       return this._subtractFn;
     }
+    /**
+     * The function returns the value of the _multiplyFn property.
+     * @returns The `_multiplyFn` property is being returned.
+     */
     get multiplyFn() {
       return this._multiplyFn;
     }
@@ -11460,17 +12092,6 @@ var dataStructureTyped = (() => {
         multiplyFn: this.multiplyFn
       });
     }
-    _addFn(a, b) {
-      if (a === void 0)
-        return b;
-      return a + b;
-    }
-    _subtractFn(a, b) {
-      return a - b;
-    }
-    _multiplyFn(a, b) {
-      return a * b;
-    }
     /**
      * The function checks if a given row and column index is valid within a specified range.
      * @param {number} row - The `row` parameter represents the row index of a two-dimensional array or
@@ -11482,6 +12103,32 @@ var dataStructureTyped = (() => {
     isValidIndex(row, col) {
       return row >= 0 && row < this.rows && col >= 0 && col < this.cols;
     }
+    /**
+     * The `clone` function returns a new instance of the Matrix class with the same data and properties
+     * as the original instance.
+     * @returns The `clone()` method is returning a new instance of the `Matrix` class with the same data
+     * and properties as the current instance.
+     */
+    clone() {
+      return new _Matrix(this.data, {
+        rows: this.rows,
+        cols: this.cols,
+        addFn: this.addFn,
+        subtractFn: this.subtractFn,
+        multiplyFn: this.multiplyFn
+      });
+    }
+    _addFn(a, b) {
+      if (a === void 0)
+        return b;
+      return a + b;
+    }
+    _subtractFn(a, b) {
+      return a - b;
+    }
+    _multiplyFn(a, b) {
+      return a * b;
+    }
     /**
      * The function `_swapRows` swaps the positions of two rows in an array.
      * @param {number} row1 - The `row1` parameter is the index of the first row that you want to swap.
@@ -11653,6 +12300,12 @@ var dataStructureTyped = (() => {
     }
   };
   var Trie = class _Trie extends IterableElementBase {
+    /**
+     * The constructor function for the Trie class.
+     * @param words: Iterable string Initialize the trie with a set of words
+     * @param options?: TrieOptions Allow the user to pass in options for the trie
+     * @return This
+     */
     constructor(words = [], options) {
       super();
       __publicField(this, "_size", 0);
@@ -11668,12 +12321,25 @@ var dataStructureTyped = (() => {
           this.add(word);
       }
     }
+    /**
+     * The size function returns the size of the stack.
+     * @return The number of elements in the list
+     */
     get size() {
       return this._size;
     }
+    /**
+     * The caseSensitive function is a getter that returns the value of the private _caseSensitive property.
+     *
+     * @return The value of the _casesensitive private variable
+     */
     get caseSensitive() {
       return this._caseSensitive;
     }
+    /**
+     * The root function returns the root node of the tree.
+     * @return The root node
+     */
     get root() {
       return this._root;
     }
@@ -11731,6 +12397,13 @@ var dataStructureTyped = (() => {
       }
       return cur.isEnd;
     }
+    /**
+     * The isEmpty function checks if the size of the queue is 0.
+     * @return True if the size of the queue is 0
+     */
+    isEmpty() {
+      return this.size === 0;
+    }
     /**
      * Time Complexity: O(M), where M is the length of the word being deleted.
      * Space Complexity: O(M) - Due to the recursive DFS approach.
@@ -11950,6 +12623,21 @@ var dataStructureTyped = (() => {
         dfs(startNode, prefix);
       return words;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone` function returns a new instance of the Trie class with the same values and case
+     * sensitivity as the original Trie.
+     * @returns A new instance of the Trie class is being returned.
+     */
+    clone() {
+      return new _Trie(this.values(), { caseSensitive: this.caseSensitive });
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)