data-structure-typed 1.54.2 → 2.0.0

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

@@ -422,13 +422,6 @@ var dataStructureTyped = (() => {
         else if (toElementFn) throw new TypeError("toElementFn must be a function type");
       }
     }
-    /**
-     * The function returns the _toElementFn property, which is a function that converts a raw element to
-     * a specific type.
-     * @returns The function `get toElementFn()` is returning either a function that takes a raw element
-     * `rawElement` of type `R` and returns an element `E`, or `undefined` if no function is assigned to
-     * `_toElementFn`.
-     */
     get toElementFn() {
       return this._toElementFn;
     }
@@ -526,7 +519,7 @@ var dataStructureTyped = (() => {
      *
      * 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
+     * @param predicate - The predicate 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.
@@ -536,10 +529,10 @@ var dataStructureTyped = (() => {
      * @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) {
+    find(predicate, thisArg) {
       let index = 0;
       for (const item of this) {
-        if (callbackfn.call(thisArg, item, index++, this)) return item;
+        if (predicate.call(thisArg, item, index++, this)) return item;
       }
       return;
     }
@@ -573,13 +566,23 @@ var dataStructureTyped = (() => {
      * all the elements in the array and applying the callback function to each element.
      */
     reduce(callbackfn, initialValue) {
-      let accumulator = initialValue;
+      let accumulator = initialValue != null ? initialValue : 0;
       let index = 0;
       for (const item of this) {
         accumulator = callbackfn(accumulator, item, index++, this);
       }
       return accumulator;
     }
+    /**
+     * 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[]`.
+     */
+    toArray() {
+      return [...this];
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -1500,97 +1503,566 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/data-structures/linked-list/singly-linked-list.ts
-  var SinglyLinkedListNode = class {
-    /**
-     * The constructor function initializes an instance of a class with a given value and sets the next property to undefined.
-     * @param {E} value - The "value" parameter is of type E, which means it can be any data type. It represents the value that
-     * will be stored in the node of a linked list.
-     */
+  // src/data-structures/base/linear-base.ts
+  var LinkedListNode = class {
     constructor(value) {
       __publicField(this, "_value");
       __publicField(this, "_next");
       this._value = value;
       this._next = void 0;
     }
-    /**
-     * The function returns the value of a protected variable.
-     * @returns The value of the variable `_value` is being returned.
-     */
     get value() {
       return this._value;
     }
-    /**
-     * The above function sets the value of a variable.
-     * @param {E} value - The parameter "value" is of type E, which means it can be any type.
-     */
     set value(value) {
       this._value = value;
     }
-    /**
-     * The `next` function returns the next node in a singly linked list.
-     * @returns The `next` property is being returned. It can be either a `SinglyLinkedListNode<E>`
-     * object or `undefined`.
-     */
     get next() {
       return this._next;
     }
+    set next(value) {
+      this._next = value;
+    }
+  };
+  var LinearBase = class _LinearBase extends IterableElementBase {
+    /**
+     * The constructor initializes the LinearBase class with optional options, setting the maximum length
+     * if provided.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the
+     * constructor. It is of type `LinearBaseOptions<E, R>`. The constructor checks if the `options`
+     * object is provided and then extracts the `maxLen` property from it. If `maxLen` is a
+     */
+    constructor(options) {
+      super(options);
+      __publicField(this, "_maxLen", -1);
+      if (options) {
+        const { maxLen } = options;
+        if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+      }
+    }
+    get maxLen() {
+      return this._maxLen;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function indexOf searches for a specified element starting from a given index in an array-like
+     * object and returns the index of the first occurrence, or -1 if not found.
+     * @param {E} searchElement - The `searchElement` parameter in the `indexOf` function represents the
+     * element that you want to find within the array. The function will search for this element starting
+     * from the `fromIndex` (if provided) up to the end of the array. If the `searchElement` is found
+     * within the
+     * @param {number} [fromIndex=0] - The `fromIndex` parameter in the `indexOf` function represents the
+     * index at which to start searching for the `searchElement` within the array. If provided, the
+     * search will begin at this index and continue to the end of the array. If `fromIndex` is not
+     * specified, the default
+     * @returns The `indexOf` method is returning the index of the `searchElement` if it is found in the
+     * array starting from the `fromIndex`. If the `searchElement` is not found, it returns -1.
+     */
+    indexOf(searchElement, fromIndex = 0) {
+      if (this.length === 0) return -1;
+      if (fromIndex < 0) fromIndex = this.length + fromIndex;
+      if (fromIndex < 0) fromIndex = 0;
+      for (let i = fromIndex; i < this.length; i++) {
+        const element = this.at(i);
+        if (element === searchElement) return i;
+      }
+      return -1;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `lastIndexOf` in TypeScript returns the index of the last occurrence of a specified
+     * element in an array.
+     * @param {E} searchElement - The `searchElement` parameter is the element that you want to find the
+     * last index of within the array. The `lastIndexOf` method will search the array starting from the
+     * `fromIndex` (or the end of the array if not specified) and return the index of the last occurrence
+     * of the
+     * @param {number} fromIndex - The `fromIndex` parameter in the `lastIndexOf` method specifies the
+     * index at which to start searching for the `searchElement` in the array. By default, it starts
+     * searching from the last element of the array (`this.length - 1`). If a specific `fromIndex` is
+     * provided
+     * @returns The last index of the `searchElement` in the array is being returned. If the
+     * `searchElement` is not found in the array, -1 is returned.
+     */
+    lastIndexOf(searchElement, fromIndex = this.length - 1) {
+      if (this.length === 0) return -1;
+      if (fromIndex >= this.length) fromIndex = this.length - 1;
+      if (fromIndex < 0) fromIndex = this.length + fromIndex;
+      for (let i = fromIndex; i >= 0; i--) {
+        const element = this.at(i);
+        if (element === searchElement) return i;
+      }
+      return -1;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `findIndex` function iterates over an array and returns the index of the first element that
+     * satisfies the provided predicate function.
+     * @param predicate - The `predicate` parameter in the `findIndex` function is a callback function
+     * that takes three arguments: `item`, `index`, and the array `this`. It should return a boolean
+     * value indicating whether the current element satisfies the condition being checked for.
+     * @param {any} [thisArg] - The `thisArg` parameter in the `findIndex` function is an optional
+     * parameter that specifies the value to use as `this` when executing the `predicate` function. If
+     * provided, the `predicate` function will be called with `thisArg` as its `this` value. If `
+     * @returns The `findIndex` method is returning the index of the first element in the array that
+     * satisfies the provided predicate function. If no such element is found, it returns -1.
+     */
+    findIndex(predicate, thisArg) {
+      for (let i = 0; i < this.length; i++) {
+        const item = this.at(i);
+        if (item !== void 0 && predicate.call(thisArg, item, i, this)) return i;
+      }
+      return -1;
+    }
+    /**
+     * Time Complexity: O(n + m)
+     * Space Complexity: O(n + m)
+     *
+     * The `concat` function in TypeScript concatenates multiple items into a new list, handling both
+     * individual elements and instances of `LinearBase`.
+     * @param {(E | this)[]} items - The `concat` method takes in an array of items, where
+     * each item can be either of type `E` or an instance of `LinearBase<E, R>`.
+     * @returns The `concat` method is returning a new instance of the class that it belongs to, with the
+     * items passed as arguments concatenated to it.
+     */
+    concat(...items) {
+      const newList = this.clone();
+      for (const item of items) {
+        if (item instanceof _LinearBase) {
+          newList.pushMany(item);
+        } else {
+          newList.push(item);
+        }
+      }
+      return newList;
+    }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     *
+     * The `sort` function in TypeScript sorts the elements of a collection using a specified comparison
+     * function.
+     * @param [compareFn] - The `compareFn` parameter is a function that defines the sort order. It takes
+     * two elements `a` and `b` as input and returns a number indicating their relative order. If the
+     * returned value is negative, `a` comes before `b`. If the returned value is positive, `
+     * @returns The `sort` method is returning the instance of the object on which it is called (this),
+     * after sorting the elements based on the provided comparison function (compareFn).
+     */
+    sort(compareFn) {
+      const arr = this.toArray();
+      arr.sort(compareFn);
+      this.clear();
+      for (const item of arr) this.push(item);
+      return this;
+    }
+    /**
+     * Time Complexity: O(n + m)
+     * Space Complexity: O(m)
+     *
+     * The `splice` function in TypeScript removes elements from an array and optionally inserts new
+     * elements at the specified index.
+     * @param {number} start - The `start` parameter in the `splice` method indicates the index at which
+     * to start modifying the array. If `start` is a negative number, it will count from the end of the
+     * array.
+     * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
+     * number of elements to remove from the array starting at the specified `start` index. If
+     * `deleteCount` is not provided or is 0, no elements are removed, and only new elements are inserted
+     * at the `start`
+     * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+     * will be inserted into the array at the specified `start` index. These elements can be of any type
+     * and you can pass multiple elements separated by commas. The `splice` method will insert these
+     * items into the array at the
+     * @returns The `splice` method returns a list of elements that were removed from the original list
+     * during the operation.
+     */
+    splice(start, deleteCount = 0, ...items) {
+      const removedList = this._createInstance();
+      start = start < 0 ? this.length + start : start;
+      start = Math.max(0, Math.min(start, this.length));
+      deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+      for (let i = 0; i < deleteCount; i++) {
+        const removed = this.deleteAt(start);
+        if (removed !== void 0) {
+          removedList.push(removed);
+        }
+      }
+      for (let i = 0; i < items.length; i++) {
+        this.addAt(start + i, items[i]);
+      }
+      return removedList;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `join` function in TypeScript returns a string by joining the elements of an array with a
+     * specified separator.
+     * @param {string} [separator=,] - The `separator` parameter is a string that specifies the character
+     * or characters that will be used to separate each element when joining them into a single string.
+     * By default, the separator is set to a comma (`,`), but you can provide a different separator if
+     * needed.
+     * @returns The `join` method is being returned, which takes an optional `separator` parameter
+     * (defaulting to a comma) and returns a string created by joining all elements of the array after
+     * converting it to an array.
+     */
+    join(separator = ",") {
+      return this.toArray().join(separator);
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `toReversedArray` takes an array and returns a new array with its elements in reverse
+     * order.
+     * @returns The `toReversedArray()` function returns an array of elements of type `E` in reverse
+     * order.
+     */
+    toReversedArray() {
+      const array = [];
+      for (let i = this.length - 1; i >= 0; i--) {
+        array.push(this.at(i));
+      }
+      return array;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `reduceRight` function in TypeScript iterates over an array from right to left and applies a
+     * callback function to each element, accumulating a single result.
+     * @param callbackfn - The `callbackfn` parameter in the `reduceRight` method is a function that will
+     * be called on each element in the array from right to left. It takes four arguments:
+     * @param {U} [initialValue] - The `initialValue` parameter in the `reduceRight` method is an
+     * optional parameter that specifies the initial value of the accumulator. If provided, the
+     * `accumulator` will start with this initial value before iterating over the elements of the array.
+     * If `initialValue` is not provided, the accumulator will
+     * @returns The `reduceRight` method is returning the final accumulated value after applying the
+     * callback function to each element in the array from right to left.
+     */
+    reduceRight(callbackfn, initialValue) {
+      let accumulator = initialValue != null ? initialValue : 0;
+      for (let i = this.length - 1; i >= 0; i--) {
+        accumulator = callbackfn(accumulator, this.at(i), i, this);
+      }
+      return accumulator;
+    }
+    /**
+     * Time Complexity: O(m)
+     * Space Complexity: O(m)
+     *
+     * The `slice` function in TypeScript creates a new instance by extracting a portion of elements from
+     * the original instance based on the specified start and end indices.
+     * @param {number} [start=0] - The `start` parameter in the `slice` method represents the index at
+     * which to begin extracting elements from an array-like object. If no `start` parameter is provided,
+     * the default value is 0, meaning the extraction will start from the beginning of the array.
+     * @param {number} end - The `end` parameter in the `slice` method represents the index at which to
+     * end the slicing. By default, if no `end` parameter is provided, it will slice until the end of the
+     * array (i.e., `this.length`).
+     * @returns The `slice` method is returning a new instance of the object with elements sliced from
+     * the specified start index (default is 0) to the specified end index (default is the length of the
+     * object).
+     */
+    slice(start = 0, end = this.length) {
+      start = start < 0 ? this.length + start : start;
+      end = end < 0 ? this.length + end : end;
+      const newList = this._createInstance();
+      for (let i = start; i < end; i++) {
+        newList.push(this.at(i));
+      }
+      return newList;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `fill` function in TypeScript fills a specified range in an array-like object with a given
+     * value.
+     * @param {E} value - The `value` parameter in the `fill` method represents the element that will be
+     * used to fill the specified range in the array.
+     * @param [start=0] - The `start` parameter specifies the index at which to start filling the array
+     * with the specified value. If not provided, it defaults to 0, indicating the beginning of the
+     * array.
+     * @param end - The `end` parameter in the `fill` function represents the index at which the filling
+     * of values should stop. It specifies the end of the range within the array where the `value` should
+     * be filled.
+     * @returns The `fill` method is returning the modified object (`this`) after filling the specified
+     * range with the provided value.
+     */
+    fill(value, start = 0, end = this.length) {
+      start = start < 0 ? this.length + start : start;
+      end = end < 0 ? this.length + end : end;
+      if (start < 0) start = 0;
+      if (end > this.length) end = this.length;
+      if (start >= end) return this;
+      for (let i = start; i < end; i++) {
+        this.setAt(i, value);
+      }
+      return this;
+    }
+  };
+  var LinearLinkedBase = class extends LinearBase {
+    /**
+     * The constructor initializes the LinearBase class with optional options, setting the maximum length
+     * if provided and valid.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the
+     * constructor. It is of type `LinearBaseOptions<E, R>`. This object may contain properties such as
+     * `maxLen`, which is a number representing the maximum length. If `maxLen` is a positive integer,
+     */
+    constructor(options) {
+      super(options);
+      if (options) {
+        const { maxLen } = options;
+        if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function overrides the indexOf method to improve performance by searching for an element in a
+     * custom array implementation starting from a specified index.
+     * @param {E} searchElement - The `searchElement` parameter is the element that you are searching for
+     * within the array. The `indexOf` method will return the index of the first occurrence of this
+     * element within the array.
+     * @param {number} [fromIndex=0] - The `fromIndex` parameter in the `indexOf` method specifies the
+     * index in the array at which to start the search for the `searchElement`. If provided, the search
+     * will begin at the specified index and continue to the end of the array. If not provided, the
+     * search will start at index
+     * @returns The `indexOf` method is returning the index of the `searchElement` if it is found in the
+     * array starting from the `fromIndex`. If the `searchElement` is not found, it returns -1.
+     */
+    indexOf(searchElement, fromIndex = 0) {
+      const iterator = this._getIterator();
+      let current = iterator.next();
+      let index = 0;
+      while (index < fromIndex) {
+        current = iterator.next();
+        index++;
+      }
+      while (!current.done) {
+        if (current.value === searchElement) return index;
+        current = iterator.next();
+        index++;
+      }
+      return -1;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function overrides the lastIndexOf method in TypeScript to improve performance by searching
+     * for an element in reverse order starting from a specified index.
+     * @param {E} searchElement - The `searchElement` parameter is the element that you want to find
+     * within the array. The `lastIndexOf` method searches the array for this element starting from the
+     * end of the array (or from the specified `fromIndex` if provided) and returns the index of the last
+     * occurrence of the element
+     * @param {number} fromIndex - The `fromIndex` parameter in the `lastIndexOf` method specifies the
+     * index at which to start searching for the `searchElement` in the array. If provided, the search
+     * will begin at this index and move towards the beginning of the array. If not provided, the search
+     * will start at the
+     * @returns The `lastIndexOf` method is being overridden to search for the `searchElement` starting
+     * from the specified `fromIndex` (defaulting to the end of the array). It iterates over the array in
+     * reverse order using a custom iterator `_getReverseIterator` and returns the index of the last
+     * occurrence of the `searchElement` if found, or -1 if not found.
+     */
+    lastIndexOf(searchElement, fromIndex = this.length - 1) {
+      const iterator = this._getReverseIterator();
+      let current = iterator.next();
+      let index = this.length - 1;
+      while (index > fromIndex) {
+        current = iterator.next();
+        index--;
+      }
+      while (!current.done) {
+        if (current.value === searchElement) return index;
+        current = iterator.next();
+        index--;
+      }
+      return -1;
+    }
+    /**
+     * Time Complexity: O(n + m)
+     * Space Complexity: O(n + m)
+     *
+     * The `concat` function in TypeScript overrides the default behavior to concatenate items into a new
+     * list, handling both individual elements and instances of `LinearBase`.
+     * @param {(E | LinearBase<E, R>)[]} items - The `concat` method you provided takes in a variable
+     * number of arguments of type `E` or `LinearBase<E, R>`. The method concatenates these items to the
+     * current list and returns a new list with the concatenated items.
+     * @returns The `concat` method is returning a new instance of the class that it belongs to, with the
+     * items passed as arguments concatenated to it.
+     */
+    concat(...items) {
+      const newList = this.clone();
+      for (const item of items) {
+        if (item instanceof LinearBase) {
+          newList.pushMany(item);
+        } else {
+          newList.push(item);
+        }
+      }
+      return newList;
+    }
+    /**
+     * Time Complexity: O(m)
+     * Space Complexity: O(m)
+     *
+     * The `slice` method is overridden to improve performance by creating a new instance and iterating
+     * through the array to extract a subset based on the specified start and end indices.
+     * @param {number} [start=0] - The `start` parameter in the `slice` method specifies the index at
+     * which to begin extracting elements from the array. If no `start` parameter is provided, the
+     * default value is 0, indicating that extraction should start from the beginning of the array.
+     * @param {number} end - The `end` parameter in the `slice` method represents the index at which to
+     * end the slicing of the array. If not provided, it defaults to the length of the array.
+     * @returns The `slice` method is returning a new instance of the array implementation with elements
+     * sliced from the original array based on the `start` and `end` parameters.
+     */
+    slice(start = 0, end = this.length) {
+      start = start < 0 ? this.length + start : start;
+      end = end < 0 ? this.length + end : end;
+      const newList = this._createInstance();
+      const iterator = this._getIterator();
+      let current = iterator.next();
+      let c = 0;
+      while (c < start) {
+        current = iterator.next();
+        c++;
+      }
+      for (let i = start; i < end; i++) {
+        newList.push(current.value);
+        current = iterator.next();
+      }
+      return newList;
+    }
+    /**
+     * Time Complexity: O(n + m)
+     * Space Complexity: O(m)
+     *
+     * The function overrides the splice method to handle deletion and insertion of elements in a data
+     * structure while returning the removed elements.
+     * @param {number} start - The `start` parameter in the `splice` method indicates the index at which
+     * to start modifying the array.
+     * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
+     * number of elements to remove from the array starting at the specified `start` index. If
+     * `deleteCount` is not provided, it defaults to 0, meaning no elements will be removed but new
+     * elements can still be inserted at
+     * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+     * will be inserted into the array at the specified `start` index. These elements can be of any type
+     * and there can be multiple elements passed as arguments to be inserted into the array.
+     * @returns The `splice` method is returning a new instance of the data structure that was modified
+     * by removing elements specified by the `start` and `deleteCount` parameters, and inserting new
+     * elements provided in the `items` array.
+     */
+    splice(start, deleteCount = 0, ...items) {
+      const removedList = this._createInstance();
+      start = start < 0 ? this.length + start : start;
+      start = Math.max(0, Math.min(start, this.length));
+      deleteCount = Math.max(0, deleteCount);
+      let currentIndex = 0;
+      let currentNode = void 0;
+      let previousNode = void 0;
+      const iterator = this._getNodeIterator();
+      for (const node of iterator) {
+        if (currentIndex === start) {
+          currentNode = node;
+          break;
+        }
+        previousNode = node;
+        currentIndex++;
+      }
+      for (let i = 0; i < deleteCount && currentNode; i++) {
+        removedList.push(currentNode.value);
+        const nextNode = currentNode.next;
+        this.delete(currentNode);
+        currentNode = nextNode;
+      }
+      for (let i = 0; i < items.length; i++) {
+        if (previousNode) {
+          this.addAfter(previousNode, items[i]);
+          previousNode = previousNode.next;
+        } else {
+          this.addAt(0, items[i]);
+          previousNode = this._getNodeIterator().next().value;
+        }
+      }
+      return removedList;
+    }
     /**
-     * The "next" property of a SinglyLinkedListNode is set to the provided value.
-     * @param {SinglyLinkedListNode<E> | undefined} value - The `value` parameter is of type
-     * `SinglyLinkedListNode<E> | undefined`. This means that it can accept either a
-     * `SinglyLinkedListNode` object or `undefined` as its value.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `reduceRight` iterates over an array in reverse order and applies a callback function
+     * to each element, accumulating a single result.
+     * @param callbackfn - The `callbackfn` parameter is a function that will be called on each element
+     * of the array from right to left. It takes four arguments:
+     * @param {U} [initialValue] - The `initialValue` parameter is an optional value that is used as the
+     * initial accumulator value in the reduce operation. If provided, the reduce operation starts with
+     * this initial value and iterates over the elements of the array, applying the callback function to
+     * each element and the current accumulator value. If `initial
+     * @returns The `reduceRight` method is returning the final accumulated value after applying the
+     * callback function to each element in the array from right to left.
      */
+    reduceRight(callbackfn, initialValue) {
+      let accumulator = initialValue != null ? initialValue : 0;
+      let index = this.length - 1;
+      for (const item of this._getReverseIterator()) {
+        accumulator = callbackfn(accumulator, item, index--, this);
+      }
+      return accumulator;
+    }
+  };
+
+  // src/data-structures/linked-list/singly-linked-list.ts
+  var SinglyLinkedListNode = class extends LinkedListNode {
+    /**
+     * The constructor function initializes an instance of a class with a given value and sets the next property to undefined.
+     * @param {E} value - The "value" parameter is of type E, which means it can be any data type. It represents the value that
+     * will be stored in the node of a linked list.
+     */
+    constructor(value) {
+      super(value);
+      __publicField(this, "_next");
+      this._value = value;
+      this._next = void 0;
+    }
+    get next() {
+      return this._next;
+    }
     set next(value) {
       this._next = value;
     }
   };
-  var SinglyLinkedList = class _SinglyLinkedList extends IterableElementBase {
+  var SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     constructor(elements = [], options) {
       super(options);
       __publicField(this, "_head");
       __publicField(this, "_tail");
-      __publicField(this, "_size", 0);
+      __publicField(this, "_length", 0);
+      if (options) {
+      }
       this.pushMany(elements);
     }
-    /**
-     * 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 above function returns the value of the first element in a linked list, or undefined if the
-     * list is empty.
-     * @returns The value of the first node in the linked list, or undefined if the linked list is empty.
-     */
     get first() {
       var _a;
       return (_a = this.head) == null ? void 0 : _a.value;
     }
-    /**
-     * The function returns the value of the last element in a linked list, or undefined if the list is
-     * empty.
-     * @returns The value of the last node in the linked list, or undefined if the linked list is empty.
-     */
     get last() {
       var _a;
       return (_a = this.tail) == null ? void 0 : _a.value;
     }
-    /**
-     * The function returns the size of an object.
-     * @returns The size of the object, which is a number.
-     */
-    get size() {
-      return this._size;
+    get length() {
+      return this._length;
     }
     /**
      * Time Complexity: O(n)
@@ -1626,7 +2098,8 @@ var dataStructureTyped = (() => {
         this.tail.next = newNode;
         this._tail = newNode;
       }
-      this._size++;
+      this._length++;
+      if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
       return true;
     }
     /**
@@ -1643,7 +2116,7 @@ var dataStructureTyped = (() => {
         const value2 = this.head.value;
         this._head = void 0;
         this._tail = void 0;
-        this._size--;
+        this._length--;
         return value2;
       }
       let current = this.head;
@@ -1653,7 +2126,7 @@ var dataStructureTyped = (() => {
       const value = this.tail.value;
       current.next = void 0;
       this._tail = current;
-      this._size--;
+      this._length--;
       return value;
     }
     /**
@@ -1667,7 +2140,7 @@ var dataStructureTyped = (() => {
       if (!this.head) return void 0;
       const removedNode = this.head;
       this._head = this.head.next;
-      this._size--;
+      this._length--;
       return removedNode.value;
     }
     /**
@@ -1690,7 +2163,7 @@ var dataStructureTyped = (() => {
         newNode.next = this.head;
         this._head = newNode;
       }
-      this._size++;
+      this._length++;
       return true;
     }
     /**
@@ -1772,7 +2245,7 @@ var dataStructureTyped = (() => {
      * `undefined` if the index is out of bounds.
      */
     at(index) {
-      if (index < 0 || index >= this._size) return void 0;
+      if (index < 0 || index >= this._length) return void 0;
       let current = this.head;
       for (let i = 0; i < index; i++) {
         current = current.next;
@@ -1823,20 +2296,23 @@ var dataStructureTyped = (() => {
      * bounds.
      */
     deleteAt(index) {
-      if (index < 0 || index >= this._size) return false;
+      if (index < 0 || index >= this._length) return;
+      let deleted;
       if (index === 0) {
+        deleted = this.first;
         this.shift();
-        return true;
+        return deleted;
       }
-      if (index === this._size - 1) {
-        this.pop();
-        return true;
+      const targetNode = this.getNodeAt(index);
+      const prevNode = this._getPrevNode(targetNode);
+      if (prevNode && targetNode) {
+        deleted = targetNode.value;
+        prevNode.next = targetNode.next;
+        if (targetNode === this.tail) this._tail = prevNode;
+        this._length--;
+        return deleted;
       }
-      const prevNode = this.getNodeAt(index - 1);
-      const removedNode = prevNode.next;
-      prevNode.next = removedNode.next;
-      this._size--;
-      return true;
+      return;
     }
     /**
      * Time Complexity: O(n)
@@ -1849,34 +2325,19 @@ var dataStructureTyped = (() => {
      * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
      */
     delete(elementOrNode) {
-      if (elementOrNode === void 0) return false;
-      let value;
-      if (elementOrNode instanceof SinglyLinkedListNode) {
-        value = elementOrNode.value;
+      if (elementOrNode === void 0 || !this.head) return false;
+      const node = this.isNode(elementOrNode) ? elementOrNode : this.getNode(elementOrNode);
+      if (!node) return false;
+      const prevNode = this._getPrevNode(node);
+      if (!prevNode) {
+        this._head = node.next;
+        if (node === this.tail) this._tail = void 0;
       } else {
-        value = elementOrNode;
+        prevNode.next = node.next;
+        if (node === this.tail) this._tail = prevNode;
       }
-      let current = this.head, prev = void 0;
-      while (current) {
-        if (current.value === value) {
-          if (prev === void 0) {
-            this._head = current.next;
-            if (current === this.tail) {
-              this._tail = void 0;
-            }
-          } else {
-            prev.next = current.next;
-            if (current === this.tail) {
-              this._tail = prev;
-            }
-          }
-          this._size--;
-          return true;
-        }
-        prev = current;
-        current = current.next;
-      }
-      return false;
+      this._length--;
+      return true;
     }
     /**
      * Time Complexity: O(n)
@@ -1894,12 +2355,12 @@ var dataStructureTyped = (() => {
      * successfully added at the specified index, and `false` if the index is out of bounds.
      */
     addAt(index, newElementOrNode) {
-      if (index < 0 || index > this._size) return false;
+      if (index < 0 || index > this._length) return false;
       if (index === 0) {
         this.unshift(newElementOrNode);
         return true;
       }
-      if (index === this._size) {
+      if (index === this._length) {
         this.push(newElementOrNode);
         return true;
       }
@@ -1907,9 +2368,31 @@ var dataStructureTyped = (() => {
       const prevNode = this.getNodeAt(index - 1);
       newNode.next = prevNode.next;
       prevNode.next = newNode;
-      this._size++;
+      this._length++;
       return true;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function setAt(index, value) updates the value at a specified index in a data structure if the
+     * index exists.
+     * @param {number} index - The `index` parameter in the `setAt` method refers to the position in the
+     * data structure where you want to set a new value.
+     * @param {E} value - The `value` parameter in the `setAt` method represents the new value that you
+     * want to set at the specified index in the data structure.
+     * @returns The `setAt` method returns a boolean value - `true` if the value at the specified index
+     * is successfully updated, and `false` if the index is out of bounds (i.e., the node at that index
+     * does not exist).
+     */
+    setAt(index, value) {
+      const node = this.getNodeAt(index);
+      if (node) {
+        node.value = value;
+        return true;
+      }
+      return false;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -1919,7 +2402,7 @@ var dataStructureTyped = (() => {
      * @returns A boolean value indicating whether the length of the object is equal to 0.
      */
     isEmpty() {
-      return this._size === 0;
+      return this._length === 0;
     }
     /**
      * Time Complexity: O(1)
@@ -1930,23 +2413,7 @@ var dataStructureTyped = (() => {
     clear() {
       this._head = void 0;
       this._tail = void 0;
-      this._size = 0;
-    }
-    /**
-     * 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[]`.
-     */
-    toArray() {
-      const array = [];
-      let current = this.head;
-      while (current) {
-        array.push(current.value);
-        current = current.next;
-      }
-      return array;
+      this._length = 0;
     }
     /**
      * Time Complexity: O(n)
@@ -1969,32 +2436,6 @@ var dataStructureTyped = (() => {
       [this._head, this._tail] = [this.tail, this.head];
       return this;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `indexOf` function in TypeScript searches for a specific element or node in a singly linked
-     * list and returns its index if found.
-     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `indexOf` method can be one
-     * of the following types:
-     * @returns The `indexOf` method returns the index of the first occurrence of the element that
-     * matches the provided predicate in the singly linked list. If no matching element is found, it
-     * returns -1.
-     */
-    indexOf(elementNodeOrPredicate) {
-      const predicate = this._ensurePredicate(elementNodeOrPredicate);
-      let index = 0;
-      let current = this.head;
-      while (current) {
-        if (predicate(current)) {
-          return index;
-        }
-        index++;
-        current = current.next;
-      }
-      return -1;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -2010,6 +2451,7 @@ var dataStructureTyped = (() => {
      */
     getNode(elementNodeOrPredicate) {
       if (elementNodeOrPredicate === void 0) return;
+      if (this.isNode(elementNodeOrPredicate)) return elementNodeOrPredicate;
       const predicate = this._ensurePredicate(elementNodeOrPredicate);
       let current = this.head;
       while (current) {
@@ -2033,33 +2475,22 @@ var dataStructureTyped = (() => {
      * element or node in the linked list. This new element can be of type `E` or a
      * `SinglyLinkedListNode<E>`.
      * @returns The `addBefore` method returns a boolean value - `true` if the new element or node was
-     * successfully added before the existing element or node, and `false` if the operation was
-     * unsuccessful.
-     */
-    addBefore(existingElementOrNode, newElementOrNode) {
-      if (!this.head) return false;
-      let existingValue;
-      if (this.isNode(existingElementOrNode)) {
-        existingValue = existingElementOrNode.value;
-      } else {
-        existingValue = existingElementOrNode;
-      }
-      if (this.head.value === existingValue) {
-        this.unshift(newElementOrNode);
-        return true;
-      }
-      let current = this.head;
-      while (current.next) {
-        if (current.next.value === existingValue) {
-          const newNode = this._ensureNode(newElementOrNode);
-          newNode.next = current.next;
-          current.next = newNode;
-          this._size++;
-          return true;
-        }
-        current = current.next;
+     * successfully added before the existing element or node, and `false` if the operation was
+     * unsuccessful.
+     */
+    addBefore(existingElementOrNode, newElementOrNode) {
+      const existingNode = this.getNode(existingElementOrNode);
+      if (!existingNode) return false;
+      const prevNode = this._getPrevNode(existingNode);
+      const newNode = this._ensureNode(newElementOrNode);
+      if (!prevNode) {
+        this.unshift(newNode);
+      } else {
+        prevNode.next = newNode;
+        newNode.next = existingNode;
+        this._length++;
       }
-      return false;
+      return true;
     }
     /**
      * Time Complexity: O(n)
@@ -2086,11 +2517,67 @@ var dataStructureTyped = (() => {
         if (existingNode === this.tail) {
           this._tail = newNode;
         }
-        this._size++;
+        this._length++;
         return true;
       }
       return false;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `splice` in TypeScript overrides the default behavior to remove and insert elements
+     * in a singly linked list while handling boundary cases.
+     * @param {number} start - The `start` parameter in the `splice` method indicates the index at which
+     * to start modifying the list. It specifies the position where elements will be added or removed.
+     * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
+     * number of elements to remove from the array starting at the specified `start` index. If
+     * `deleteCount` is not provided, it defaults to 0, meaning no elements will be removed but new
+     * elements can still be inserted at
+     * @param {E[]} items - The `items` parameter in the `splice` method represents the elements to be
+     * inserted into the list at the specified `start` index. These elements will be inserted in place of
+     * the elements that are removed from the list. The `splice` method allows you to add new elements to
+     * the list while
+     * @returns The `splice` method is returning a `SinglyLinkedList` containing the elements that were
+     * removed from the original list during the splice operation.
+     */
+    splice(start, deleteCount = 0, ...items) {
+      const removedList = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+      start = Math.max(0, Math.min(start, this.length));
+      deleteCount = Math.max(0, deleteCount);
+      const prevNode = start === 0 ? void 0 : this.getNodeAt(start - 1);
+      const startNode = prevNode ? prevNode.next : this.head;
+      let current = startNode;
+      for (let i = 0; i < deleteCount && current; i++) {
+        removedList.push(current.value);
+        current = current.next;
+      }
+      const nextNode = current;
+      let lastInsertedNode = void 0;
+      for (const item of items) {
+        const newNode = this._ensureNode(item);
+        if (!lastInsertedNode) {
+          if (prevNode) {
+            prevNode.next = newNode;
+          } else {
+            this._head = newNode;
+          }
+        } else {
+          lastInsertedNode.next = newNode;
+        }
+        lastInsertedNode = newNode;
+      }
+      if (lastInsertedNode) {
+        lastInsertedNode.next = nextNode;
+      } else if (prevNode) {
+        prevNode.next = nextNode;
+      }
+      if (!nextNode) {
+        this._tail = lastInsertedNode || prevNode;
+      }
+      this._length += items.length - removedList.length;
+      return removedList;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -2124,7 +2611,7 @@ var dataStructureTyped = (() => {
      * is a clone of the original list.
      */
     clone() {
-      return new _SinglyLinkedList(this, { toElementFn: this.toElementFn });
+      return new _SinglyLinkedList(this, { toElementFn: this.toElementFn, maxLen: this._maxLen });
     }
     /**
      * Time Complexity: O(n)
@@ -2144,7 +2631,7 @@ var dataStructureTyped = (() => {
      * elements that pass the filter condition specified by the `callback` function.
      */
     filter(callback, thisArg) {
-      const filteredList = new _SinglyLinkedList([], { toElementFn: this.toElementFn });
+      const filteredList = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
       let index = 0;
       for (const current of this) {
         if (callback.call(thisArg, current, index, this)) {
@@ -2175,7 +2662,7 @@ var dataStructureTyped = (() => {
      * @returns a new instance of the `SinglyLinkedList` class with the mapped elements.
      */
     map(callback, toElementFn, thisArg) {
-      const mappedList = new _SinglyLinkedList([], { toElementFn });
+      const mappedList = new _SinglyLinkedList([], { toElementFn, maxLen: this._maxLen });
       let index = 0;
       for (const current of this) {
         mappedList.push(callback.call(thisArg, current, index, this));
@@ -2183,6 +2670,19 @@ var dataStructureTyped = (() => {
       }
       return mappedList;
     }
+    /**
+     * The function `_createInstance` returns a new instance of `SinglyLinkedList` with the specified
+     * options.
+     * @param [options] - The `options` parameter in the `_createInstance` method is of type
+     * `SinglyLinkedListOptions<E, R>`, which is used to configure the behavior of the `SinglyLinkedList`
+     * instance being created. It is an optional parameter, meaning it can be omitted when calling the
+     * method.
+     * @returns An instance of the `SinglyLinkedList` class with an empty array and the provided options
+     * is being returned.
+     */
+    _createInstance(options) {
+      return new _SinglyLinkedList([], options);
+    }
     /**
      * The function `_getIterator` returns an iterable iterator that yields the values of a linked list.
      */
@@ -2193,6 +2693,33 @@ var dataStructureTyped = (() => {
         current = current.next;
       }
     }
+    /**
+     * The function returns an iterator that iterates over the elements of a collection in reverse order.
+     */
+    *_getReverseIterator() {
+      const reversedArr = [...this].reverse();
+      for (const item of reversedArr) {
+        yield item;
+      }
+    }
+    /**
+     * The function `_getNodeIterator` returns an iterator that iterates over the nodes of a singly
+     * linked list.
+     */
+    *_getNodeIterator() {
+      let current = this.head;
+      while (current) {
+        yield current;
+        current = current.next;
+      }
+    }
+    // protected *_getReverseNodeIterator(): IterableIterator<SinglyLinkedListNode<E>> {
+    //   const reversedArr = [...this._getNodeIterator()].reverse();
+    //
+    //   for (const item of reversedArr) {
+    //     yield item;
+    //   }
+    // }
     /**
      * The _isPredicate function in TypeScript checks if the input is a function that takes a
      * SinglyLinkedListNode as an argument and returns a boolean.
@@ -2232,73 +2759,54 @@ var dataStructureTyped = (() => {
       if (this._isPredicate(elementNodeOrPredicate)) return elementNodeOrPredicate;
       return (node) => node.value === elementNodeOrPredicate;
     }
+    /**
+     * The function `_getPrevNode` returns the node before a given node in a singly linked list.
+     * @param node - The `node` parameter in the `_getPrevNode` method is a reference to a node in a
+     * singly linked list. The method is used to find the node that comes before the given node in the
+     * linked list.
+     * @returns The `_getPrevNode` method returns either the previous node of the input node in a singly
+     * linked list or `undefined` if the input node is the head of the list or if the input node is not
+     * found in the list.
+     */
+    _getPrevNode(node) {
+      if (!this.head || this.head === node) return void 0;
+      let current = this.head;
+      while (current.next && current.next !== node) {
+        current = current.next;
+      }
+      return current.next === node ? current : void 0;
+    }
   };
 
   // src/data-structures/linked-list/doubly-linked-list.ts
-  var DoublyLinkedListNode = class {
+  var DoublyLinkedListNode = class extends LinkedListNode {
     /**
      * The constructor function initializes the value, next, and previous properties of an object.
      * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
      * is defined as a generic type "E".
      */
     constructor(value) {
-      __publicField(this, "_value");
+      super(value);
       __publicField(this, "_next");
       __publicField(this, "_prev");
       this._value = value;
       this._next = void 0;
       this._prev = void 0;
     }
-    /**
-     * The function returns the value of a protected variable.
-     * @returns The value of the variable `_value` is being returned.
-     */
-    get value() {
-      return this._value;
-    }
-    /**
-     * The above function sets the value of a variable.
-     * @param {E} value - The parameter "value" is of type E, which means it can be any type.
-     */
-    set value(value) {
-      this._value = value;
-    }
-    /**
-     * The "next" function returns the next node in a doubly linked list.
-     * @returns The `next` property is being returned. It can be either a `DoublyLinkedListNode<E>`
-     * object or `undefined`.
-     */
     get next() {
       return this._next;
     }
-    /**
-     * The "next" property of a DoublyLinkedListNode is set to the provided value.
-     * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
-     * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
-     * `DoublyLinkedListNode` object or `undefined` as its value.
-     */
     set next(value) {
       this._next = value;
     }
-    /**
-     * The `prev` function returns the previous node in a doubly linked list.
-     * @returns The `prev` property of the `DoublyLinkedListNode` class is being returned. It can either
-     * be a `DoublyLinkedListNode` object or `undefined`.
-     */
     get prev() {
       return this._prev;
     }
-    /**
-     * The function sets the previous node of a doubly linked list node.
-     * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
-     * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
-     * `DoublyLinkedListNode` object or `undefined` as its value.
-     */
     set prev(value) {
       this._prev = value;
     }
   };
-  var DoublyLinkedList = class _DoublyLinkedList extends IterableElementBase {
+  var DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     /**
      * This TypeScript constructor initializes a DoublyLinkedList with optional elements and options.
      * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the constructor is an
@@ -2313,33 +2821,24 @@ var dataStructureTyped = (() => {
       super(options);
       __publicField(this, "_head");
       __publicField(this, "_tail");
-      __publicField(this, "_size");
+      __publicField(this, "_length");
       this._head = void 0;
       this._tail = void 0;
-      this._size = 0;
+      this._length = 0;
+      if (options) {
+        const { maxLen } = options;
+        if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+      }
       this.pushMany(elements);
     }
-    /**
-     * 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;
+    get length() {
+      return this._length;
     }
     /**
      * Time Complexity: O(1)
@@ -2411,7 +2910,8 @@ var dataStructureTyped = (() => {
         this.tail.next = newNode;
         this._tail = newNode;
       }
-      this._size++;
+      this._length++;
+      if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
       return true;
     }
     /**
@@ -2431,7 +2931,7 @@ var dataStructureTyped = (() => {
         this._tail = removedNode.prev;
         this.tail.next = void 0;
       }
-      this._size--;
+      this._length--;
       return removedNode.value;
     }
     /**
@@ -2451,7 +2951,7 @@ var dataStructureTyped = (() => {
         this._head = removedNode.next;
         this.head.prev = void 0;
       }
-      this._size--;
+      this._length--;
       return removedNode.value;
     }
     /**
@@ -2474,7 +2974,8 @@ var dataStructureTyped = (() => {
         this.head.prev = newNode;
         this._head = newNode;
       }
-      this._size++;
+      this._length++;
+      if (this._maxLen > 0 && this._length > this._maxLen) this.pop();
       return true;
     }
     /**
@@ -2537,7 +3038,7 @@ var dataStructureTyped = (() => {
      * or the linked list is empty, it will return undefined.
      */
     at(index) {
-      if (index < 0 || index >= this._size) return void 0;
+      if (index < 0 || index >= this._length) return void 0;
       let current = this.head;
       for (let i = 0; i < index; i++) {
         current = current.next;
@@ -2556,7 +3057,7 @@ var dataStructureTyped = (() => {
      * valid range of the linked list, otherwise it returns `undefined`.
      */
     getNodeAt(index) {
-      if (index < 0 || index >= this._size) return void 0;
+      if (index < 0 || index >= this._length) return void 0;
       let current = this.head;
       for (let i = 0; i < index; i++) {
         current = current.next;
@@ -2583,6 +3084,7 @@ var dataStructureTyped = (() => {
      */
     getNode(elementNodeOrPredicate) {
       if (elementNodeOrPredicate === void 0) return;
+      if (this.isNode(elementNodeOrPredicate)) return elementNodeOrPredicate;
       const predicate = this._ensurePredicate(elementNodeOrPredicate);
       let current = this.head;
       while (current) {
@@ -2605,15 +3107,15 @@ var dataStructureTyped = (() => {
      * `addAt` method can be either a value of type `E` or a `DoublyLinkedListNode<E>` object.
      * @returns The `addAt` method returns a boolean value. It returns `true` if the element or node was
      * successfully added at the specified index, and `false` if the index is out of bounds (less than 0
-     * or greater than the size of the list).
+     * or greater than the length of the list).
      */
     addAt(index, newElementOrNode) {
-      if (index < 0 || index > this._size) return false;
+      if (index < 0 || index > this._length) return false;
       if (index === 0) {
         this.unshift(newElementOrNode);
         return true;
       }
-      if (index === this._size) {
+      if (index === this._length) {
         this.push(newElementOrNode);
         return true;
       }
@@ -2624,7 +3126,7 @@ var dataStructureTyped = (() => {
       newNode.next = nextNode;
       prevNode.next = newNode;
       nextNode.prev = newNode;
-      this._size++;
+      this._length++;
       return true;
     }
     /**
@@ -2655,7 +3157,7 @@ var dataStructureTyped = (() => {
         if (existingNode === this.head) {
           this._head = newNode;
         }
-        this._size++;
+        this._length++;
         return true;
       }
       return false;
@@ -2689,7 +3191,28 @@ var dataStructureTyped = (() => {
         if (existingNode === this.tail) {
           this._tail = newNode;
         }
-        this._size++;
+        this._length++;
+        return true;
+      }
+      return false;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `setAt` updates the value at a specified index in a data structure if the index
+     * exists.
+     * @param {number} index - The `index` parameter in the `setAt` method refers to the position in the
+     * data structure where you want to set a new value.
+     * @param {E} value - The `value` parameter in the `setAt` method represents the new value that you
+     * want to set at the specified index in the data structure.
+     * @returns The `setAt` method returns a boolean value - `true` if the value at the specified index
+     * is successfully updated, and `false` if the index is out of bounds.
+     */
+    setAt(index, value) {
+      const node = this.getNodeAt(index);
+      if (node) {
+        node.value = value;
         return true;
       }
       return false;
@@ -2705,22 +3228,25 @@ var dataStructureTyped = (() => {
      * bounds.
      */
     deleteAt(index) {
-      if (index < 0 || index >= this._size) return false;
+      if (index < 0 || index >= this._length) return;
+      let deleted;
       if (index === 0) {
+        deleted = this.first;
         this.shift();
-        return true;
+        return deleted;
       }
-      if (index === this._size - 1) {
+      if (index === this._length - 1) {
+        deleted = this.last;
         this.pop();
-        return true;
+        return deleted;
       }
       const removedNode = this.getNodeAt(index);
       const prevNode = removedNode.prev;
       const nextNode = removedNode.next;
       prevNode.next = nextNode;
       nextNode.prev = prevNode;
-      this._size--;
-      return true;
+      this._length--;
+      return removedNode == null ? void 0 : removedNode.value;
     }
     /**
      * Time Complexity: O(1) or O(n)
@@ -2747,7 +3273,7 @@ var dataStructureTyped = (() => {
           const nextNode = node.next;
           if (prevNode) prevNode.next = nextNode;
           if (nextNode) nextNode.prev = prevNode;
-          this._size--;
+          this._length--;
         }
         return true;
       }
@@ -2757,46 +3283,22 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function checks if a variable has a size greater than zero and returns a boolean value.
+     * The function checks if a variable has a length greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
      */
     isEmpty() {
-      return this._size === 0;
+      return this._length === 0;
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `clear` function resets the linked list by setting the head, tail, and size to undefined and 0 respectively.
+     * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
      */
     clear() {
       this._head = void 0;
       this._tail = void 0;
-      this._size = 0;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * This function finds the index of a specified element, node, or predicate in a doubly linked list.
-     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-     * elementNodeOrPredicate - The `indexOf` method takes in a parameter `elementNodeOrPredicate`, which
-     * can be one of the following:
-     * @returns The `indexOf` method returns the index of the element in the doubly linked list that
-     * matches the provided element, node, or predicate. If no match is found, it returns -1.
-     */
-    indexOf(elementNodeOrPredicate) {
-      const predicate = this._ensurePredicate(elementNodeOrPredicate);
-      let index = 0;
-      let current = this.head;
-      while (current) {
-        if (predicate(current)) {
-          return index;
-        }
-        index++;
-        current = current.next;
-      }
-      return -1;
+      this._length = 0;
     }
     /**
      * Time Complexity: O(n)
@@ -2857,38 +3359,6 @@ var dataStructureTyped = (() => {
       }
       return this;
     }
-    /**
-     * 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[]`.
-     */
-    toArray() {
-      const array = [];
-      let current = this.head;
-      while (current) {
-        array.push(current.value);
-        current = current.next;
-      }
-      return array;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `toReversedArray` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toReversedArray()` function returns an array of type `E[]`.
-     */
-    toReversedArray() {
-      const array = [];
-      let current = this.tail;
-      while (current) {
-        array.push(current.value);
-        current = current.prev;
-      }
-      return array;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -2899,7 +3369,7 @@ var dataStructureTyped = (() => {
      * is a copy of the original list.
      */
     clone() {
-      return new _DoublyLinkedList(this);
+      return new _DoublyLinkedList(this, { toElementFn: this._toElementFn, maxLen: this._maxLen });
     }
     /**
      * Time Complexity: O(n)
@@ -2919,7 +3389,7 @@ var dataStructureTyped = (() => {
      * elements that pass the filter condition specified by the `callback` function.
      */
     filter(callback, thisArg) {
-      const filteredList = new _DoublyLinkedList([], { toElementFn: this.toElementFn });
+      const filteredList = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
       let index = 0;
       for (const current of this) {
         if (callback.call(thisArg, current, index, this)) {
@@ -2950,7 +3420,7 @@ var dataStructureTyped = (() => {
      * @returns a new instance of the `DoublyLinkedList` class with elements of type `T` and `RR`.
      */
     map(callback, toElementFn, thisArg) {
-      const mappedList = new _DoublyLinkedList([], { toElementFn });
+      const mappedList = new _DoublyLinkedList([], { toElementFn, maxLen: this._maxLen });
       let index = 0;
       for (const current of this) {
         mappedList.push(callback.call(thisArg, current, index, this));
@@ -2991,6 +3461,35 @@ var dataStructureTyped = (() => {
         current = current.next;
       }
     }
+    /**
+     * The function returns an iterator that iterates over the elements of a data structure in reverse
+     * order.
+     */
+    *_getReverseIterator() {
+      let current = this.tail;
+      while (current) {
+        yield current.value;
+        current = current.prev;
+      }
+    }
+    /**
+     * The function returns an iterator that iterates over the nodes of a doubly linked list starting
+     * from the head.
+     */
+    *_getNodeIterator() {
+      let current = this.head;
+      while (current) {
+        yield current;
+        current = current.next;
+      }
+    }
+    // protected *_getReverseNodeIterator(): IterableIterator<DoublyLinkedListNode<E>> {
+    //   const reversedArr = [...this._getNodeIterator()].reverse();
+    //
+    //   for (const item of reversedArr) {
+    //     yield item;
+    //   }
+    // }
     /**
      * The function `_isPredicate` checks if the input is a function that takes a `DoublyLinkedListNode`
      * as an argument and returns a boolean.
@@ -3030,6 +3529,30 @@ var dataStructureTyped = (() => {
       if (this._isPredicate(elementNodeOrPredicate)) return elementNodeOrPredicate;
       return (node) => node.value === elementNodeOrPredicate;
     }
+    /**
+     * The function `_createInstance` returns a new instance of `DoublyLinkedList` with the specified
+     * options.
+     * @param [options] - The `options` parameter in the `_createInstance` method is of type
+     * `DoublyLinkedListOptions<E, R>`. It is an optional parameter that allows you to pass additional
+     * configuration options when creating a new instance of the `DoublyLinkedList` class.
+     * @returns An instance of the `DoublyLinkedList` class with an empty array and the provided options
+     * is being returned, cast as the current class type.
+     */
+    _createInstance(options) {
+      return new _DoublyLinkedList([], options);
+    }
+    /**
+     * The function `_getPrevNode` returns the previous node of a given node in a doubly linked list.
+     * @param node - The parameter `node` in the `_getPrevNode` method is of type
+     * `DoublyLinkedListNode<E>`, which represents a node in a doubly linked list containing an element
+     * of type `E`.
+     * @returns The `_getPrevNode` method is returning the previous node of the input `node` in a doubly
+     * linked list. If the input node has a previous node, it will return that node. Otherwise, it will
+     * return `undefined`.
+     */
+    _getPrevNode(node) {
+      return node.prev;
+    }
   };
 
   // src/data-structures/linked-list/skip-linked-list.ts
@@ -3394,16 +3917,6 @@ var dataStructureTyped = (() => {
       const spliced = this.elements.splice(index, 1);
       return spliced.length === 1;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The toArray function returns a copy of the elements in an array.
-     * @returns An array of type E.
-     */
-    toArray() {
-      return this.elements.slice();
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -3491,7 +4004,7 @@ var dataStructureTyped = (() => {
   };
 
   // src/data-structures/queue/queue.ts
-  var Queue = class _Queue extends IterableElementBase {
+  var Queue = class _Queue extends LinearBase {
     constructor(elements = [], options) {
       super(options);
       __publicField(this, "_elements", []);
@@ -3503,37 +4016,31 @@ var dataStructureTyped = (() => {
       }
       this.pushMany(elements);
     }
-    /**
-     * 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 protected variable _offset
-     */
     get offset() {
       return this._offset;
     }
-    /**
-     * The size function returns the number of elements in an array.
-     * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
-     */
-    get size() {
+    get length() {
       return this.elements.length - this.offset;
     }
+    get autoCompactRatio() {
+      return this._autoCompactRatio;
+    }
+    set autoCompactRatio(v) {
+      this._autoCompactRatio = v;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
      * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
-     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
+     * the `_offset` index. If the data structure is empty (length is 0), it returns `undefined`.
      */
     get first() {
-      return this.size > 0 ? this.elements[this.offset] : void 0;
+      return this.length > 0 ? this.elements[this.offset] : void 0;
     }
     /**
      * Time Complexity: O(1)
@@ -3544,22 +4051,7 @@ var dataStructureTyped = (() => {
      * array is empty, it returns `undefined`.
      */
     get last() {
-      return this.size > 0 ? this.elements[this.elements.length - 1] : void 0;
-    }
-    /**
-     * This function returns the value of the autoCompactRatio property.
-     * @returns The `autoCompactRatio` property of the object, which is a number.
-     */
-    get autoCompactRatio() {
-      return this._autoCompactRatio;
-    }
-    /**
-     * The above function sets the autoCompactRatio property to a specified number in TypeScript.
-     * @param {number} v - The parameter `v` represents the value that will be assigned to the
-     * `_autoCompactRatio` property.
-     */
-    set autoCompactRatio(v) {
-      this._autoCompactRatio = v;
+      return this.length > 0 ? this.elements[this.elements.length - 1] : void 0;
     }
     /**
      * Time Complexity: O(n)
@@ -3584,6 +4076,7 @@ var dataStructureTyped = (() => {
      */
     push(element) {
       this.elements.push(element);
+      if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
       return true;
     }
     /**
@@ -3614,7 +4107,7 @@ var dataStructureTyped = (() => {
      * @returns The function `shift()` returns either the first element in the queue or `undefined` if the queue is empty.
      */
     shift() {
-      if (this.size === 0) return void 0;
+      if (this.length === 0) return void 0;
       const first = this.first;
       this._offset += 1;
       if (this.offset / this.elements.length > this.autoCompactRatio) this.compact();
@@ -3630,7 +4123,7 @@ var dataStructureTyped = (() => {
      */
     delete(element) {
       const index = this.elements.indexOf(element);
-      return this.deleteAt(index);
+      return !!this.deleteAt(index);
     }
     /**
      * Time Complexity: O(n)
@@ -3641,8 +4134,9 @@ var dataStructureTyped = (() => {
      * @return A boolean value
      */
     deleteAt(index) {
-      const spliced = this.elements.splice(index, 1);
-      return spliced.length === 1;
+      const deleted = this.elements[index];
+      this.elements.splice(index, 1);
+      return deleted;
     }
     /**
      * Time Complexity: O(1)
@@ -3658,25 +4152,66 @@ var dataStructureTyped = (() => {
     at(index) {
       return this.elements[index + this._offset];
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `reverse` function in TypeScript reverses the elements of an array starting from a specified
+     * offset.
+     * @returns The `reverse()` method is returning the modified object itself (`this`) after reversing
+     * the elements in the array and resetting the offset to 0.
+     */
+    reverse() {
+      this._elements = this.elements.slice(this.offset).reverse();
+      this._offset = 0;
+      return this;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `addAt` inserts a new element at a specified index in an array, returning true if
+     * successful and false if the index is out of bounds.
+     * @param {number} index - The `index` parameter represents the position at which the `newElement`
+     * should be added in the array.
+     * @param {E} newElement - The `newElement` parameter represents the element that you want to insert
+     * into the array at the specified index.
+     * @returns The `addAt` method returns a boolean value - `true` if the new element was successfully
+     * added at the specified index, and `false` if the index is out of bounds (less than 0 or greater
+     * than the length of the array).
+     */
+    addAt(index, newElement) {
+      if (index < 0 || index > this.length) return false;
+      this._elements.splice(this.offset + index, 0, newElement);
+      return true;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function checks if a data structure is empty by comparing its size to zero.
-     * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
+     * The function `setAt` updates an element at a specified index in an array-like data structure.
+     * @param {number} index - The `index` parameter is a number that represents the position in the
+     * array where the new element will be set.
+     * @param {E} newElement - The `newElement` parameter represents the new value that you want to set
+     * at the specified index in the array.
+     * @returns The `setAt` method returns a boolean value - `true` if the element was successfully set
+     * at the specified index, and `false` if the index is out of bounds (less than 0 or greater than the
+     * length of the array).
      */
-    isEmpty() {
-      return this.size === 0;
+    setAt(index, newElement) {
+      if (index < 0 || index > this.length) return false;
+      this._elements[this.offset + index] = newElement;
+      return true;
     }
     /**
      * Time Complexity: O(1)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      *
-     * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
-     * @returns An array of type E is being returned.
+     * The function checks if a data structure is empty by comparing its length to zero.
+     * @returns {boolean} A boolean value indicating whether the length of the object is 0 or not.
      */
-    toArray() {
-      return this.elements.slice(this.offset);
+    isEmpty() {
+      return this.length === 0;
     }
     /**
      * Time Complexity: O(1)
@@ -3701,6 +4236,34 @@ var dataStructureTyped = (() => {
       this._offset = 0;
       return true;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function overrides the splice method to remove and insert elements in a queue-like data
+     * structure.
+     * @param {number} start - The `start` parameter in the `splice` method specifies the index at which
+     * to start changing the array. Items will be added or removed starting from this index.
+     * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
+     * number of elements to remove from the array starting at the specified `start` index. If
+     * `deleteCount` is not provided, it defaults to 0, meaning no elements will be removed but new
+     * elements can still be inserted at
+     * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+     * will be added to the array at the specified `start` index. These elements will replace the
+     * existing elements starting from the `start` index for the `deleteCount` number of elements.
+     * @returns The `splice` method is returning the `removedQueue`, which is an instance of the same
+     * class as the original object.
+     */
+    splice(start, deleteCount = 0, ...items) {
+      const removedQueue = this._createInstance();
+      start = Math.max(0, Math.min(start, this.length));
+      deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+      const globalStartIndex = this.offset + start;
+      const removedElements = this._elements.splice(globalStartIndex, deleteCount, ...items);
+      removedQueue.pushMany(removedElements);
+      this.compact();
+      return removedQueue;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -3709,7 +4272,7 @@ var dataStructureTyped = (() => {
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     clone() {
-      return new _Queue(this.elements.slice(this.offset), { toElementFn: this.toElementFn });
+      return new _Queue(this.elements.slice(this.offset), { toElementFn: this.toElementFn, maxLen: this._maxLen });
     }
     /**
      * Time Complexity: O(n)
@@ -3728,7 +4291,11 @@ var dataStructureTyped = (() => {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-      const newDeque = new _Queue([], { toElementFn: this.toElementFn });
+      const newDeque = this._createInstance({
+        toElementFn: this._toElementFn,
+        autoCompactRatio: this._autoCompactRatio,
+        maxLen: this._maxLen
+      });
       let index = 0;
       for (const el of this) {
         if (predicate.call(thisArg, el, index, this)) {
@@ -3757,7 +4324,11 @@ var dataStructureTyped = (() => {
      * callback function to each element in the original Queue object.
      */
     map(callback, toElementFn, thisArg) {
-      const newDeque = new _Queue([], { toElementFn });
+      const newDeque = new _Queue([], {
+        toElementFn,
+        autoCompactRatio: this._autoCompactRatio,
+        maxLen: this._maxLen
+      });
       let index = 0;
       for (const el of this) {
         newDeque.push(callback.call(thisArg, el, index, this));
@@ -3771,9 +4342,31 @@ var dataStructureTyped = (() => {
      *
      * The function `_getIterator` returns an iterable iterator for the elements in the class.
      */
-    *_getIterator() {
-      for (const item of this.elements.slice(this.offset)) {
-        yield item;
+    *_getIterator() {
+      for (const item of this.elements.slice(this.offset)) {
+        yield item;
+      }
+    }
+    /**
+     * The function `_createInstance` returns a new instance of the `Queue` class with the specified
+     * options.
+     * @param [options] - The `options` parameter in the `_createInstance` method is of type
+     * `QueueOptions<E, R>`, which is used to configure the behavior of the queue being created. It
+     * allows you to specify settings or properties that can influence how the queue operates.
+     * @returns An instance of the `Queue` class with an empty array and the provided options is being
+     * returned.
+     */
+    _createInstance(options) {
+      return new _Queue([], options);
+    }
+    /**
+     * The function `_getReverseIterator` returns an iterator that iterates over elements in reverse
+     * order.
+     */
+    *_getReverseIterator() {
+      for (let i = this.length - 1; i >= 0; i--) {
+        const cur = this.at(i);
+        if (cur !== void 0) yield cur;
       }
     }
   };
@@ -3787,12 +4380,12 @@ var dataStructureTyped = (() => {
      * values as the original `LinkedListQueue`.
      */
     clone() {
-      return new _LinkedListQueue(this, { toElementFn: this.toElementFn });
+      return new _LinkedListQueue(this, { toElementFn: this.toElementFn, maxLen: this._maxLen });
     }
   };
 
   // src/data-structures/queue/deque.ts
-  var Deque = class _Deque extends IterableElementBase {
+  var Deque = class _Deque extends LinearBase {
     /**
      * The constructor initializes a Deque object with optional iterable of elements and options.
      * @param elements - An iterable object (such as an array or a Set) that contains the initial
@@ -3807,18 +4400,16 @@ var dataStructureTyped = (() => {
     constructor(elements = [], options) {
       super(options);
       __publicField(this, "_bucketSize", 1 << 12);
-      __publicField(this, "_maxLen", -1);
       __publicField(this, "_bucketFirst", 0);
       __publicField(this, "_firstInBucket", 0);
       __publicField(this, "_bucketLast", 0);
       __publicField(this, "_lastInBucket", 0);
       __publicField(this, "_bucketCount", 0);
       __publicField(this, "_buckets", []);
-      __publicField(this, "_size", 0);
+      __publicField(this, "_length", 0);
       if (options) {
-        const { bucketSize, maxLen } = options;
+        const { bucketSize } = options;
         if (typeof bucketSize === "number") this._bucketSize = bucketSize;
-        if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
       }
       let _size;
       if ("length" in elements) {
@@ -3837,72 +4428,29 @@ var dataStructureTyped = (() => {
       this._firstInBucket = this._lastInBucket = this._bucketSize - _size % this._bucketSize >> 1;
       this.pushMany(elements);
     }
-    /**
-     * The bucketSize function returns the size of the bucket.
-     *
-     * @return The size of the bucket
-     */
     get bucketSize() {
       return this._bucketSize;
     }
-    /**
-     * The maxLen function returns the max length of the deque.
-     *
-     * @return The max length of the deque
-     */
-    get maxLen() {
-      return this._maxLen;
-    }
-    /**
-     * The function returns the value of the protected variable `_bucketFirst`.
-     * @returns The value of the `_bucketFirst` property.
-     */
     get bucketFirst() {
       return this._bucketFirst;
     }
-    /**
-     * The function returns the value of the protected variable _firstInBucket.
-     * @returns The method is returning the value of the variable `_firstInBucket`, which is of type
-     * `number`.
-     */
     get firstInBucket() {
       return this._firstInBucket;
     }
-    /**
-     * The function returns the value of the protected variable `_bucketLast`.
-     * @returns The value of the `_bucketLast` property, which is a number.
-     */
     get bucketLast() {
       return this._bucketLast;
     }
-    /**
-     * The function returns the value of the protected variable _lastInBucket.
-     * @returns The method is returning the value of the variable `_lastInBucket`, which is of type
-     * `number`.
-     */
     get lastInBucket() {
       return this._lastInBucket;
     }
-    /**
-     * The function returns the number of buckets.
-     * @returns The number of buckets.
-     */
     get bucketCount() {
       return this._bucketCount;
     }
-    /**
-     * 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;
+    get length() {
+      return this._length;
     }
     /**
      * The function returns the first element in a collection if it exists, otherwise it returns
@@ -3910,7 +4458,7 @@ var dataStructureTyped = (() => {
      * @returns The first element of the collection, of type E, is being returned.
      */
     get first() {
-      if (this._size === 0) return;
+      if (this._length === 0) return;
       return this._buckets[this._bucketFirst][this._firstInBucket];
     }
     /**
@@ -3918,7 +4466,7 @@ var dataStructureTyped = (() => {
      * @return The last element in the array
      */
     get last() {
-      if (this._size === 0) return;
+      if (this._length === 0) return;
       return this._buckets[this._bucketLast][this._lastInBucket];
     }
     /**
@@ -3931,7 +4479,7 @@ var dataStructureTyped = (() => {
      * @returns The size of the data structure after the element has been pushed.
      */
     push(element) {
-      if (this._size) {
+      if (this._length) {
         if (this._lastInBucket < this._bucketSize - 1) {
           this._lastInBucket += 1;
         } else if (this._bucketLast < this._bucketCount - 1) {
@@ -3943,9 +4491,9 @@ var dataStructureTyped = (() => {
         }
         if (this._bucketLast === this._bucketFirst && this._lastInBucket === this._firstInBucket) this._reallocate();
       }
-      this._size += 1;
+      this._length += 1;
       this._buckets[this._bucketLast][this._lastInBucket] = element;
-      if (this._maxLen > 0 && this._size > this._maxLen) this.shift();
+      if (this._maxLen > 0 && this._length > this._maxLen) this.shift();
       return true;
     }
     /**
@@ -3957,9 +4505,9 @@ var dataStructureTyped = (() => {
      * @returns The element that was removed from the data structure is being returned.
      */
     pop() {
-      if (this._size === 0) return;
+      if (this._length === 0) return;
       const element = this._buckets[this._bucketLast][this._lastInBucket];
-      if (this._size !== 1) {
+      if (this._length !== 1) {
         if (this._lastInBucket > 0) {
           this._lastInBucket -= 1;
         } else if (this._bucketLast > 0) {
@@ -3970,7 +4518,7 @@ var dataStructureTyped = (() => {
           this._lastInBucket = this._bucketSize - 1;
         }
       }
-      this._size -= 1;
+      this._length -= 1;
       return element;
     }
     /**
@@ -3983,9 +4531,9 @@ var dataStructureTyped = (() => {
      * returned.
      */
     shift() {
-      if (this._size === 0) return;
+      if (this._length === 0) return;
       const element = this._buckets[this._bucketFirst][this._firstInBucket];
-      if (this._size !== 1) {
+      if (this._length !== 1) {
         if (this._firstInBucket < this._bucketSize - 1) {
           this._firstInBucket += 1;
         } else if (this._bucketFirst < this._bucketCount - 1) {
@@ -3996,7 +4544,7 @@ var dataStructureTyped = (() => {
           this._firstInBucket = 0;
         }
       }
-      this._size -= 1;
+      this._length -= 1;
       return element;
     }
     /**
@@ -4010,7 +4558,7 @@ var dataStructureTyped = (() => {
      * @returns The size of the data structure after the element has been added.
      */
     unshift(element) {
-      if (this._size) {
+      if (this._length) {
         if (this._firstInBucket > 0) {
           this._firstInBucket -= 1;
         } else if (this._bucketFirst > 0) {
@@ -4022,9 +4570,9 @@ var dataStructureTyped = (() => {
         }
         if (this._bucketFirst === this._bucketLast && this._firstInBucket === this._lastInBucket) this._reallocate();
       }
-      this._size += 1;
+      this._length += 1;
       this._buckets[this._bucketFirst][this._firstInBucket] = element;
-      if (this._maxLen > 0 && this._size > this._maxLen) this.pop();
+      if (this._maxLen > 0 && this._length > this._maxLen) this.pop();
       return true;
     }
     /**
@@ -4084,7 +4632,7 @@ var dataStructureTyped = (() => {
      * @returns A boolean value indicating whether the size of the object is 0 or not.
      */
     isEmpty() {
-      return this._size === 0;
+      return this._length === 0;
     }
     /**
      * Time Complexity: O(1)
@@ -4096,30 +4644,9 @@ var dataStructureTyped = (() => {
     clear() {
       this._buckets = [new Array(this._bucketSize)];
       this._bucketCount = 1;
-      this._bucketFirst = this._bucketLast = this._size = 0;
+      this._bucketFirst = this._bucketLast = this._length = 0;
       this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
     }
-    /**
-     * The below function is a generator that yields elements from a collection one by one.
-     */
-    *begin() {
-      let index = 0;
-      while (index < this._size) {
-        yield this.at(index);
-        index++;
-      }
-    }
-    /**
-     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
-     * the last element.
-     */
-    *reverseBegin() {
-      let index = this._size - 1;
-      while (index >= 0) {
-        yield this.at(index);
-        index--;
-      }
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -4131,7 +4658,7 @@ var dataStructureTyped = (() => {
      * @returns The element at the specified position in the data structure is being returned.
      */
     at(pos) {
-      rangeCheck(pos, 0, this._size - 1);
+      rangeCheck(pos, 0, this._length - 1);
       const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
       return this._buckets[bucketIndex][indexInBucket];
     }
@@ -4146,7 +4673,7 @@ var dataStructureTyped = (() => {
      * position in the data structure.
      */
     setAt(pos, element) {
-      rangeCheck(pos, 0, this._size - 1);
+      rangeCheck(pos, 0, this._length - 1);
       const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
       this._buckets[bucketIndex][indexInBucket] = element;
       return true;
@@ -4167,15 +4694,15 @@ var dataStructureTyped = (() => {
      * @returns The size of the array after the insertion is being returned.
      */
     addAt(pos, element, num = 1) {
-      const length = this._size;
+      const length = this._length;
       rangeCheck(pos, 0, length);
       if (pos === 0) {
         while (num--) this.unshift(element);
-      } else if (pos === this._size) {
+      } else if (pos === this._length) {
         while (num--) this.push(element);
       } else {
         const arr = [];
-        for (let i = pos; i < this._size; ++i) {
+        for (let i = pos; i < this._length; ++i) {
           arr.push(this.at(i));
         }
         this.cut(pos - 1, true);
@@ -4204,16 +4731,59 @@ var dataStructureTyped = (() => {
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         this._bucketLast = bucketIndex;
         this._lastInBucket = indexInBucket;
-        this._size = pos + 1;
+        this._length = pos + 1;
         return this;
       } else {
-        const newDeque = new _Deque([], { bucketSize: this._bucketSize });
+        const newDeque = this._createInstance({
+          bucketSize: this._bucketSize,
+          toElementFn: this._toElementFn,
+          maxLen: this._maxLen
+        });
         for (let i = 0; i <= pos; i++) {
           newDeque.push(this.at(i));
         }
         return newDeque;
       }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `splice` function in TypeScript overrides the default behavior to remove and insert elements
+     * in a Deque data structure while ensuring the starting position and delete count are within bounds.
+     * @param {number} start - The `start` parameter in the `splice` method represents the index at which
+     * to start changing the array. Items will be removed or added starting from this index.
+     * @param {number} deleteCount - The `deleteCount` parameter in the `splice` method represents the
+     * number of elements to remove from the array starting at the specified `start` index. If
+     * `deleteCount` is not provided, it defaults to the number of elements from the `start` index to the
+     * end of the array (`
+     * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+     * will be inserted into the deque at the specified `start` index. These elements will be inserted in
+     * place of the elements that are removed based on the `start` and `deleteCount` parameters.
+     * @returns The `splice` method is returning the array `deletedElements` which contains the elements
+     * that were removed from the Deque during the splice operation.
+     */
+    splice(start, deleteCount = this._length - start, ...items) {
+      rangeCheck(start, 0, this._length);
+      if (deleteCount < 0) deleteCount = 0;
+      if (start + deleteCount > this._length) deleteCount = this._length - start;
+      const deletedElements = this._createInstance();
+      for (let i = 0; i < deleteCount; i++) {
+        deletedElements.push(this.at(start + i));
+      }
+      const elementsAfter = [];
+      for (let i = start + deleteCount; i < this._length; i++) {
+        elementsAfter.push(this.at(i));
+      }
+      this.cut(start - 1, true);
+      for (const item of items) {
+        this.push(item);
+      }
+      for (const element of elementsAfter) {
+        this.push(element);
+      }
+      return deletedElements;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1) or O(n)
@@ -4237,12 +4807,16 @@ var dataStructureTyped = (() => {
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         this._bucketFirst = bucketIndex;
         this._firstInBucket = indexInBucket;
-        this._size = this._size - pos;
+        this._length = this._length - pos;
         return this;
       } else {
-        const newDeque = new _Deque([], { bucketSize: this._bucketSize });
+        const newDeque = this._createInstance({
+          bucketSize: this._bucketSize,
+          toElementFn: this._toElementFn,
+          maxLen: this._maxLen
+        });
         if (pos < 0) pos = 0;
-        for (let i = pos; i < this._size; i++) {
+        for (let i = pos; i < this._length; i++) {
           newDeque.push(this.at(i));
         }
         return newDeque;
@@ -4260,21 +4834,26 @@ var dataStructureTyped = (() => {
      * @returns The size of the data structure after the deletion operation is performed.
      */
     deleteAt(pos) {
-      rangeCheck(pos, 0, this._size - 1);
-      if (pos === 0) this.shift();
-      else if (pos === this._size - 1) this.pop();
-      else {
-        const length = this._size - 1;
-        let { bucketIndex: curBucket, indexInBucket: curPointer } = this._getBucketAndPosition(pos);
-        for (let i = pos; i < length; ++i) {
-          const { bucketIndex: nextBucket, indexInBucket: nextPointer } = this._getBucketAndPosition(pos + 1);
+      rangeCheck(pos, 0, this._length - 1);
+      let deleted;
+      if (pos === 0) {
+        return this.shift();
+      } else if (pos === this._length - 1) {
+        deleted = this.last;
+        this.pop();
+        return deleted;
+      } else {
+        const length = this._length - 1;
+        const { bucketIndex: targetBucket, indexInBucket: targetPointer } = this._getBucketAndPosition(pos);
+        deleted = this._buckets[targetBucket][targetPointer];
+        for (let i = pos; i < length; i++) {
+          const { bucketIndex: curBucket, indexInBucket: curPointer } = this._getBucketAndPosition(i);
+          const { bucketIndex: nextBucket, indexInBucket: nextPointer } = this._getBucketAndPosition(i + 1);
           this._buckets[curBucket][curPointer] = this._buckets[nextBucket][nextPointer];
-          curBucket = nextBucket;
-          curPointer = nextPointer;
         }
         this.pop();
+        return deleted;
       }
-      return true;
     }
     /**
      * Time Complexity: O(n)
@@ -4287,7 +4866,7 @@ var dataStructureTyped = (() => {
      * @returns The size of the data structure after the element has been deleted.
      */
     delete(element) {
-      const size = this._size;
+      const size = this._length;
       if (size === 0) return false;
       let i = 0;
       let index = 0;
@@ -4302,6 +4881,42 @@ var dataStructureTyped = (() => {
       this.cut(index - 1, true);
       return true;
     }
+    // /**
+    //  * Time Complexity: O(n)
+    //  * Space Complexity: O(1)
+    //  *
+    //  * This function overrides the indexOf method to search for an element within a custom data
+    //  * structure.
+    //  * @param {E} searchElement - The `searchElement` parameter is the element that you are searching for
+    //  * within the data structure. The `indexOf` method will return the index of the first occurrence of
+    //  * this element within the data structure.
+    //  * @param {number} [fromIndex=0] - The `fromIndex` parameter in the `indexOf` method specifies the
+    //  * index at which to start searching for the `searchElement` within the data structure. If provided,
+    //  * the search will begin at this index instead of the beginning of the data structure.
+    //  * @returns The indexOf method is returning the index of the searchElement if it is found in the data
+    //  * structure, or -1 if the searchElement is not found.
+    //  */
+    // override indexOf(searchElement: E, fromIndex: number = 0): number {
+    //   let index = fromIndex;
+    //   let bucketIndex = this._bucketFirst;
+    //   let indexInBucket = this._firstInBucket + fromIndex;
+    //
+    //   for (let i = 0; i < this._length; i++) {
+    //     if (this._buckets[bucketIndex][indexInBucket] === searchElement) {
+    //       return index;
+    //     }
+    //     index++;
+    //     indexInBucket++;
+    //     if (indexInBucket >= this._bucketSize) {
+    //       bucketIndex++;
+    //       indexInBucket = 0;
+    //     }
+    //     if (bucketIndex >= this._bucketCount) {
+    //       bucketIndex = 0;
+    //     }
+    //   }
+    //   return -1;
+    // }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -4331,12 +4946,12 @@ var dataStructureTyped = (() => {
      * @returns The size of the modified array is being returned.
      */
     unique() {
-      if (this._size <= 1) {
+      if (this._length <= 1) {
         return this;
       }
       let index = 1;
       let prev = this.at(0);
-      for (let i = 1; i < this._size; ++i) {
+      for (let i = 1; i < this._length; ++i) {
         const cur = this.at(i);
         if (cur !== prev) {
           prev = cur;
@@ -4346,27 +4961,6 @@ var dataStructureTyped = (() => {
       this.cut(index - 1, true);
       return this;
     }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `sort` function sorts the elements in a data structure using a provided comparator function.
-     * @param [comparator] - The `comparator` parameter is a function that takes in two elements `x` and
-     * `y` of type `E` and returns a number. The comparator function is used to determine the order of
-     * the elements in the sorted array.
-     * @returns Deque<E>
-     */
-    sort(comparator) {
-      const arr = [];
-      for (let i = 0; i < this._size; ++i) {
-        arr.push(this.at(i));
-      }
-      arr.sort(comparator);
-      for (let i = 0; i < this._size; ++i) {
-        this.setAt(i, arr[i]);
-      }
-      return this;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4374,10 +4968,10 @@ var dataStructureTyped = (() => {
      * The `shrinkToFit` function reorganizes the elements in an array-like data structure to minimize
      * memory usage.
      * @returns Nothing is being returned. The function is using the `return` statement to exit early if
-     * `this._size` is 0, but it does not return any value.
+     * `this._length` is 0, but it does not return any value.
      */
     shrinkToFit() {
-      if (this._size === 0) return;
+      if (this._length === 0) return;
       const newBuckets = [];
       if (this._bucketFirst === this._bucketLast) return;
       else if (this._bucketFirst < this._bucketLast) {
@@ -4396,35 +4990,6 @@ var dataStructureTyped = (() => {
       this._bucketLast = newBuckets.length - 1;
       this._buckets = newBuckets;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function "indexOf" returns the index of the first occurrence of a given element in an array,
-     * or -1 if the element is not found.
-     * @param {E} element - The "element" parameter represents the element that you want to find the
-     * index of in the data structure.
-     * @returns The indexOf function returns the index of the first occurrence of the specified element
-     * in the data structure. If the element is not found, it returns -1.
-     */
-    indexOf(element) {
-      for (let i = 0; i < this._size; ++i) {
-        if (this.at(i) === element) {
-          return i;
-        }
-      }
-      return -1;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `toArray` function converts the elements of a data structure into an array.
-     * @returns The `toArray()` method is returning an array of elements of type `E`.
-     */
-    toArray() {
-      return [...this];
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4435,7 +5000,11 @@ var dataStructureTyped = (() => {
      * elements as the original deque (`this`) and the same bucket size.
      */
     clone() {
-      return new _Deque(this, { bucketSize: this.bucketSize, toElementFn: this.toElementFn });
+      return new _Deque(this, {
+        bucketSize: this.bucketSize,
+        toElementFn: this.toElementFn,
+        maxLen: this._maxLen
+      });
     }
     /**
      * Time Complexity: O(n)
@@ -4454,7 +5023,11 @@ var dataStructureTyped = (() => {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-      const newDeque = new _Deque([], { bucketSize: this._bucketSize, toElementFn: this.toElementFn });
+      const newDeque = this._createInstance({
+        bucketSize: this._bucketSize,
+        toElementFn: this.toElementFn,
+        maxLen: this._maxLen
+      });
       let index = 0;
       for (const el of this) {
         if (predicate.call(thisArg, el, index, this)) {
@@ -4483,7 +5056,7 @@ var dataStructureTyped = (() => {
      * @returns a new Deque object with elements of type EM and raw elements of type RM.
      */
     map(callback, toElementFn, thisArg) {
-      const newDeque = new _Deque([], { bucketSize: this._bucketSize, toElementFn });
+      const newDeque = new _Deque([], { bucketSize: this._bucketSize, toElementFn, maxLen: this._maxLen });
       let index = 0;
       for (const el of this) {
         newDeque.push(callback.call(thisArg, el, index, this));
@@ -4499,7 +5072,7 @@ var dataStructureTyped = (() => {
      * object to be iterated over using a for...of loop.
      */
     *_getIterator() {
-      for (let i = 0; i < this._size; ++i) {
+      for (let i = 0; i < this._length; ++i) {
         yield this.at(i);
       }
     }
@@ -4556,6 +5129,26 @@ var dataStructureTyped = (() => {
       }
       return { bucketIndex, indexInBucket };
     }
+    /**
+     * The function `_createInstance` returns a new instance of the `Deque` class with the specified
+     * options.
+     * @param [options] - The `options` parameter in the `_createInstance` method is of type
+     * `DequeOptions<E, R>`, which is an optional parameter that allows you to pass additional
+     * configuration options when creating a new instance of the `Deque` class.
+     * @returns An instance of the `Deque` class with an empty array and the provided options, casted as
+     * `this`.
+     */
+    _createInstance(options) {
+      return new _Deque([], options);
+    }
+    /**
+     * This function returns an iterator that iterates over elements in reverse order.
+     */
+    *_getReverseIterator() {
+      for (let i = this._length - 1; i > -1; i--) {
+        yield this.at(i);
+      }
+    }
   };
 
   // src/data-structures/heap/heap.ts
@@ -4779,16 +5372,6 @@ var dataStructureTyped = (() => {
       _dfs(0);
       return result;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * Convert the heap to an array.
-     * @returns An array containing the elements of the heap.
-     */
-    toArray() {
-      return [...this.elements];
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -5688,8 +6271,8 @@ var dataStructureTyped = (() => {
         const queue = new Queue([vertex1]);
         visited.set(vertex1, true);
         let cost = 0;
-        while (queue.size > 0) {
-          for (let i = 0; i < queue.size; i++) {
+        while (queue.length > 0) {
+          for (let i = 0; i < queue.length; i++) {
             const cur = queue.shift();
             if (cur === vertex2) {
               return cost;
@@ -7463,7 +8046,7 @@ var dataStructureTyped = (() => {
      * This TypeScript constructor function initializes a binary tree with optional options and adds
      * elements based on the provided input.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-     * iterable that can contain either objects of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It
+     * iterable that can contain either objects of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It
      * is used to initialize the binary tree with keys, nodes, entries, or raw data.
      * @param [options] - The `options` parameter in the constructor is an optional object that can
      * contain the following properties:
@@ -7472,6 +8055,7 @@ var dataStructureTyped = (() => {
       super();
       __publicField(this, "iterationType", "ITERATIVE");
       __publicField(this, "_isMapMode", true);
+      __publicField(this, "_isDuplicate", false);
       __publicField(this, "_store", /* @__PURE__ */ new Map());
       __publicField(this, "_root");
       __publicField(this, "_size", 0);
@@ -7479,9 +8063,10 @@ var dataStructureTyped = (() => {
       __publicField(this, "_toEntryFn");
       __publicField(this, "_DEFAULT_NODE_CALLBACK", (node) => node ? node.key : void 0);
       if (options) {
-        const { iterationType, toEntryFn, isMapMode } = options;
+        const { iterationType, toEntryFn, isMapMode, isDuplicate } = options;
         if (iterationType) this.iterationType = iterationType;
         if (isMapMode !== void 0) this._isMapMode = isMapMode;
+        if (isDuplicate !== void 0) this._isDuplicate = isDuplicate;
         if (typeof toEntryFn === "function") this._toEntryFn = toEntryFn;
         else if (toEntryFn) throw TypeError("toEntryFn must be a function type");
       }
@@ -7490,6 +8075,9 @@ var dataStructureTyped = (() => {
     get isMapMode() {
       return this._isMapMode;
     }
+    get isDuplicate() {
+      return this._isDuplicate;
+    }
     get store() {
       return this._store;
     }
@@ -7544,8 +8132,8 @@ var dataStructureTyped = (() => {
      *
      * The function `ensureNode` in TypeScript checks if a given input is a node, entry, key, or raw
      * value and returns the corresponding node or null.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `ensureNode` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `ensureNode` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It
      * is used to determine whether the input is a key, node, entry, or raw data. The
      * @param {IterationType} iterationType - The `iterationType` parameter in the `ensureNode` function
      * is used to specify the type of iteration to be performed. It has a default value of
@@ -7571,7 +8159,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function isNode checks if the input is an instance of BinaryTreeNode.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
      * `keyNodeOrEntry` can be either a key, a node, an entry, or raw data. The function is
      * checking if the input is an instance of a `BinaryTreeNode` and returning a boolean value
      * accordingly.
@@ -7588,7 +8176,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `isRaw` checks if the input parameter is of type `R` by verifying if it is an object.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | R} keyNodeEntryOrRaw - BTNRep<K, V, BinaryTreeNode<K, V>>
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | R} keyNodeEntryOrRaw - K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
      * @returns The function `isRaw` is checking if the `keyNodeEntryOrRaw` parameter is of type `R` by
      * checking if it is an object. If the parameter is an object, the function will return `true`,
      * indicating that it is of type `R`.
@@ -7601,8 +8189,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `isRealNode` checks if a given input is a valid node in a binary tree.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `isRealNode` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`.
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `isRealNode` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`.
      * The function checks if the input parameter is a `BinaryTreeNode<K, V>` type by verifying if it is not equal
      * @returns The function `isRealNode` is checking if the input `keyNodeOrEntry` is a valid
      * node by comparing it to `this._NIL`, `null`, and `undefined`. If the input is not one of these
@@ -7618,7 +8206,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function checks if a given input is a valid node or null.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
      * `keyNodeOrEntry` in the `isRealNodeOrNull` function can be of type `BTNRep<K,
      * V, BinaryTreeNode<K, V>>` or `R`. It is a union type that can either be a key, a node, an entry, or
      * @returns The function `isRealNodeOrNull` is returning a boolean value. It checks if the input
@@ -7633,7 +8221,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function isNIL checks if a given key, node, entry, or raw value is equal to the _NIL value.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - BTNRep<K, V,
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - BTNRep<K, V,
      * BinaryTreeNode<K, V>>
      * @returns The function is checking if the `keyNodeOrEntry` parameter is equal to the `_NIL`
      * property of the current object and returning a boolean value based on that comparison.
@@ -7646,9 +8234,9 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `isRange` checks if the input parameter is an instance of the `Range` class.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>> | Range<K>}
-     * keyNodeEntryOrPredicate - The `keyNodeEntryOrPredicate` parameter in the `isRange` function can be
-     * of type `BTNRep<K, V, BinaryTreeNode<K, V>>`, `NodePredicate<BinaryTreeNode<K, V>>`, or
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>> | Range<K>} keyNodeEntryOrPredicate
+     * - The `keyNodeEntryOrPredicate` parameter in the `isRange` function can be
+     * of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `, `NodePredicate<BinaryTreeNode<K, V>>`, or
      * `Range<K>`. The function checks if the `keyNodeEntry
      * @returns The `isRange` function is checking if the `keyNodeEntryOrPredicate` parameter is an
      * instance of the `Range` class. If it is an instance of `Range`, the function will return `true`,
@@ -7664,8 +8252,8 @@ var dataStructureTyped = (() => {
      *
      * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
      * tree.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It represents a
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It represents a
      * key, node, entry, or raw data in a binary tree structure. The function `isLeaf` checks whether the
      * provided
      * @returns The function `isLeaf` returns a boolean value indicating whether the input
@@ -7683,8 +8271,8 @@ var dataStructureTyped = (() => {
      *
      * The function `isEntry` checks if the input is a BTNEntry object by verifying if it is an array
      * with a length of 2.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `isEntry` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or type `R`.
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `isEntry` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or type `R`.
      * The function checks if the provided `keyNodeOrEntry` is of type `BTN
      * @returns The `isEntry` function is checking if the `keyNodeOrEntry` parameter is an array
      * with a length of 2. If it is, then it returns `true`, indicating that the parameter is of type
@@ -7714,7 +8302,7 @@ var dataStructureTyped = (() => {
      *
      * The `add` function in TypeScript adds a new node to a binary tree while handling duplicate keys
      * and finding the correct insertion position.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `add` method you provided
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `add` method you provided
      * seems to be for adding a new node to a binary tree structure. The `keyNodeOrEntry`
      * parameter in the method can accept different types of values:
      * @param {V} [value] - The `value` parameter in the `add` method represents the value associated
@@ -7736,13 +8324,15 @@ var dataStructureTyped = (() => {
       }
       const queue = new Queue([this._root]);
       let potentialParent;
-      while (queue.size > 0) {
+      while (queue.length > 0) {
         const cur = queue.shift();
         if (!cur) continue;
-        if (newNode !== null && cur.key === newNode.key) {
-          this._replaceNode(cur, newNode);
-          if (this._isMapMode) this._setValue(cur.key, newValue);
-          return true;
+        if (!this._isDuplicate) {
+          if (newNode !== null && cur.key === newNode.key) {
+            this._replaceNode(cur, newNode);
+            if (this._isMapMode) this._setValue(cur.key, newValue);
+            return true;
+          }
         }
         if (potentialParent === void 0 && (cur.left === void 0 || cur.right === void 0)) {
           potentialParent = cur;
@@ -7775,7 +8365,7 @@ var dataStructureTyped = (() => {
      * each insertion was successful.
      * @param keysNodesEntriesOrRaws - `keysNodesEntriesOrRaws` is an iterable that can contain a
      * mix of keys, nodes, entries, or raw values. Each element in this iterable can be of type
-     * `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`.
+     * `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`.
      * @param [values] - The `values` parameter in the `addMany` function is an optional parameter that
      * accepts an iterable of values. These values correspond to the keys or nodes being added in the
      * `keysNodesEntriesOrRaws` parameter. If provided, the function will iterate over the values and
@@ -7821,7 +8411,7 @@ var dataStructureTyped = (() => {
      * The `refill` function clears the existing data structure and then adds new key-value pairs based
      * on the provided input.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the `refill`
-     * method can accept an iterable containing a mix of `BTNRep<K, V, BinaryTreeNode<K, V>>` objects or `R`
+     * method can accept an iterable containing a mix of `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` objects or `R`
      * objects.
      * @param [values] - The `values` parameter in the `refill` method is an optional parameter that
      * accepts an iterable of values of type `V` or `undefined`.
@@ -7836,7 +8426,7 @@ var dataStructureTyped = (() => {
      *
      * The function `delete` in TypeScript implements the deletion of a node in a binary tree and returns
      * the deleted node along with information for tree balancing.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry
      * - The `delete` method you provided is used to delete a node from a binary tree based on the key,
      * node, entry or raw data. The method returns an array of
      * `BinaryTreeDeleteResult` objects containing information about the deleted node and whether
@@ -7890,15 +8480,15 @@ var dataStructureTyped = (() => {
      *
      * The `search` function in TypeScript performs a depth-first or breadth-first search on a tree
      * structure based on a given predicate or key, with options to return multiple results or just one.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
      * `keyNodeEntryOrPredicate` parameter in the `search` function can accept three types of values:
      * @param [onlyOne=false] - The `onlyOne` parameter in the `search` function is a boolean flag that
      * determines whether the search should stop after finding the first matching node. If `onlyOne` is
      * set to `true`, the search will return as soon as a matching node is found. If `onlyOne` is
      * @param {C} callback - The `callback` parameter in the `search` function is a callback function
      * that will be called on each node that matches the search criteria. It is of type `C`, which
-     * extends `NodeCallback<BinaryTreeNode<K, V>>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `search` function is
+     * extends `NodeCallback<BinaryTreeNode<K, V> | null>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `search` function is
      * used to specify the node from which the search operation should begin. It represents the starting
      * point in the binary tree where the search will be performed. If no specific `startNode` is
      * provided, the search operation will start from the root
@@ -7948,12 +8538,12 @@ var dataStructureTyped = (() => {
      *
      * The function `getNodes` retrieves nodes from a binary tree based on a key, node, entry, raw data,
      * or predicate, with options for recursive or iterative traversal.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
      * - The `getNodes` function you provided takes several parameters:
      * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` function is a boolean flag that
      * determines whether to return only the first node that matches the criteria specified by the
      * `keyNodeEntryOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getNodes` function is used to specify the starting point for traversing the binary tree. It
      * represents the root node of the binary tree or the node from which the traversal should begin. If
      * not provided, the default value is set to `this._root
@@ -7972,10 +8562,10 @@ var dataStructureTyped = (() => {
      *
      * The `getNode` function retrieves a node based on the provided key, node, entry, raw data, or
      * predicate.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
      * - The `keyNodeEntryOrPredicate` parameter in the `getNode` function can accept a key,
      * node, entry, raw data, or a predicate function.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getNode` function is used to specify the starting point for searching for a node in a binary
      * tree. If no specific starting point is provided, the default value is set to `this._root`, which
      * is typically the root node of the binary tree.
@@ -7995,10 +8585,10 @@ var dataStructureTyped = (() => {
      *
      * This function overrides the `get` method to retrieve the value associated with a specified key,
      * node, entry, raw data, or predicate in a data structure.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
      * - The `keyNodeEntryOrPredicate` parameter in the `get` method can accept one of the
      * following types:
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `get`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `get`
      * method is used to specify the starting point for searching for a key or node in the binary tree.
      * If no specific starting point is provided, the default starting point is the root of the binary
      * tree (`this._root`).
@@ -8026,10 +8616,10 @@ var dataStructureTyped = (() => {
      *
      * The `has` function in TypeScript checks if a specified key, node, entry, raw data, or predicate
      * exists in the data structure.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
      * - The `keyNodeEntryOrPredicate` parameter in the `override has` method can accept one of
      * the following types:
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `override` method is used to specify the starting point for the search operation within the data
      * structure. It defaults to `this._root` if not provided explicitly.
      * @param {IterationType} iterationType - The `iterationType` parameter in the `override has` method
@@ -8072,7 +8662,7 @@ var dataStructureTyped = (() => {
      *
      * The function checks if a binary tree is perfectly balanced by comparing its minimum height with
      * its height.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter is the starting
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
      * point for checking if the binary tree is perfectly balanced. It represents the root node of the
      * binary tree or a specific node from which the balance check should begin.
      * @returns The method `isPerfectlyBalanced` is returning a boolean value, which indicates whether
@@ -8090,7 +8680,7 @@ var dataStructureTyped = (() => {
      *
      * The function `isBST` in TypeScript checks if a binary search tree is valid using either recursive
      * or iterative methods.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `isBST`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `isBST`
      * function represents the starting point for checking whether a binary search tree (BST) is valid.
      * It can be a node in the BST or a reference to the root of the BST. If no specific node is
      * provided, the function will default to
@@ -8142,10 +8732,10 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(log n)
      *
      * The `getDepth` function calculates the depth between two nodes in a binary tree.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} dist - The `dist` parameter in the `getDepth`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } dist - The `dist` parameter in the `getDepth`
      * function represents the node or entry in a binary tree map, or a reference to a node in the tree.
      * It is the target node for which you want to calculate the depth from the `startNode` node.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getDepth` function represents the starting point from which you want to calculate the depth of a
      * given node or entry in a binary tree. If no specific starting point is provided, the default value
      * for `startNode` is set to the root of the binary
@@ -8172,7 +8762,7 @@ var dataStructureTyped = (() => {
      *
      * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
      * or iterative approach in TypeScript.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter is the starting
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
      * point from which the height of the binary tree will be calculated. It can be a node in the binary
      * tree or a reference to the root of the tree. If not provided, it defaults to the root of the
      * binary tree data structure.
@@ -8212,7 +8802,7 @@ var dataStructureTyped = (() => {
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach in TypeScript.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getMinHeight` function represents the starting node from which the minimum height of the binary
      * tree will be calculated. It is either a node in the binary tree or a reference to the root of the
      * tree. If not provided, the default value is the root
@@ -8271,7 +8861,7 @@ var dataStructureTyped = (() => {
      * the path to the root. It is expected to be a function that takes a node as an argument and returns
      * a value based on that node. The return type of the callback function is determined by the generic
      * type `C
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} beginNode - The `beginNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } beginNode - The `beginNode` parameter in the
      * `getPathToRoot` function can be either a key, a node, an entry, or any other value of type `R`.
      * @param [isReverse=true] - The `isReverse` parameter in the `getPathToRoot` function determines
      * whether the resulting path from the given `beginNode` to the root should be in reverse order or
@@ -8301,7 +8891,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called with the leftmost
      * node of a binary tree or with `undefined` if the tree is empty. It is provided with a default
      * value of `_DEFAULT_NODE_CALLBACK` if not specified.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getLeftMost` function represents the starting point for finding the leftmost node in a binary
      * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
      * starting point is provided, the function will default
@@ -8341,7 +8931,7 @@ var dataStructureTyped = (() => {
      * of finding the rightmost node in a binary tree. It is of type `NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>`,
      * which means it is a callback function that can accept either an optional binary tree node or null
      * as
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getRightMost` function represents the starting point for finding the rightmost node in a binary
      * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
      * starting point is provided, the function will default
@@ -8427,32 +9017,34 @@ var dataStructureTyped = (() => {
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
-     * The function `dfs` performs a depth-first search traversal on a binary tree structure based on the
-     * specified parameters.
-     * @param {C} callback - The `callback` parameter is a generic type `C` that extends the
-     * `NodeCallback` interface with a type parameter of `OptNodeOrNull<BinaryTreeNode<K, V>>`. It has a default value of
-     * `this._DEFAULT_NODE_CALLBACK as C`.
-     * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `dfs` method specifies the
-     * order in which the Depth-First Search (DFS) algorithm should traverse the nodes in the tree. The
-     * possible values for the `pattern` parameter are:
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `dfs`
-     * method is used to specify the starting point for the Depth-First Search traversal. It can be
-     * either a `BTNRep` object representing a key, node, or entry in the binary tree map,
-     * or it can be a
-     * @param {IterationType} iterationType - The `iterationType` parameter in the `dfs` method specifies
-     * the type of iteration to be performed during the depth-first search traversal. It is used to
-     * determine the order in which nodes are visited during the traversal.
-     * @param [includeNull=false] - The `includeNull` parameter in the `dfs` method is a boolean flag
-     * that determines whether null values should be included in the traversal or not. If `includeNull`
-     * is set to `true`, then null values will be included in the traversal process. If it is set to
-     * `false`,
-     * @returns The `dfs` method is returning an array of the return type specified by the generic type
-     * parameter `C`. The return type is determined by the callback function provided to the method.
-     */
-    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", startNode = this._root, iterationType = this.iterationType, includeNull = false) {
+     * The function performs a depth-first search on a binary tree structure based on the specified
+     * parameters.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node
+     * visited during the depth-first search. It should accept a `BinaryTreeNode` as an argument and
+     * return an optional node or null. The default value for this parameter is `_DEFAULT_NODE_CALLBACK`.
+     * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `dfs` function specifies
+     * the order in which the nodes are visited during a depth-first search traversal. The possible
+     * values for the `pattern` parameter are:
+     * @param {boolean} [onlyOne=false] - The `onlyOne` parameter in the `dfs` function is a boolean flag
+     * that determines whether the depth-first search should stop after finding the first matching node
+     * or continue searching for all matching nodes. If `onlyOne` is set to `true`, the search will stop
+     * after finding the first matching node
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined}
+     * startNode - The `startNode` parameter in the `dfs` function can be one of the following types:
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `dfs` function
+     * specifies the type of iteration to be performed during the Depth-First Search traversal. It is
+     * used to determine the order in which nodes are visited during the traversal. The possible values
+     * for `iterationType` are typically defined as an enum or a
+     * @param [includeNull=false] - The `includeNull` parameter in the `dfs` function determines whether
+     * null nodes should be included in the depth-first search traversal. If `includeNull` is set to
+     * `true`, null nodes will be included in the traversal process. If it is set to `false`, null nodes
+     * will be skipped
+     * @returns The `dfs` method is returning an array of the return type of the callback function `C`.
+     */
+    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", onlyOne = false, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
       startNode = this.ensureNode(startNode);
       if (!startNode) return [];
-      return this._dfs(callback, pattern, startNode, iterationType, includeNull);
+      return this._dfs(callback, pattern, onlyOne, startNode, iterationType, includeNull);
     }
     /**
      * Time complexity: O(n)
@@ -8463,7 +9055,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter in the `bfs` function is a function that will be
      * called on each node visited during the breadth-first search traversal. It is a generic type `C`
      * that extends the `NodeCallback` type, which takes a parameter of type `BinaryTreeNode<K, V>` or `null`.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `bfs`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `bfs`
      * function represents the starting point for the breadth-first search traversal in a binary tree. It
      * can be specified as a key, node, or entry in the binary tree structure. If not provided, the
      * default value is the root node of the binary
@@ -8486,7 +9078,7 @@ var dataStructureTyped = (() => {
           startNode
         ]);
         const dfs = (level) => {
-          if (queue.size === 0) return;
+          if (queue.length === 0) return;
           const current = queue.shift();
           ans.push(callback(current));
           if (includeNull) {
@@ -8501,8 +9093,8 @@ var dataStructureTyped = (() => {
         dfs(0);
       } else {
         const queue = new Queue([startNode]);
-        while (queue.size > 0) {
-          const levelSize = queue.size;
+        while (queue.length > 0) {
+          const levelSize = queue.length;
           for (let i = 0; i < levelSize; i++) {
             const current = queue.shift();
             ans.push(callback(current));
@@ -8526,7 +9118,7 @@ var dataStructureTyped = (() => {
      * structure based on a specified callback and iteration type.
      * @param {C} callback - The `callback` parameter is a function that will be called on each leaf node
      * in the binary tree. It is optional and defaults to a default callback function if not provided.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `leaves`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `leaves`
      * method is used to specify the starting point for finding and processing the leaves of a binary
      * tree. It can be provided as either a key, a node, or an entry in the binary tree structure. If not
      * explicitly provided, the default value
@@ -8552,7 +9144,7 @@ var dataStructureTyped = (() => {
         dfs(startNode);
       } else {
         const queue = new Queue([startNode]);
-        while (queue.size > 0) {
+        while (queue.length > 0) {
           const cur = queue.shift();
           if (this.isRealNode(cur)) {
             if (this.isLeaf(cur)) {
@@ -8574,7 +9166,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be applied to each node in
      * the binary tree during the traversal. It is used to process each node and determine what
      * information to include in the output for each level of the tree.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `listLevels` function represents the starting point for traversing the binary tree. It can be
      * either a key, a node, or an entry in the binary tree. If not provided, the default value is the
      * root of the binary tree.
@@ -8632,11 +9224,11 @@ var dataStructureTyped = (() => {
      * Morris Traversal algorithm with different order patterns.
      * @param {C} callback - The `callback` parameter in the `morris` function is a function that will be
      * called on each node in the binary tree during the traversal. It is of type `C`, which extends the
-     * `NodeCallback<BinaryTreeNode<K, V>>` type. The default value for `callback` is `this._DEFAULT
+     * `NodeCallback<BinaryTreeNode<K, V> | null>` type. The default value for `callback` is `this._DEFAULT
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `morris` function specifies
      * the type of Depth-First Search (DFS) order pattern to traverse the binary tree. The possible
      * values for the `pattern` parameter are:
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `morris`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `morris`
      * function is the starting point for the Morris traversal algorithm. It represents the root node of
      * the binary tree or the node from which the traversal should begin. It can be provided as either a
      * key, a node, an entry, or a reference
@@ -8740,21 +9332,6 @@ var dataStructureTyped = (() => {
       this._clone(cloned);
       return cloned;
     }
-    _clone(cloned) {
-      this.bfs(
-        (node) => {
-          if (node === null) cloned.add(null);
-          else {
-            if (this._isMapMode) cloned.add([node.key, this._store.get(node.key)]);
-            else cloned.add([node.key, node.value]);
-          }
-        },
-        this._root,
-        this.iterationType,
-        true
-      );
-      if (this._isMapMode) cloned._store = this._store;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -8814,7 +9391,7 @@ var dataStructureTyped = (() => {
      *
      * The function `toVisual` in TypeScript overrides the visual representation of a binary tree with
      * customizable options for displaying undefined, null, and sentinel nodes.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `toVisual` method is used to specify the starting point for visualizing the binary tree structure.
      * It can be a node, key, entry, or the root of the tree. If no specific starting point is provided,
      * the default is set to the root
@@ -8858,7 +9435,7 @@ var dataStructureTyped = (() => {
      * printing options for the binary tree. It is an optional parameter that allows you to customize how
      * the binary tree is printed, such as choosing between different traversal orders or formatting
      * options.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `override print` method is used to specify the starting point for printing the binary tree. It can
      * be either a key, a node, an entry, or the root of the tree. If no specific starting point is
      * provided, the default value is set to
@@ -8866,21 +9443,36 @@ var dataStructureTyped = (() => {
     print(options, startNode = this._root) {
       console.log(this.toVisual(startNode, options));
     }
+    _clone(cloned) {
+      this.bfs(
+        (node) => {
+          if (node === null) cloned.add(null);
+          else {
+            if (this._isMapMode) cloned.add([node.key, this._store.get(node.key)]);
+            else cloned.add([node.key, node.value]);
+          }
+        },
+        this._root,
+        this.iterationType,
+        true
+      );
+      if (this._isMapMode) cloned._store = this._store;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
      * or returns null.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The
      * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeOrEntry`, which
-     * can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. This parameter represents either a key, a
+     * can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. This parameter represents either a key, a
      * node, an entry
      * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
      * an optional parameter of type `V`. It represents the value associated with the key in the node
      * being created. If a `value` is provided, it will be used when creating the node. If
      * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
-     * (`OptNodeOrNull<BinaryTreeNode<K, V>>`) based on the input parameters provided. The function checks the type of the
+     * (`BinaryTreeNode<K, V> | null | undefined`) based on the input parameters provided. The function checks the type of the
      * input parameter (`keyNodeOrEntry`) and processes it accordingly to return a node or null
      * value.
      */
@@ -8901,45 +9493,48 @@ var dataStructureTyped = (() => {
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
-     * The `_dfs` function performs a depth-first search traversal on a binary tree structure based on
-     * the specified order pattern and callback function.
+     * The `_dfs` function performs a depth-first search traversal on a binary tree, with customizable
+     * options for traversal order and node processing.
      * @param {C} callback - The `callback` parameter in the `_dfs` method is a function that will be
-     * called on each node visited during the depth-first search traversal. It is of type `C`, which
-     * extends `NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>`. The default value for this parameter is `this._DEFAULT
+     * called on each node visited during the depth-first search traversal. It is a generic type `C` that
+     * extends `NodeCallback<BinaryTreeNode<K, V> | null>`. The default value for `callback`
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `_dfs` method specifies the
-     * order in which the nodes are visited during the Depth-First Search traversal. It can have one of
-     * the following values:
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `_dfs`
-     * method is used to specify the starting point for the depth-first search traversal in a binary
-     * tree. It can be provided as either a `BTNRep` object or a reference to the root node
-     * of the tree. If no specific
+     * order in which the nodes are visited during a depth-first search traversal. It can have one of the
+     * following values:
+     * @param {boolean} [onlyOne=false] - The `onlyOne` parameter in the `_dfs` method is a boolean flag
+     * that determines whether the traversal should stop after processing a single node. If `onlyOne` is
+     * set to `true`, the traversal will return as soon as a single node is processed. If it is set to
+     * `false
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined}
+     * startNode - The `startNode` parameter in the `_dfs` method is used to specify the starting node
+     * for the depth-first search traversal. It can be provided in different forms:
      * @param {IterationType} iterationType - The `iterationType` parameter in the `_dfs` method
-     * specifies the type of iteration to be performed during the Depth-First Search (DFS) traversal of a
-     * binary tree. It can have two possible values:
-     * @param [includeNull=false] - The `includeNull` parameter in the `_dfs` method is a boolean flag
-     * that determines whether null nodes should be included in the depth-first search traversal. If
-     * `includeNull` is set to `true`, null nodes will be considered during the traversal process. If it
-     * is set to `false`,
-     * @param shouldVisitLeft - The `shouldVisitLeft` parameter is a function that takes a node as input
-     * and returns a boolean value. It is used to determine whether the left child of a node should be
-     * visited during the depth-first search traversal. By default, it checks if the node is truthy (not
-     * null or undefined
-     * @param shouldVisitRight - The `shouldVisitRight` parameter is a function that takes a node as an
-     * argument and returns a boolean value. It is used to determine whether the right child of a node
-     * should be visited during the depth-first search traversal. The default implementation checks if
-     * the node is truthy before visiting the right child
-     * @param shouldVisitRoot - The `shouldVisitRoot` parameter is a function that takes a node as an
-     * argument and returns a boolean value. It is used to determine whether the root node should be
-     * visited during the depth-first search traversal based on certain conditions. The default
-     * implementation checks if the node is a real node or null based
-     * @param shouldProcessRoot - The `shouldProcessRoot` parameter is a function that takes a node as an
-     * argument and returns a boolean value indicating whether the node should be processed during the
-     * depth-first search traversal. The default implementation checks if the node is a real node or null
-     * based on the `includeNull` flag. If `
-     * @returns The function `_dfs` returns an array of the return type of the callback function provided
-     * as input.
-     */
-    _dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", startNode = this._root, iterationType = this.iterationType, includeNull = false, shouldVisitLeft = (node) => !!node, shouldVisitRight = (node) => !!node, shouldVisitRoot = (node) => {
+     * specifies whether the traversal should be done recursively or iteratively. It can have two
+     * possible values:
+     * @param [includeNull=false] - The `includeNull` parameter in the `_dfs` method determines whether
+     * null nodes should be included in the traversal process. If `includeNull` is set to `true`, the
+     * method will consider null nodes as valid nodes to visit or process. If `includeNull` is set to
+     * `false`,
+     * @param shouldVisitLeft - The `shouldVisitLeft` parameter in the `_dfs` method is a function that
+     * determines whether the left child of a node should be visited during the Depth-First Search
+     * traversal. By default, it checks if the node is not null or undefined before visiting the left
+     * child. You can customize this behavior
+     * @param shouldVisitRight - The `shouldVisitRight` parameter in the `_dfs` method is a function that
+     * determines whether to visit the right child node of the current node during a depth-first search
+     * traversal. The default implementation of this function checks if the node is not null or undefined
+     * before deciding to visit it.
+     * @param shouldVisitRoot - The `shouldVisitRoot` parameter in the `_dfs` method is a function that
+     * determines whether a given node should be visited during the depth-first search traversal. The
+     * function takes a node as an argument and returns a boolean value indicating whether the node
+     * should be visited.
+     * @param shouldProcessRoot - The `shouldProcessRoot` parameter in the `_dfs` method is a function
+     * that determines whether the root node should be processed during the Depth-First Search traversal.
+     * It takes a node (BinaryTreeNode<K, V> | null | undefined) as input and returns a boolean value. If
+     * the function
+     * @returns The `_dfs` method returns an array of the return type of the provided callback function
+     * `C`.
+     */
+    _dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", onlyOne = false, startNode = this._root, iterationType = this.iterationType, includeNull = false, shouldVisitLeft = (node) => !!node, shouldVisitRight = (node) => !!node, shouldVisitRoot = (node) => {
       if (includeNull) return this.isRealNodeOrNull(node);
       return this.isRealNode(node);
     }, shouldProcessRoot = (node) => this.isRealNodeOrNull(node)) {
@@ -8950,26 +9545,35 @@ var dataStructureTyped = (() => {
         const dfs = (node) => {
           if (!shouldVisitRoot(node)) return;
           const visitLeft = () => {
-            if (shouldVisitLeft(node)) dfs(node == null ? void 0 : node.left);
+            if (shouldVisitLeft(node) && (node == null ? void 0 : node.left) !== void 0) dfs(node == null ? void 0 : node.left);
           };
           const visitRight = () => {
-            if (shouldVisitRight(node)) dfs(node == null ? void 0 : node.right);
+            if (shouldVisitRight(node) && (node == null ? void 0 : node.right) !== void 0) dfs(node == null ? void 0 : node.right);
           };
           switch (pattern) {
             case "IN":
               visitLeft();
-              if (shouldProcessRoot(node)) ans.push(callback(node));
+              if (shouldProcessRoot(node)) {
+                ans.push(callback(node));
+                if (onlyOne) return;
+              }
               visitRight();
               break;
             case "PRE":
-              if (shouldProcessRoot(node)) ans.push(callback(node));
+              if (shouldProcessRoot(node)) {
+                ans.push(callback(node));
+                if (onlyOne) return;
+              }
               visitLeft();
               visitRight();
               break;
             case "POST":
               visitLeft();
               visitRight();
-              if (shouldProcessRoot(node)) ans.push(callback(node));
+              if (shouldProcessRoot(node)) {
+                ans.push(callback(node));
+                if (onlyOne) return;
+              }
               break;
           }
         };
@@ -8992,7 +9596,10 @@ var dataStructureTyped = (() => {
           if (cur === void 0) continue;
           if (!shouldVisitRoot(cur.node)) continue;
           if (cur.opt === 1 /* PROCESS */) {
-            if (shouldProcessRoot(cur.node)) ans.push(callback(cur.node));
+            if (shouldProcessRoot(cur.node) && cur.node !== void 0) {
+              ans.push(callback(cur.node));
+              if (onlyOne) return ans;
+            }
           } else {
             switch (pattern) {
               case "IN":
@@ -9119,12 +9726,12 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The _swapProperties function swaps key and value properties between two nodes in a binary tree.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} srcNode - The `srcNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } srcNode - The `srcNode` parameter in the
      * `_swapProperties` method can be either a BTNRep object containing key and value
      * properties, or it can be of type R.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} destNode - The `destNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } destNode - The `destNode` parameter in the
      * `_swapProperties` method represents the node or entry where the properties will be swapped with
-     * the `srcNode`. It can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. The method ensures that
+     * the `srcNode`. It can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. The method ensures that
      * both `srcNode
      * @returns The `_swapProperties` method returns either the `destNode` with its key and value swapped
      * with the `srcNode`, or `undefined` if either `srcNode` or `destNode` is falsy.
@@ -9181,7 +9788,7 @@ var dataStructureTyped = (() => {
      *
      * The function _setRoot sets the root node of a data structure while updating the parent reference
      * of the previous root node.
-     * @param v - The parameter `v` in the `_setRoot` method is of type `OptNodeOrNull<BinaryTreeNode<K, V>>`, which means
+     * @param v - The parameter `v` in the `_setRoot` method is of type `BinaryTreeNode<K, V> | null | undefined`, which means
      * it can either be an optional `BinaryTreeNode<K, V>` type or `null`.
      */
     _setRoot(v) {
@@ -9196,7 +9803,7 @@ var dataStructureTyped = (() => {
      *
      * The function `_ensurePredicate` in TypeScript ensures that the input is converted into a valid
      * predicate function for a binary tree node.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
      * `_ensurePredicate` method in the provided code snippet is responsible for ensuring that the input
      * parameter `keyNodeEntryOrPredicate` is transformed into a valid predicate function that can be
      * used for filtering nodes in a binary tree.
@@ -9210,9 +9817,15 @@ var dataStructureTyped = (() => {
         return (node) => node === keyNodeEntryOrPredicate;
       if (this.isEntry(keyNodeEntryOrPredicate)) {
         const [key] = keyNodeEntryOrPredicate;
-        return (node) => node.key === key;
+        return (node) => {
+          if (!node) return false;
+          return node.key === key;
+        };
       }
-      return (node) => node.key === keyNodeEntryOrPredicate;
+      return (node) => {
+        if (!node) return false;
+        return node.key === keyNodeEntryOrPredicate;
+      };
     }
     /**
      * Time Complexity: O(1)
@@ -9235,8 +9848,8 @@ var dataStructureTyped = (() => {
      *
      * The function `_extractKey` in TypeScript returns the key from a given input, which can be a node,
      * entry, raw data, or null/undefined.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `_extractKey` method you provided is a
-     * TypeScript method that takes in a parameter `keyNodeOrEntry` of type `BTNRep<K, V, BinaryTreeNode<K, V>>`,
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `_extractKey` method you provided is a
+     * TypeScript method that takes in a parameter `keyNodeOrEntry` of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `,
      * where `BTNRep` is a generic type with keys `K`, `V`, and `BinaryTreeNode<K, V>`, and `
      * @returns The `_extractKey` method returns the key value extracted from the `keyNodeOrEntry`
      * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on
@@ -9331,7 +9944,7 @@ var dataStructureTyped = (() => {
      * This TypeScript constructor initializes a binary search tree with optional options and adds
      * elements if provided.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-     * iterable that can contain elements of type `BTNRep<K, V, BSTNode<K, V>>` or `R`. It is used to
+     * iterable that can contain elements of type `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It is used to
      * initialize the binary search tree with keys, nodes, entries, or raw data.
      * @param [options] - The `options` parameter is an optional object that can contain the following
      * properties:
@@ -9417,7 +10030,7 @@ var dataStructureTyped = (() => {
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
+     * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
      * `keyNodeOrEntry` can accept a value of type `R`, which represents the key, node,
      * entry, or raw element that needs to be ensured in the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
@@ -9435,8 +10048,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, BSTNode<K, V>>`.
+     * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `.
      * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `BSTNode` class.
      */
@@ -9462,8 +10075,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(log n)
      *
      * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can accept a value of type `R` or `BTNRep<K, V, BSTNode<K, V>>`.
+     * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept a value of type `R` or `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `.
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key in the binary search tree. If provided, it will be stored in the node along with the key.
      * @returns a boolean value.
@@ -9565,22 +10178,20 @@ var dataStructureTyped = (() => {
         return 0;
       });
       const _dfs = (arr) => {
-        var _a;
         if (arr.length === 0) return;
         const mid = Math.floor((arr.length - 1) / 2);
-        let { key, value } = arr[mid];
+        const { key, value } = arr[mid];
         const { orgIndex } = arr[mid];
         if (this.isRaw(key)) {
           const entry = this._toEntryFn(key);
-          key = entry[0];
-          value = (_a = entry[1]) != null ? _a : value;
+          inserted[orgIndex] = this.add(entry);
+        } else {
+          inserted[orgIndex] = this.add(key, value);
         }
-        inserted[orgIndex] = this.add(key, value);
         _dfs(arr.slice(0, mid));
         _dfs(arr.slice(mid + 1));
       };
       const _iterate = () => {
-        var _a;
         const n = sorted.length;
         const stack = [[0, n - 1]];
         while (stack.length > 0) {
@@ -9589,14 +10200,14 @@ var dataStructureTyped = (() => {
             const [l, r] = popped;
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
-              let { key, value } = sorted[m];
+              const { key, value } = sorted[m];
               const { orgIndex } = sorted[m];
               if (this.isRaw(key)) {
                 const entry = this._toEntryFn(key);
-                key = entry[0];
-                value = (_a = entry[1]) != null ? _a : value;
+                inserted[orgIndex] = this.add(entry);
+              } else {
+                inserted[orgIndex] = this.add(key, value);
               }
-              inserted[orgIndex] = this.add(key, value);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
             }
@@ -9616,7 +10227,7 @@ var dataStructureTyped = (() => {
      *
      * The function `search` in TypeScript overrides the search behavior in a binary tree structure based
      * on specified criteria.
-     * @param {BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The
+     * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The
      * `keyNodeEntryOrPredicate` parameter in the `override search` method can accept one of the
      * following types:
      * @param [onlyOne=false] - The `onlyOne` parameter is a boolean flag that determines whether the
@@ -9624,9 +10235,9 @@ var dataStructureTyped = (() => {
      * search will return as soon as a matching node is found. If `onlyOne` is set to `false`, the
      * @param {C} callback - The `callback` parameter in the `override search` function is a function
      * that will be called on each node that matches the search criteria. It is of type `C`, which
-     * extends `NodeCallback<BSTNode<K, V>>`. The callback function should accept a node of type `BSTNode<K, V>` as its
+     * extends `NodeCallback<BSTNode<K, V> | null>`. The callback function should accept a node of type `BSTNode<K, V>` as its
      * argument and
-     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter in the `override search`
+     * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `override search`
      * method represents the node from which the search operation will begin. It is the starting point
      * for searching within the tree data structure. The method ensures that the `startNode` is a valid
      * node before proceeding with the search operation. If the `
@@ -9646,75 +10257,58 @@ var dataStructureTyped = (() => {
       let predicate;
       const isRange = this.isRange(keyNodeEntryOrPredicate);
       if (isRange) {
-        predicate = (node) => keyNodeEntryOrPredicate.isInRange(node.key, this._comparator);
+        predicate = (node) => {
+          if (!node) return false;
+          return keyNodeEntryOrPredicate.isInRange(node.key, this._comparator);
+        };
       } else {
         predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
       }
-      const isToLeftByRange = (cur) => {
+      const shouldVisitLeft = (cur) => {
+        if (!cur) return false;
+        if (!this.isRealNode(cur.left)) return false;
         if (isRange) {
           const range = keyNodeEntryOrPredicate;
           const leftS = this.isReverse ? range.high : range.low;
           const leftI = this.isReverse ? range.includeHigh : range.includeLow;
           return leftI && this._compare(cur.key, leftS) >= 0 || !leftI && this._compare(cur.key, leftS) > 0;
         }
-        return false;
+        if (!isRange && !this._isPredicate(keyNodeEntryOrPredicate)) {
+          const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
+          return benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) > 0;
+        }
+        return true;
       };
-      const isToRightByRange = (cur) => {
+      const shouldVisitRight = (cur) => {
+        if (!cur) return false;
+        if (!this.isRealNode(cur.right)) return false;
         if (isRange) {
           const range = keyNodeEntryOrPredicate;
           const rightS = this.isReverse ? range.low : range.high;
           const rightI = this.isReverse ? range.includeLow : range.includeLow;
           return rightI && this._compare(cur.key, rightS) <= 0 || !rightI && this._compare(cur.key, rightS) < 0;
         }
-        return false;
+        if (!isRange && !this._isPredicate(keyNodeEntryOrPredicate)) {
+          const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
+          return benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) < 0;
+        }
+        return true;
       };
-      const ans = [];
-      if (iterationType === "RECURSIVE") {
-        const dfs = (cur) => {
-          if (predicate(cur)) {
-            ans.push(callback(cur));
-            if (onlyOne) return;
-          }
-          if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
-          if (isRange) {
-            if (this.isRealNode(cur.left) && isToLeftByRange(cur)) dfs(cur.left);
-            if (this.isRealNode(cur.right) && isToRightByRange(cur)) dfs(cur.right);
-          } else if (!this._isPredicate(keyNodeEntryOrPredicate)) {
-            const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
-            if (this.isRealNode(cur.left) && benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) > 0)
-              dfs(cur.left);
-            if (this.isRealNode(cur.right) && benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) < 0)
-              dfs(cur.right);
-          } else {
-            if (this.isRealNode(cur.left)) dfs(cur.left);
-            if (this.isRealNode(cur.right)) dfs(cur.right);
-          }
-        };
-        dfs(startNode);
-      } else {
-        const stack = [startNode];
-        while (stack.length > 0) {
-          const cur = stack.pop();
-          if (predicate(cur)) {
-            ans.push(callback(cur));
-            if (onlyOne) return ans;
-          }
-          if (isRange) {
-            if (this.isRealNode(cur.left) && isToLeftByRange(cur)) stack.push(cur.left);
-            if (this.isRealNode(cur.right) && isToRightByRange(cur)) stack.push(cur.right);
-          } else if (!this._isPredicate(keyNodeEntryOrPredicate)) {
-            const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
-            if (this.isRealNode(cur.right) && benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) < 0)
-              stack.push(cur.right);
-            if (this.isRealNode(cur.left) && benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) > 0)
-              stack.push(cur.left);
-          } else {
-            if (this.isRealNode(cur.right)) stack.push(cur.right);
-            if (this.isRealNode(cur.left)) stack.push(cur.left);
-          }
+      return super._dfs(
+        callback,
+        "IN",
+        onlyOne,
+        startNode,
+        iterationType,
+        false,
+        shouldVisitLeft,
+        shouldVisitRight,
+        () => true,
+        (cur) => {
+          if (cur) return predicate(cur);
+          return false;
         }
-      }
-      return ans;
+      );
     }
     /**
      * Time Complexity: O(log n)
@@ -9725,9 +10319,9 @@ var dataStructureTyped = (() => {
      * either a `Range` object or an array of two elements representing the range boundaries.
      * @param {C} callback - The `callback` parameter in the `rangeSearch` function is a callback
      * function that is used to process each node that is found within the specified range during the
-     * search operation. It is of type `NodeCallback<BSTNode<K, V>>`, where `BSTNode<K, V>` is the type of nodes in the
+     * search operation. It is of type `NodeCallback<BSTNode<K, V> | null>`, where `BSTNode<K, V>` is the type of nodes in the
      * data structure.
-     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter in the `rangeSearch`
+     * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `rangeSearch`
      * function represents the node from which the search for nodes within the specified range will
      * begin. It is the starting point for the range search operation.
      * @param {IterationType} iterationType - The `iterationType` parameter in the `rangeSearch` function
@@ -9746,8 +10340,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(log n)
      *
      * This function retrieves a node based on a given keyNodeEntryOrPredicate within a binary search tree structure.
-     * @param {BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The `keyNodeEntryOrPredicate`
-     * parameter can be of type `BTNRep<K, V, BSTNode<K, V>>`, `R`, or `NodePredicate<BSTNode<K, V>>`.
+     * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The `keyNodeEntryOrPredicate`
+     * parameter can be of type `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `, `R`, or `NodePredicate<BSTNode<K, V>>`.
      * @param {BSTNOptKeyOrNode<K, BSTNode<K, V>>} startNode - The `startNode` parameter in the `getNode` method
      * is used to specify the starting point for searching nodes in the binary search tree. If no
      * specific starting point is provided, the default value is set to `this._root`, which is the root
@@ -9769,24 +10363,30 @@ var dataStructureTyped = (() => {
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
-     * The function overrides the depth-first search method and returns an array of the return types of
-     * the callback function.
+     * The function `dfs` in TypeScript overrides the base class method with default parameters and
+     * returns the result of the super class `dfs` method.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
-     * during the depth-first search traversal. It is an optional parameter and defaults to
-     * `this._DEFAULT_NODE_CALLBACK`. The type `C` represents the type of the callback function.
-     * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
-     * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
-     * take one of the following values:
-     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
-     * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
-     * node entry. If not specified, the default value is the root of the tree.
-     * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
-     * type of iteration to be used during the Depth-First Search (DFS) traversal. It can have one of the
-     * following values:
-     * @returns The method is returning an array of the return type of the callback function.
+     * visited during the Depth-First Search traversal. It is a generic type `C` that extends the
+     * `NodeCallback` interface for `BSTNode<K, V>`. The default value for `callback` is `this._
+     * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `override dfs` method
+     * specifies the order in which the Depth-First Search (DFS) traversal should be performed on the
+     * Binary Search Tree (BST). The possible values for the `pattern` parameter are:
+     * @param {boolean} [onlyOne=false] - The `onlyOne` parameter in the `override dfs` method is a
+     * boolean flag that indicates whether you want to stop the depth-first search traversal after
+     * finding the first matching node or continue searching for all matching nodes. If `onlyOne` is set
+     * to `true`, the traversal will stop after finding
+     * @param {K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} startNode -
+     * The `startNode` parameter in the `override dfs` method can be one of the following types:
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `override dfs` method
+     * specifies the type of iteration to be performed during the Depth-First Search (DFS) traversal of a
+     * Binary Search Tree (BST). It is used to determine the order in which nodes are visited during the
+     * traversal. The possible values for `
+     * @returns The `override` function is returning the result of calling the `dfs` method from the
+     * superclass, with the provided arguments `callback`, `pattern`, `onlyOne`, `startNode`, and
+     * `iterationType`. The return type is an array of the return type of the callback function `C`.
      */
-    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", startNode = this._root, iterationType = this.iterationType) {
-      return super.dfs(callback, pattern, startNode, iterationType);
+    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+      return super.dfs(callback, pattern, onlyOne, startNode, iterationType);
     }
     /**
      * Time complexity: O(n)
@@ -9797,7 +10397,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * visited during the breadth-first search. It should take a single argument, which is the current
      * node being visited, and it can return a value of any type.
-     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
+     * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
      * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
      * object. If no value is provided, the default value is the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -9815,9 +10415,9 @@ var dataStructureTyped = (() => {
      * The function overrides the listLevels method from the superclass and returns an array of arrays
      * containing the results of the callback function applied to each level of the tree.
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
-     * `NodeCallback<BSTNode<K, V>>`. It represents a callback function that will be called for each node in the
+     * `NodeCallback<BSTNode<K, V> | null>`. It represents a callback function that will be called for each node in the
      * tree during the iteration process.
-     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
+     * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
      * point for listing the levels of the binary tree. It can be either a root node of the tree, a
      * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
      * value is provided, the root of
@@ -9841,7 +10441,7 @@ var dataStructureTyped = (() => {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
      * 0, or 1, where:
-     * @param {BTNRep<K, V, BSTNode<K, V>>} targetNode - The `targetNode` parameter is the node in
+     * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } targetNode - The `targetNode` parameter is the node in
      * the binary tree that you want to start traversing from. It can be specified either by providing
      * the key of the node, the node itself, or an entry containing the key and value of the node. If no
      * `targetNode` is provided,
@@ -9867,7 +10467,7 @@ var dataStructureTyped = (() => {
         return ans;
       } else {
         const queue = new Queue([this._root]);
-        while (queue.size > 0) {
+        while (queue.length > 0) {
           const cur = queue.shift();
           if (this.isRealNode(cur)) {
             const compared = this._compare(cur.key, targetKey);
@@ -9900,8 +10500,8 @@ var dataStructureTyped = (() => {
           if (l > r) return;
           const m = l + Math.floor((r - l) / 2);
           const midNode = sorted[m];
-          if (this._isMapMode) this.add(midNode.key);
-          else this.add([midNode.key, midNode.value]);
+          if (this._isMapMode && midNode !== null) this.add(midNode.key);
+          else if (midNode !== null) this.add([midNode.key, midNode.value]);
           buildBalanceBST(l, m - 1);
           buildBalanceBST(m + 1, r);
         };
@@ -9916,8 +10516,8 @@ var dataStructureTyped = (() => {
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
               const midNode = sorted[m];
-              if (this._isMapMode) this.add(midNode.key);
-              else this.add([midNode.key, midNode.value]);
+              if (this._isMapMode && midNode !== null) this.add(midNode.key);
+              else if (midNode !== null) this.add([midNode.key, midNode.value]);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
             }
@@ -10020,8 +10620,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - A variable that can be of
-     * type R or BTNRep<K, V, BSTNode<K, V>>. It represents either a key, a node, an entry, or a raw
+     * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - A variable that can be of
+     * type R or K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  . It represents either a key, a node, an entry, or a raw
      * element.
      * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
      * value associated with a key in a key-value pair.
@@ -10669,7 +11269,8 @@ var dataStructureTyped = (() => {
      * This TypeScript constructor initializes an AVLTree with keys, nodes, entries, or raw data provided
      * in an iterable format.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-     * iterable that can contain either `BTNRep<K, V, AVLTreeNode<K, V>>` objects or `R` objects. It is
+     * iterable that can contain either `
+     K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined ` objects or `R` objects. It is
      * used to initialize the AVLTree with key-value pairs or raw data entries. If provided
      * @param [options] - The `options` parameter in the constructor is of type `AVLTreeOptions<K, V,
      * R>`. It is an optional parameter that allows you to specify additional options for configuring the
@@ -10719,8 +11320,9 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of AVLTreeNode.
-     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeNode<K, V>>`.
+     * @param {K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `
+     K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `.
      * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `AVLTreeNode` class.
      */
@@ -10733,8 +11335,9 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a class and inserts a key-value pair into a data
      * structure, then balances the path.
-     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can accept values of type `R`, `BTNRep<K, V, AVLTreeNode<K, V>>`
+     * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept values of type `R`, `
+     K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key or node being added to the data structure.
      * @returns The method is returning a boolean value.
@@ -10751,7 +11354,7 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the delete method in a TypeScript class, performs deletion, and then
      * balances the tree if necessary.
-     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
+     * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `override delete` method can be one of the following types:
      * @returns The `delete` method is being overridden in this code snippet. It first calls the `delete`
      * method from the superclass (presumably a parent class) with the provided `predicate`, which could
@@ -11035,8 +11638,9 @@ var dataStructureTyped = (() => {
      *
      * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
      * to restore balance in an AVL tree after inserting a node.
-     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} node - The `node` parameter can be of type `R` or
-     * `BTNRep<K, V, AVLTreeNode<K, V>>`.
+     * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } node - The `node` parameter can be of type `R` or
+     * `
+     K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `.
      */
     _balancePath(node) {
       node = this.ensureNode(node);
@@ -11129,7 +11733,7 @@ var dataStructureTyped = (() => {
      * This TypeScript constructor initializes a Red-Black Tree with optional keys, nodes, entries, or
      * raw data.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-     * iterable that can contain either `BTNRep<K, V, RedBlackTreeNode<K, V>>` objects or `R` objects. It
+     * iterable that can contain either `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined` objects or `R` objects. It
      * is used to initialize the Red-Black Tree with keys, nodes, entries, or
      * @param [options] - The `options` parameter in the constructor is of type `RedBlackTreeOptions<K,
      * V, R>`. It is an optional parameter that allows you to specify additional options for the
@@ -11189,8 +11793,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
+     * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
      * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `RedBlackTreeNode` class.
      */
@@ -11214,8 +11818,8 @@ var dataStructureTyped = (() => {
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can accept a value of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
+     * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept a value of type `R` or `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key in the data structure. It represents the value that you want to add or update in the data
      * structure.
@@ -11249,7 +11853,7 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the delete method in a binary tree data structure to remove a node based on
      * a given predicate and maintain the binary search tree properties.
-     * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
+     * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `override delete` method is used to specify the condition or key based on which a
      * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
      * function that determines which node(s) should be deleted.
@@ -11692,63 +12296,77 @@ var dataStructureTyped = (() => {
         iterationType: this.iterationType,
         specifyComparable: this._specifyComparable,
         toEntryFn: this._toEntryFn,
-        isReverse: this._isReverse
+        isReverse: this._isReverse,
+        isMapMode: this._isMapMode
       }, options));
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `createNode` overrides the method to create a new AVLTreeMultiMapNode with a
-     * specified key and an empty array of values.
-     * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
-     * that will be created in the AVLTreeMultiMap.
-     * @returns An AVLTreeMultiMapNode object is being returned, initialized with the provided key and an
-     * empty array.
+     * The `createNode` function in TypeScript overrides the default implementation to create a new
+     * AVLTreeMultiMapNode with a specified key and value array.
+     * @param {K} key - The `key` parameter represents the key of the node being created in the
+     * AVLTreeMultiMap.
+     * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
+     * values associated with a specific key in the AVLTreeMultiMapNode. If no value is provided when
+     * calling the method, an empty array `[]` is used as the default value.
+     * @returns An AVLTreeMultiMapNode object is being returned, with the specified key and value. If the
+     * AVLTreeMultiMap is in map mode, an empty array is used as the value, otherwise the provided value
+     * array is used.
      */
-    createNode(key) {
-      return new AVLTreeMultiMapNode(key, []);
+    createNode(key, value = []) {
+      return new AVLTreeMultiMapNode(key, this._isMapMode ? [] : value);
     }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
-     * The function `add` in TypeScript overrides the superclass method to add key-value pairs to an AVL
-     * tree multi-map.
-     * @param {BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `override add` method can be either a key-value pair entry or just a key. If it
-     * is a key-value pair entry, it will be in the format `[key, values]`, where `key` is the key and
-     * `values`
-     * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
-     * you want to add to the AVLTreeMultiMap. It can be a single value or an array of values associated
-     * with a specific key.
-     * @returns The `override add` method is returning a boolean value, which indicates whether the
-     * addition operation was successful or not.
+     * The function `add` in this TypeScript code overrides the superclass method to add key-value pairs
+     * to an AVLTreeMultiMap, handling different input types and scenarios.
+     * @param [key] - The `key` parameter in the `override add` method represents the key of the entry to
+     * be added to the AVLTreeMultiMap. It can be of type `K`, which is the key type of the map. The key
+     * can be a single key value, a node of the AVLTree
+     * @param {V[]} [values] - The `values` parameter in the `add` method represents an array of values
+     * that you want to add to the AVLTreeMultiMap. It can contain one or more values associated with a
+     * specific key.
+     * @returns The `add` method is returning a boolean value, which indicates whether the operation was
+     * successful or not.
      */
     add(keyNodeOrEntry, value) {
       if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
       const _commonAdd = (key, values) => {
         if (key === void 0 || key === null) return false;
-        const existingValues = this.get(key);
-        if (existingValues !== void 0 && values !== void 0) {
-          for (const value2 of values) existingValues.push(value2);
-          return true;
-        }
-        const existingNode = this.getNode(key);
-        if (this.isRealNode(existingNode)) {
-          if (existingValues === void 0) {
-            super.add(key, values);
-            return true;
-          }
-          if (values !== void 0) {
+        const _addToValues = () => {
+          const existingValues = this.get(key);
+          if (existingValues !== void 0 && values !== void 0) {
             for (const value2 of values) existingValues.push(value2);
             return true;
+          }
+          return false;
+        };
+        const _addByNode = () => {
+          const existingNode = this.getNode(key);
+          if (this.isRealNode(existingNode)) {
+            const existingValues = this.get(existingNode);
+            if (existingValues === void 0) {
+              super.add(key, values);
+              return true;
+            }
+            if (values !== void 0) {
+              for (const value2 of values) existingValues.push(value2);
+              return true;
+            } else {
+              return false;
+            }
           } else {
-            return false;
+            return super.add(key, values);
           }
-        } else {
-          return super.add(key, values);
+        };
+        if (this._isMapMode) {
+          return _addByNode() || _addToValues();
         }
+        return _addToValues() || _addByNode();
       };
       if (this.isEntry(keyNodeOrEntry)) {
         const [key, values] = keyNodeOrEntry;
@@ -11762,7 +12380,7 @@ var dataStructureTyped = (() => {
      *
      * The function `deleteValue` removes a specific value from a key in an AVLTreeMultiMap data
      * structure and deletes the entire node if no values are left for that key.
-     * @param {BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+     * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `deleteValue` function can be either a `BTNRep` object representing a key-value
      * pair in the AVLTreeMultiMapNode, or just the key itself.
      * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
@@ -11848,7 +12466,7 @@ var dataStructureTyped = (() => {
      * additional options for configuring the TreeMultiMap instance.
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
-      super([], __spreadProps(__spreadValues({}, options), { isMapMode: true }));
+      super([], __spreadValues({}, options));
       if (keysNodesEntriesOrRaws) {
         this.addMany(keysNodesEntriesOrRaws);
       }
@@ -11871,35 +12489,38 @@ var dataStructureTyped = (() => {
         iterationType: this.iterationType,
         specifyComparable: this._specifyComparable,
         toEntryFn: this._toEntryFn,
-        isReverse: this._isReverse
+        isReverse: this._isReverse,
+        isMapMode: this._isMapMode
       }, options));
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `createNode` overrides the method to create a new `TreeMultiMapNode` with a specified
-     * key and an empty array of values.
-     * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
-     * that will be created in the TreeMultiMap data structure.
-     * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned, with the specified key and
-     * an empty array as its value.
+     * The function `createNode` overrides the creation of a new TreeMultiMapNode with a specified key
+     * and value array.
+     * @param {K} key - The `key` parameter represents the key of the node being created in the
+     * `TreeMultiMap`.
+     * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
+     * values associated with a specific key in the TreeMultiMap data structure.
+     * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned with the specified key and
+     * value. If `_isMapMode` is true, an empty array is passed as the value, otherwise the provided
+     * value is used.
      */
-    createNode(key) {
-      return new TreeMultiMapNode(key, []);
+    createNode(key, value = []) {
+      return new TreeMultiMapNode(key, this._isMapMode ? [] : value);
     }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
-     * The function `add` in TypeScript overrides the superclass method to add key-value pairs to a
-     * TreeMultiMapNode, handling different input types and scenarios.
-     * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `override add` method can be either a `BTNRep` object containing a key, an array
-     * of values, and a `TreeMultiMapNode`, or just a key.
-     * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
-     * you want to add to the TreeMultiMap. If the key is already present in the map, the new value will
-     * be added to the existing list of values associated with that key. If the key is not present,
+     * The function overrides the add method to handle different types of input for a TreeMultiMap data
+     * structure.
+     * @param [key] - The `key` parameter in the `override add` method represents the key of the entry to
+     * be added to the TreeMultiMap. It can be of type `K`, which is the key type of the TreeMultiMap, or
+     * it can be a TreeMultiMapNode containing the key and its
+     * @param {V[]} [values] - The `values` parameter in the `add` method represents an array of values
+     * that you want to add to the TreeMultiMap. It can contain one or more values of type `V`.
      * @returns The `add` method is returning a boolean value, which indicates whether the operation was
      * successful or not.
      */
@@ -11907,26 +12528,36 @@ var dataStructureTyped = (() => {
       if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
       const _commonAdd = (key, values) => {
         if (key === void 0 || key === null) return false;
-        const existingValues = this.get(key);
-        if (existingValues !== void 0 && values !== void 0) {
-          for (const value2 of values) existingValues.push(value2);
-          return true;
-        }
-        const existingNode = this.getNode(key);
-        if (this.isRealNode(existingNode)) {
-          if (existingValues === void 0) {
-            super.add(key, values);
-            return true;
-          }
-          if (values !== void 0) {
+        const _addToValues = () => {
+          const existingValues = this.get(key);
+          if (existingValues !== void 0 && values !== void 0) {
             for (const value2 of values) existingValues.push(value2);
             return true;
+          }
+          return false;
+        };
+        const _addByNode = () => {
+          const existingNode = this.getNode(key);
+          if (this.isRealNode(existingNode)) {
+            const existingValues = this.get(existingNode);
+            if (existingValues === void 0) {
+              super.add(key, values);
+              return true;
+            }
+            if (values !== void 0) {
+              for (const value2 of values) existingValues.push(value2);
+              return true;
+            } else {
+              return false;
+            }
           } else {
-            return false;
+            return super.add(key, values);
           }
-        } else {
-          return super.add(key, values);
+        };
+        if (this._isMapMode) {
+          return _addByNode() || _addToValues();
         }
+        return _addToValues() || _addByNode();
       };
       if (this.isEntry(keyNodeOrEntry)) {
         const [key, values] = keyNodeOrEntry;
@@ -11940,7 +12571,7 @@ var dataStructureTyped = (() => {
      *
      * The function `deleteValue` removes a specific value from a key in a TreeMultiMap data structure
      * and deletes the entire node if no values are left for that key.
-     * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+     * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `deleteValue` function can be either a `BTNRep` object containing a key and an
      * array of values, or just a key itself.
      * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
@@ -12049,7 +12680,7 @@ var dataStructureTyped = (() => {
      */
     getComputedCount() {
       let sum = 0;
-      this.dfs((node) => sum += node.count);
+      this.dfs((node) => sum += node ? node.count : 0);
       return sum;
     }
     /**
@@ -12086,8 +12717,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of the TreeCounterNode class.
-     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
      * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `TreeCounterNode` class.
      */
@@ -12100,7 +12731,7 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a class and adds a new node to a data structure, updating
      * the count and returning a boolean indicating success.
-     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
      * `keyNodeOrEntry` parameter can accept one of the following types:
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
@@ -12127,7 +12758,7 @@ var dataStructureTyped = (() => {
      *
      * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
      * structure, handling cases where nodes have children and maintaining balance in the tree.
-     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `predicate`
      * parameter in the `delete` method is used to specify the condition or key based on which a node
      * should be deleted from the binary tree. It can be a key, a node, or an entry.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
@@ -12253,8 +12884,8 @@ var dataStructureTyped = (() => {
           if (l > r) return;
           const m = l + Math.floor((r - l) / 2);
           const midNode = sorted[m];
-          if (this._isMapMode) this.add(midNode.key, void 0, midNode.count);
-          else this.add(midNode.key, midNode.value, midNode.count);
+          if (this._isMapMode && midNode !== null) this.add(midNode.key, void 0, midNode.count);
+          else if (midNode !== null) this.add(midNode.key, midNode.value, midNode.count);
           buildBalanceBST(l, m - 1);
           buildBalanceBST(m + 1, r);
         };
@@ -12269,8 +12900,8 @@ var dataStructureTyped = (() => {
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
               const midNode = sorted[m];
-              if (this._isMapMode) this.add(midNode.key, void 0, midNode.count);
-              else this.add(midNode.key, midNode.value, midNode.count);
+              if (this._isMapMode && midNode !== null) this.add(midNode.key, void 0, midNode.count);
+              else if (midNode !== null) this.add(midNode.key, midNode.value, midNode.count);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
             }
@@ -12288,7 +12919,7 @@ var dataStructureTyped = (() => {
      */
     clone() {
       const cloned = this.createTree();
-      this.bfs((node) => cloned.add(node.key, void 0, node.count));
+      this.bfs((node) => cloned.add(node === null ? null : node.key, void 0, node === null ? 0 : node.count));
       if (this._isMapMode) cloned._store = this._store;
       return cloned;
     }
@@ -12318,8 +12949,8 @@ var dataStructureTyped = (() => {
     /**
      * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
      * @param {V} [value] - The `value` parameter is an optional value that represents the value
      * associated with the key in the node. It is used when creating a new node or updating the value of
      * an existing node.
@@ -12495,8 +13126,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of AVLTreeCounterNode.
-     * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeCounterNode<K, V>>`.
+     * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
      * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `AVLTreeCounterNode` class.
      */
@@ -12509,9 +13140,9 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a TypeScript class to add a new node to a data structure
      * and update the count.
-     * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The
+     * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
      * `keyNodeOrEntry` parameter can accept a value of type `R`, which can be any type. It
-     * can also accept a value of type `BTNRep<K, V, AVLTreeCounterNode<K, V>>`, which represents a key, node,
+     * can also accept a value of type `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`, which represents a key, node,
      * entry, or raw element
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
@@ -12536,7 +13167,7 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the delete method in a binary tree data structure, handling deletion of
      * nodes and maintaining balance in the tree.
-     * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
+     * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `predicate`
      * parameter in the `delete` method is used to specify the condition for deleting a node from the
      * binary tree. It can be a key, node, or entry that determines which
      * node(s) should be deleted.
@@ -12611,6 +13242,7 @@ var dataStructureTyped = (() => {
     /**
      * 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} iterationType - The `iterationType` parameter is an optional parameter that
@@ -12698,8 +13330,8 @@ var dataStructureTyped = (() => {
     /**
      * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
      * a node object.
-     * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The
-     * `keyNodeOrEntry` parameter can be of type `R` or `BTNRep<K, V, AVLTreeCounterNode<K, V>>`.
+     * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
+     * `keyNodeOrEntry` parameter can be of type `R` or `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `override` function. It represents the value associated with the key in the data structure. If no
      * value is provided, it will default to `undefined`.
@@ -14026,6 +14658,9 @@ var dataStructureTyped = (() => {
       }
       yield* __yieldStar(_dfs(this.root, ""));
     }
+    get _total() {
+      return this._size;
+    }
     /**
      * Time Complexity: O(l), where l is the length of the input string.
      * Space Complexity: O(1) - Constant space.
@@ -14148,13 +14783,6 @@ var dataStructureTyped = (() => {
   };
   return __toCommonJS(src_exports);
 })();
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 /**
  * data-structure-typed
  *