data-structure-typed 1.53.5 → 1.53.7

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

@@ -131,6 +131,7 @@ var dataStructureTyped = (() => {
     Navigator: () => Navigator,
     PriorityQueue: () => PriorityQueue,
     Queue: () => Queue,
+    Range: () => Range,
     RedBlackTree: () => RedBlackTree,
     RedBlackTreeNode: () => RedBlackTreeNode,
     SegmentTree: () => SegmentTree,
@@ -670,7 +671,7 @@ var dataStructureTyped = (() => {
   };
   function isPrimitiveComparable(value) {
     const valueType = typeof value;
-    if (valueType === "number") return !Number.isNaN(value);
+    if (valueType === "number") return true;
     return valueType === "bigint" || valueType === "string" || valueType === "boolean";
   }
   function tryObjectToPrimitive(obj) {
@@ -691,7 +692,7 @@ var dataStructureTyped = (() => {
     if (value === null || value === void 0) return false;
     if (isPrimitiveComparable(value)) return true;
     if (typeof value !== "object") return false;
-    if (value instanceof Date) return !Number.isNaN(value.getTime());
+    if (value instanceof Date) return true;
     if (isForceObjectComparable) return true;
     const comparableValue = tryObjectToPrimitive(value);
     if (comparableValue === null || comparableValue === void 0) return false;
@@ -1562,33 +1563,17 @@ var dataStructureTyped = (() => {
     get size() {
       return this._size;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
-     * array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a `SinglyLinkedList` object.
-     */
-    static fromArray(data) {
-      const singlyLinkedList = new _SinglyLinkedList();
-      for (const item of data) {
-        singlyLinkedList.push(item);
-      }
-      return singlyLinkedList;
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The push function adds a new element to the end of a singly linked list.
-     * @param {E} element - The "element" parameter represents the value of the element that you want to
-     * add to the linked list.
-     * @returns The `push` method is returning a boolean value, `true`.
+     * The `push` function adds a new element or node to the end of a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the `push`
+     * method can accept either an element of type `E` or a `SinglyLinkedListNode<E>` object.
+     * @returns The `push` method is returning a boolean value, specifically `true`.
      */
-    push(element) {
-      const newNode = new SinglyLinkedListNode(element);
+    push(elementOrNode) {
+      const newNode = this._ensureNode(elementOrNode);
       if (!this.head) {
         this._head = newNode;
         this._tail = newNode;
@@ -1644,13 +1629,15 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The unshift function adds a new element to the beginning of a singly linked list.
-     * @param {E} element - The "element" parameter represents the value of the element that you want to
-     * add to the beginning of the singly linked list.
-     * @returns The `unshift` method is returning a boolean value, `true`.
+     * The unshift function adds a new element or node to the beginning of a singly linked list in
+     * TypeScript.
+     * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the
+     * `unshift` method can be either an element of type `E` or a `SinglyLinkedListNode` containing an
+     * element of type `E`.
+     * @returns The `unshift` method is returning a boolean value, specifically `true`.
      */
-    unshift(element) {
-      const newNode = new SinglyLinkedListNode(element);
+    unshift(elementOrNode) {
+      const newNode = this._ensureNode(elementOrNode);
       if (!this.head) {
         this._head = newNode;
         this._tail = newNode;
@@ -1661,6 +1648,27 @@ var dataStructureTyped = (() => {
       this._size++;
       return true;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * This function searches for a specific element in a singly linked list based on a given node or
+     * predicate.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `get` method can be one of
+     * the following types:
+     * @returns The `get` method returns the value of the first node in the singly linked list that
+     * satisfies the provided predicate function. If no such node is found, it returns `undefined`.
+     */
+    search(elementNodeOrPredicate) {
+      const predicate = this._ensurePredicate(elementNodeOrPredicate);
+      let current = this.head;
+      while (current) {
+        if (predicate(current)) return current.value;
+        current = current.next;
+      }
+      return void 0;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -1679,6 +1687,22 @@ var dataStructureTyped = (() => {
       }
       return current.value;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `isNode` in TypeScript checks if the input is an instance of `SinglyLinkedListNode`.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `isNode` function can be
+     * one of the following types:
+     * @returns The `isNode` function is checking if the `elementNodeOrPredicate` parameter is an
+     * instance of `SinglyLinkedListNode<E>`. If it is, the function returns `true`, indicating that the
+     * parameter is a `SinglyLinkedListNode<E>`. If it is not an instance of `SinglyLinkedListNode<E>`,
+     * the function returns `false`.
+     */
+    isNode(elementNodeOrPredicate) {
+      return elementNodeOrPredicate instanceof SinglyLinkedListNode;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -1727,18 +1751,18 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The delete function removes a node with a specific value from a singly linked list.
-     * @param {E | SinglyLinkedListNode<E>} valueOrNode - The `valueOrNode` parameter can accept either a value of type `E`
+     * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter can accept either a value of type `E`
      * or a `SinglyLinkedListNode<E>` object.
      * @returns The `delete` method returns a boolean value. It returns `true` if the value or node is found and
      * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
      */
-    delete(valueOrNode) {
-      if (valueOrNode === void 0) return false;
+    delete(elementOrNode) {
+      if (elementOrNode === void 0) return false;
       let value;
-      if (valueOrNode instanceof SinglyLinkedListNode) {
-        value = valueOrNode.value;
+      if (elementOrNode instanceof SinglyLinkedListNode) {
+        value = elementOrNode.value;
       } else {
-        value = valueOrNode;
+        value = elementOrNode;
       }
       let current = this.head, prev = void 0;
       while (current) {
@@ -1766,25 +1790,28 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `addAt` function inserts a value at a specified index in a singly linked list.
-     * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
-     * linked list. It is of type number.
-     * @param {E} value - The `value` parameter represents the value that you want to insert into the linked list at the
-     * specified index.
-     * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
-     * if the index is out of bounds.
+     * The `addAt` function inserts a new element or node at a specified index in a singly linked list.
+     * @param {number} index - The `index` parameter represents the position at which you want to add a
+     * new element or node in the linked list. It is a number that indicates the index where the new
+     * element or node should be inserted.
+     * @param {E | SinglyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter in the
+     * `addAt` method can be either a value of type `E` or a `SinglyLinkedListNode<E>` object. This
+     * parameter represents the element or node that you want to add to the linked list at the specified
+     * index.
+     * @returns The `addAt` method returns a boolean value - `true` if the element or node was
+     * successfully added at the specified index, and `false` if the index is out of bounds.
      */
-    addAt(index, value) {
+    addAt(index, newElementOrNode) {
       if (index < 0 || index > this._size) return false;
       if (index === 0) {
-        this.unshift(value);
+        this.unshift(newElementOrNode);
         return true;
       }
       if (index === this._size) {
-        this.push(value);
+        this.push(newElementOrNode);
         return true;
       }
-      const newNode = new SinglyLinkedListNode(value);
+      const newNode = this._ensureNode(newElementOrNode);
       const prevNode = this.getNodeAt(index - 1);
       newNode.next = prevNode.next;
       prevNode.next = newNode;
@@ -1848,16 +1875,21 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `indexOf` function returns the index of the first occurrence of a given value in a linked list.
-     * @param {E} value - The value parameter is the value that you want to find the index of in the linked list.
-     * @returns The method is returning the index of the first occurrence of the specified value in the linked list. If the
-     * value is not found, it returns -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(value) {
+    indexOf(elementNodeOrPredicate) {
+      const predicate = this._ensurePredicate(elementNodeOrPredicate);
       let index = 0;
       let current = this.head;
       while (current) {
-        if (current.value === value) {
+        if (predicate(current)) {
           return index;
         }
         index++;
@@ -1869,16 +1901,21 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function finds a node in a singly linked list by its value and returns the node if found, otherwise returns
-     * undefined.
-     * @param {E} value - The value parameter is the value that we want to search for in the linked list.
-     * @returns a `SinglyLinkedListNode<E>` if a node with the specified value is found in the linked list. If no node with
-     * the specified value is found, the function returns `undefined`.
+     * The function `getNode` in TypeScript searches for a node in a singly linked list based on a given
+     * element, node, or predicate.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean) | undefined} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `getNode` method can be one
+     * of the following types:
+     * @returns The `getNode` method returns either a `SinglyLinkedListNode<E>` if a matching node is
+     * found based on the provided predicate, or it returns `undefined` if no matching node is found or
+     * if the input parameter is `undefined`.
      */
-    getNode(value) {
+    getNode(elementNodeOrPredicate) {
+      if (elementNodeOrPredicate === void 0) return;
+      const predicate = this._ensurePredicate(elementNodeOrPredicate);
       let current = this.head;
       while (current) {
-        if (current.value === value) {
+        if (predicate(current)) {
           return current;
         }
         current = current.next;
@@ -1889,29 +1926,34 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `addBefore` function inserts a new value before an existing value in a singly linked list.
-     * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
-     * new value before. It can be either the value itself or a node containing the value in the linked list.
-     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
-     * @returns The method `addBefore` returns a boolean value. It returns `true` if the new value was successfully
-     * inserted before the existing value, and `false` otherwise.
+     * The function `addBefore` in TypeScript adds a new element or node before an existing element or
+     * node in a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} existingElementOrNode - existingElementOrNode represents the
+     * element or node in the linked list before which you want to add a new element or node.
+     * @param {E | SinglyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter in the
+     * `addBefore` method represents the element or node that you want to insert before the existing
+     * 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(existingValueOrNode, newValue) {
+    addBefore(existingElementOrNode, newElementOrNode) {
       if (!this.head) return false;
       let existingValue;
-      if (existingValueOrNode instanceof SinglyLinkedListNode) {
-        existingValue = existingValueOrNode.value;
+      if (this.isNode(existingElementOrNode)) {
+        existingValue = existingElementOrNode.value;
       } else {
-        existingValue = existingValueOrNode;
+        existingValue = existingElementOrNode;
       }
       if (this.head.value === existingValue) {
-        this.unshift(newValue);
+        this.unshift(newElementOrNode);
         return true;
       }
       let current = this.head;
       while (current.next) {
         if (current.next.value === existingValue) {
-          const newNode = new SinglyLinkedListNode(newValue);
+          const newNode = this._ensureNode(newElementOrNode);
           newNode.next = current.next;
           current.next = newNode;
           this._size++;
@@ -1925,22 +1967,22 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `addAfter` function inserts a new node with a given value after an existing node in a singly linked list.
-     * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
-     * the new value will be inserted. It can be either the value of the existing node or the existing node itself.
-     * @param {E} newValue - The value that you want to insert into the linked list after the existing value or node.
-     * @returns The method returns a boolean value. It returns true if the new value was successfully inserted after the
-     * existing value or node, and false if the existing value or node was not found in the linked list.
+     * The `addAfter` function in TypeScript adds a new element or node after an existing element or node
+     * in a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} existingElementOrNode - existingElementOrNode can be either
+     * an element of type E or a SinglyLinkedListNode of type E.
+     * @param {E | SinglyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter in the
+     * `addAfter` method represents the element or node that you want to add after the existing element
+     * or node in a singly linked list. This parameter can be either the value of the new element or a
+     * reference to a `SinglyLinkedListNode` containing
+     * @returns The `addAfter` method returns a boolean value - `true` if the new element or node was
+     * successfully added after the existing element or node, and `false` if the existing element or node
+     * was not found.
      */
-    addAfter(existingValueOrNode, newValue) {
-      let existingNode;
-      if (existingValueOrNode instanceof SinglyLinkedListNode) {
-        existingNode = existingValueOrNode;
-      } else {
-        existingNode = this.getNode(existingValueOrNode);
-      }
+    addAfter(existingElementOrNode, newElementOrNode) {
+      const existingNode = this.getNode(existingElementOrNode);
       if (existingNode) {
-        const newNode = new SinglyLinkedListNode(newValue);
+        const newNode = this._ensureNode(newElementOrNode);
         newNode.next = existingNode.next;
         existingNode.next = newNode;
         if (existingNode === this.tail) {
@@ -1955,15 +1997,19 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function counts the number of occurrences of a given value in a linked list.
-     * @param {E} value - The value parameter is the value that you want to count the occurrences of in the linked list.
-     * @returns The count of occurrences of the given value in the linked list.
+     * The function `countOccurrences` iterates through a singly linked list and counts the occurrences
+     * of a specified element or nodes that satisfy a given predicate.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementOrNode
+     * - The `elementOrNode` parameter in the `countOccurrences` method can accept three types of values:
+     * @returns The `countOccurrences` method returns the number of occurrences of the specified element,
+     * node, or predicate function in the singly linked list.
      */
-    countOccurrences(value) {
+    countOccurrences(elementOrNode) {
+      const predicate = this._ensurePredicate(elementOrNode);
       let count = 0;
       let current = this.head;
       while (current) {
-        if (current.value === value) {
+        if (predicate(current)) {
           count++;
         }
         current = current.next;
@@ -2049,6 +2095,61 @@ var dataStructureTyped = (() => {
         current = current.next;
       }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
+     * array.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+     * @returns The `fromArray` function returns a `SinglyLinkedList` object.
+     */
+    static fromArray(data) {
+      const singlyLinkedList = new _SinglyLinkedList();
+      for (const item of data) {
+        singlyLinkedList.push(item);
+      }
+      return singlyLinkedList;
+    }
+    /**
+     * The _isPredicate function in TypeScript checks if the input is a function that takes a
+     * SinglyLinkedListNode as an argument and returns a boolean.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter can be one of the following types:
+     * @returns The _isPredicate method is returning a boolean value based on whether the
+     * elementNodeOrPredicate parameter is a function or not. If the elementNodeOrPredicate is a
+     * function, the method will return true, indicating that it is a predicate function. If it is not a
+     * function, the method will return false.
+     */
+    _isPredicate(elementNodeOrPredicate) {
+      return typeof elementNodeOrPredicate === "function";
+    }
+    /**
+     * The function `_ensureNode` ensures that the input is a valid node and returns it, creating a new
+     * node if necessary.
+     * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter can be either
+     * an element of type `E` or a `SinglyLinkedListNode` containing an element of type `E`.
+     * @returns A SinglyLinkedListNode<E> object is being returned.
+     */
+    _ensureNode(elementOrNode) {
+      if (this.isNode(elementOrNode)) return elementOrNode;
+      return new SinglyLinkedListNode(elementOrNode);
+    }
+    /**
+     * The function `_ensurePredicate` in TypeScript ensures that the input is either a node, a predicate
+     * function, or a value to compare with the node's value.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter can be one of the following types:
+     * @returns A function is being returned. If the input `elementNodeOrPredicate` is already a node, a
+     * function is returned that checks if a given node is equal to the input node. If the input is a
+     * predicate function, it is returned as is. If the input is neither a node nor a predicate function,
+     * a function is returned that checks if a given node's value is equal to the input
+     */
+    _ensurePredicate(elementNodeOrPredicate) {
+      if (this.isNode(elementNodeOrPredicate)) return (node) => node === elementNodeOrPredicate;
+      if (this._isPredicate(elementNodeOrPredicate)) return elementNodeOrPredicate;
+      return (node) => node.value === elementNodeOrPredicate;
+    }
   };
 
   // src/data-structures/linked-list/doubly-linked-list.ts
@@ -2116,6 +2217,16 @@ var dataStructureTyped = (() => {
     }
   };
   var DoublyLinkedList = class _DoublyLinkedList extends IterableElementBase {
+    /**
+     * 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
+     * iterable collection of elements of type `E` or `R`. It is used to initialize the DoublyLinkedList
+     * with the elements provided in the iterable. If no elements are provided, the default value is an
+     * empty iterable.
+     * @param [options] - The `options` parameter in the constructor is of type
+     * `DoublyLinkedListOptions<E, R>`. It is an optional parameter that allows you to pass additional
+     * configuration options to customize the behavior of the DoublyLinkedList.
+     */
     constructor(elements = [], options) {
       super(options);
       __publicField(this, "_head");
@@ -2395,12 +2506,7 @@ var dataStructureTyped = (() => {
      * node was not found.
      */
     addBefore(existingElementOrNode, newElementOrNode) {
-      let existingNode;
-      if (existingElementOrNode instanceof DoublyLinkedListNode) {
-        existingNode = existingElementOrNode;
-      } else {
-        existingNode = this.getNode(existingElementOrNode);
-      }
+      const existingNode = this.isNode(existingElementOrNode) ? existingElementOrNode : this.getNode(existingElementOrNode);
       if (existingNode) {
         const newNode = this._ensureNode(newElementOrNode);
         newNode.prev = existingNode.prev;
@@ -2434,12 +2540,7 @@ var dataStructureTyped = (() => {
      * was not found in the linked list.
      */
     addAfter(existingElementOrNode, newElementOrNode) {
-      let existingNode;
-      if (existingElementOrNode instanceof DoublyLinkedListNode) {
-        existingNode = existingElementOrNode;
-      } else {
-        existingNode = this.getNode(existingElementOrNode);
-      }
+      const existingNode = this.isNode(existingElementOrNode) ? existingElementOrNode : this.getNode(existingElementOrNode);
       if (existingNode) {
         const newNode = this._ensureNode(newElementOrNode);
         newNode.next = existingNode.next;
@@ -2540,17 +2641,15 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The indexOf function in TypeScript returns the index of a specified element or node in a Doubly
-     * Linked List.
-     * @param {E | DoublyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the
-     * `indexOf` method can be either an element of type `E` or a `DoublyLinkedListNode` containing an
-     * element of type `E`.
-     * @returns The `indexOf` method is returning the index of the element or node in the doubly linked
-     * list. If the element or node is found in the list, the method returns the index of that element or
-     * node. If the element or node is not found in the list, the method returns -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(elementOrNode) {
-      const predicate = this._ensurePredicate(elementOrNode);
+    indexOf(elementNodeOrPredicate) {
+      const predicate = this._ensurePredicate(elementNodeOrPredicate);
       let index = 0;
       let current = this.head;
       while (current) {
@@ -2566,8 +2665,6 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     */
-    /**
      * This function retrieves an element from a doubly linked list based on a given element
      * node or predicate.
      * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
@@ -2576,7 +2673,7 @@ var dataStructureTyped = (() => {
      * @returns The `get` method returns the value of the first node in the doubly linked list that
      * satisfies the provided predicate function. If no such node is found, it returns `undefined`.
      */
-    get(elementNodeOrPredicate) {
+    search(elementNodeOrPredicate) {
       const predicate = this._ensurePredicate(elementNodeOrPredicate);
       let current = this.head;
       while (current) {
@@ -2724,6 +2821,23 @@ var dataStructureTyped = (() => {
       }
       return mappedList;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     */
+    countOccurrences(elementOrNode) {
+      const predicate = this._ensurePredicate(elementOrNode);
+      let count = 0;
+      let current = this.head;
+      while (current) {
+        if (predicate(current)) {
+          count++;
+        }
+        current = current.next;
+      }
+      return count;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -6994,12 +7108,26 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/constants/index.ts
+  // src/common/index.ts
   var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
     DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
     DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
     return DFSOperation2;
   })(DFSOperation || {});
+  var Range = class {
+    constructor(low, high, includeLow = true, includeHigh = true) {
+      this.low = low;
+      this.high = high;
+      this.includeLow = includeLow;
+      this.includeHigh = includeHigh;
+    }
+    // Determine whether a key is within the range
+    isInRange(key, comparator) {
+      const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+      const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+      return lowCheck && highCheck;
+    }
+  };
 
   // src/data-structures/binary-tree/binary-tree.ts
   var BinaryTreeNode = class {
@@ -7143,15 +7271,12 @@ var dataStructureTyped = (() => {
         const finalValue = value != null ? value : entryValue;
         return [this.createNode(key, finalValue), finalValue];
       }
-      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
       if (this.isRaw(keyNodeEntryOrRaw)) {
-        if (this._toEntryFn) {
-          const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-          const finalValue = value != null ? value : entryValue;
-          if (this.isKey(key)) return [this.createNode(key, finalValue), finalValue];
-        }
-        return [void 0, void 0];
+        const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+        const finalValue = value != null ? value : entryValue;
+        if (this.isKey(key)) return [this.createNode(key, finalValue), finalValue];
       }
+      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
       return [void 0, void 0];
     }
     /**
@@ -7178,13 +7303,13 @@ var dataStructureTyped = (() => {
         const key = keyNodeEntryOrRaw[0];
         if (key === null) return null;
         if (key === void 0) return;
-        return this.getNodeByKey(key, iterationType);
+        return this.getNode(key, this._root, iterationType);
       }
       if (this._toEntryFn) {
         const [key] = this._toEntryFn(keyNodeEntryOrRaw);
-        if (this.isKey(key)) return this.getNodeByKey(key);
+        if (this.isKey(key)) return this.getNode(key);
       }
-      if (this.isKey(keyNodeEntryOrRaw)) return this.getNodeByKey(keyNodeEntryOrRaw, iterationType);
+      if (this.isKey(keyNodeEntryOrRaw)) return this.getNode(keyNodeEntryOrRaw, this._root, iterationType);
       return;
     }
     /**
@@ -7201,8 +7326,15 @@ var dataStructureTyped = (() => {
     isNode(keyNodeEntryOrRaw) {
       return keyNodeEntryOrRaw instanceof BinaryTreeNode;
     }
+    /**
+     * The function `isRaw` checks if the input parameter is of type `R` by verifying if it is an object.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - BTNRep<K, V, NODE> | R
+     * @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`.
+     */
     isRaw(keyNodeEntryOrRaw) {
-      return typeof keyNodeEntryOrRaw === "object";
+      return this._toEntryFn !== void 0 && typeof keyNodeEntryOrRaw === "object";
     }
     /**
      * The function `isRealNode` checks if a given input is a valid node in a binary tree.
@@ -7240,6 +7372,9 @@ var dataStructureTyped = (() => {
     isNIL(keyNodeEntryOrRaw) {
       return keyNodeEntryOrRaw === this._NIL;
     }
+    isRange(keyNodeEntryRawOrPredicate) {
+      return keyNodeEntryRawOrPredicate instanceof Range;
+    }
     /**
      * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
      * tree.
@@ -7378,6 +7513,17 @@ var dataStructureTyped = (() => {
       }
       return inserted;
     }
+    /**
+     * Time Complexity: O(k * n)
+     * Space Complexity: O(1)
+     *
+     * The `merge` function in TypeScript merges another binary tree into the current tree by adding all
+     * elements from the other tree.
+     * @param anotherTree - `BinaryTree<K, V, R, NODE, TREE>`
+     */
+    merge(anotherTree) {
+      this.addMany(anotherTree, []);
+    }
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -7452,34 +7598,37 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(k + log n)
      *
-     * 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, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
-     * - 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
-     * `keyNodeEntryRawOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
-     * @param {BTNRep<K, V, NODE> | R} 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
-     * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` function
-     * determines the type of iteration to be performed when traversing the nodes of a binary tree. It
-     * can have two possible values:
-     * @returns The `getNodes` function returns an array of nodes that satisfy the provided condition
-     * based on the input parameters and the iteration type specified.
-     */
-    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+     * 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, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
+     * `keyNodeEntryRawOrPredicate` 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<NODE>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
+     * @param {BTNRep<K, V, NODE> | R} 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
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `search` function
+     * specifies the type of iteration to be used when searching for nodes in a binary tree. It can have
+     * two possible values:
+     * @returns The `search` function returns an array of values that match the provided criteria based
+     * on the search algorithm implemented within the function.
+     */
+    search(keyNodeEntryRawOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
       if (keyNodeEntryRawOrPredicate === void 0) return [];
       if (keyNodeEntryRawOrPredicate === null) return [];
       startNode = this.ensureNode(startNode);
       if (!startNode) return [];
-      const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+      const predicate = this._ensurePredicate(keyNodeEntryRawOrPredicate);
       const ans = [];
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
-          if (callback(cur)) {
-            ans.push(cur);
+          if (predicate(cur)) {
+            ans.push(callback(cur));
             if (onlyOne) return;
           }
           if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
@@ -7492,8 +7641,8 @@ var dataStructureTyped = (() => {
         while (stack.length > 0) {
           const cur = stack.pop();
           if (this.isRealNode(cur)) {
-            if (callback(cur)) {
-              ans.push(cur);
+            if (predicate(cur)) {
+              ans.push(callback(cur));
               if (onlyOne) return ans;
             }
             if (this.isRealNode(cur.left)) stack.push(cur.left);
@@ -7503,6 +7652,30 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(k + log n)
+     *
+     * 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, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
+     * - 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
+     * `keyNodeEntryRawOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
+     * @param {BTNRep<K, V, NODE> | R} 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
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` function
+     * determines the type of iteration to be performed when traversing the nodes of a binary tree. It
+     * can have two possible values:
+     * @returns The `getNodes` function returns an array of nodes that satisfy the provided condition
+     * based on the input parameters and the iteration type specified.
+     */
+    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+      return this.search(keyNodeEntryRawOrPredicate, onlyOne, (node) => node, startNode, iterationType);
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
@@ -7525,23 +7698,7 @@ var dataStructureTyped = (() => {
      */
     getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
       var _a;
-      return (_a = this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0]) != null ? _a : null;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     *
-     * The function `getNodeByKey` retrieves a node by its key from a binary tree structure.
-     * @param {K} key - The `key` parameter is the value used to search for a specific node in a data
-     * structure.
-     * @param {IterationType} iterationType - The `iterationType` parameter is a type of iteration that
-     * specifies how the tree nodes should be traversed when searching for a node with the given key. It
-     * is an optional parameter with a default value of `this.iterationType`.
-     * @returns The `getNodeByKey` function is returning an optional binary tree node
-     * (`OptNodeOrNull<NODE>`).
-     */
-    getNodeByKey(key, iterationType = this.iterationType) {
-      return this.getNode(key, this._root, iterationType);
+      return (_a = this.search(keyNodeEntryRawOrPredicate, true, (node) => node, startNode, iterationType)[0]) != null ? _a : null;
     }
     /**
      * Time Complexity: O(n)
@@ -7568,7 +7725,7 @@ var dataStructureTyped = (() => {
     get(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
       var _a;
       if (this._isMapMode) {
-        const key = this._getKey(keyNodeEntryRawOrPredicate);
+        const key = this._extractKey(keyNodeEntryRawOrPredicate);
         if (key === null || key === void 0) return;
         return this._store.get(key);
       }
@@ -7596,7 +7753,7 @@ var dataStructureTyped = (() => {
      * Otherwise, it returns `false`.
      */
     has(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-      return this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType).length > 0;
+      return this.search(keyNodeEntryRawOrPredicate, true, (node) => node, startNode, iterationType).length > 0;
     }
     /**
      * Time Complexity: O(1)
@@ -7835,7 +7992,7 @@ var dataStructureTyped = (() => {
      * array is either in reverse order or in the original order based on the value of the `isReverse`
      * parameter.
      */
-    getPathToRoot(callback = this._DEFAULT_NODE_CALLBACK, beginNode, isReverse = true) {
+    getPathToRoot(beginNode, callback = this._DEFAULT_NODE_CALLBACK, isReverse = false) {
       const result = [];
       let beginNodeEnsured = this.ensureNode(beginNode);
       if (!beginNodeEnsured) return result;
@@ -8760,16 +8917,16 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_getKey` in TypeScript returns the key from a given input, which can be a node,
+     * 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, NODE> | R} keyNodeEntryOrRaw - The `_getKey` method you provided is a
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_extractKey` method you provided is a
      * TypeScript method that takes in a parameter `keyNodeEntryOrRaw` of type `BTNRep<K, V, NODE> | R`,
      * where `BTNRep` is a generic type with keys `K`, `V`, and `NODE`, and `
-     * @returns The `_getKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
+     * @returns The `_extractKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
      * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on
      * the conditions checked in the method.
      */
-    _getKey(keyNodeEntryOrRaw) {
+    _extractKey(keyNodeEntryOrRaw) {
       if (keyNodeEntryOrRaw === null) return null;
       if (keyNodeEntryOrRaw === void 0) return;
       if (keyNodeEntryOrRaw === this._NIL) return;
@@ -8804,6 +8961,9 @@ var dataStructureTyped = (() => {
       return this._store.set(key, value);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The _clearNodes function sets the root node to undefined and resets the size to 0.
      */
     _clearNodes() {
@@ -8811,6 +8971,9 @@ var dataStructureTyped = (() => {
       this._size = 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The _clearValues function clears all values stored in the _store object.
      */
     _clearValues() {
@@ -8879,20 +9042,30 @@ var dataStructureTyped = (() => {
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       __publicField(this, "_root");
-      __publicField(this, "_DEFAULT_COMPARATOR", (a, b) => {
+      __publicField(this, "_isReverse", false);
+      __publicField(this, "_comparator", (a, b) => {
+        if (isComparable(a) && isComparable(b)) {
+          if (a > b) return 1;
+          if (a < b) return -1;
+          return 0;
+        }
+        if (this._extractComparable) {
+          if (this._extractComparable(a) > this._extractComparable(b)) return 1;
+          if (this._extractComparable(a) < this._extractComparable(b)) return -1;
+          return 0;
+        }
         if (typeof a === "object" || typeof b === "object") {
           throw TypeError(
-            `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
+            `When comparing object types, a custom extractComparable must be defined in the constructor's options parameter.`
           );
         }
-        if (a > b) return 1;
-        if (a < b) return -1;
         return 0;
       });
-      __publicField(this, "_comparator", this._DEFAULT_COMPARATOR);
+      __publicField(this, "_extractComparable");
       if (options) {
-        const { comparator } = options;
-        if (comparator) this._comparator = comparator;
+        const { extractComparable, isReverse } = options;
+        if (typeof extractComparable === "function") this._extractComparable = extractComparable;
+        if (isReverse !== void 0) this._isReverse = isReverse;
       }
       if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
     }
@@ -8903,6 +9076,14 @@ var dataStructureTyped = (() => {
     get root() {
       return this._root;
     }
+    /**
+     * The above function is a getter method in TypeScript that returns the value of the private property
+     * `_isReverse`.
+     * @returns The `isReverse` property of the object, which is a boolean value.
+     */
+    get isReverse() {
+      return this._isReverse;
+    }
     /**
      * The function creates a new BSTNode with the given key and value and returns it.
      * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
@@ -8925,8 +9106,9 @@ var dataStructureTyped = (() => {
       return new _BST([], __spreadValues({
         iterationType: this.iterationType,
         isMapMode: this._isMapMode,
-        comparator: this._comparator,
-        toEntryFn: this._toEntryFn
+        extractComparable: this._extractComparable,
+        toEntryFn: this._toEntryFn,
+        isReverse: this._isReverse
       }, options));
     }
     /**
@@ -8977,11 +9159,11 @@ var dataStructureTyped = (() => {
      * @param {any} key - The `key` parameter is a value that will be checked to determine if it is of
      * type `K`.
      * @returns The `override isKey(key: any): key is K` function is returning a boolean value based on
-     * the result of the `isComparable` function with the condition `this.comparator !==
+     * the result of the `isComparable` function with the condition `this._compare !==
      * this._DEFAULT_COMPARATOR`.
      */
     isKey(key) {
-      return isComparable(key, this.comparator !== this._DEFAULT_COMPARATOR);
+      return isComparable(key, this._extractComparable !== void 0);
     }
     /**
      * Time Complexity: O(log n)
@@ -9005,11 +9187,11 @@ var dataStructureTyped = (() => {
       }
       let current = this._root;
       while (current !== void 0) {
-        if (this.comparator(current.key, newNode.key) === 0) {
+        if (this._compare(current.key, newNode.key) === 0) {
           this._replaceNode(current, newNode);
           if (this._isMapMode) this._setValue(current.key, newValue);
           return true;
-        } else if (this.comparator(current.key, newNode.key) > 0) {
+        } else if (this._compare(current.key, newNode.key) > 0) {
           if (current.left === void 0) {
             current.left = newNode;
             if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
@@ -9087,7 +9269,7 @@ var dataStructureTyped = (() => {
           keyB = b;
         }
         if (keyA !== void 0 && keyA !== null && keyB !== void 0 && keyB !== null) {
-          return this.comparator(keyA, keyB);
+          return this._compare(keyA, keyB);
         }
         return 0;
       });
@@ -9123,48 +9305,92 @@ var dataStructureTyped = (() => {
       }
       return inserted;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `merge` function overrides the base class method by adding elements from another
+     * binary search tree.
+     * @param anotherTree - `anotherTree` is an instance of a Binary Search Tree (BST) with key type `K`,
+     * value type `V`, return type `R`, node type `NODE`, and tree type `TREE`.
+     */
+    merge(anotherTree) {
+      this.addMany(anotherTree, [], false);
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
      *
-     * The function `getNodes` in TypeScript overrides the base class method to retrieve nodes based on a
-     * given keyNodeEntryRawOrPredicate and iteration type.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The `keyNodeEntryRawOrPredicate`
-     * parameter in the `getNodes` method is used to filter the nodes that will be returned. It can be a
-     * key, a node, an entry, or a custom keyNodeEntryRawOrPredicate function that determines whether a node should be
-     * included in the result.
-     * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` method is a boolean flag that
-     * determines whether to return only the first node that matches the keyNodeEntryRawOrPredicate (`true`) or all nodes
-     * that match the keyNodeEntryRawOrPredicate (`false`). If `onlyOne` is set to `true`, the method will stop iterating
-     * and
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
-     * `getNodes` method is used to specify the starting point for traversing the tree when searching for
-     * nodes that match a given keyNodeEntryRawOrPredicate. It represents the root node of the subtree where the search
-     * should begin. If not explicitly provided, the default value for `begin
-     * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` method
-     * specifies the type of iteration to be performed when traversing the nodes of a binary tree. It can
-     * have two possible values:
-     * @returns The `getNodes` method returns an array of nodes that satisfy the given keyNodeEntryRawOrPredicate.
+     * The function `search` in TypeScript overrides the search behavior in a binary tree structure based
+     * on specified criteria.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
+     * `keyNodeEntryRawOrPredicate` 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
+     * 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 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<NODE>`. The callback function should accept a node of type `NODE` as its
+     * argument and
+     * @param {BTNRep<K, V, NODE> | R} 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 `
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `override search`
+     * function determines the type of iteration to be used during the search operation. It can have two
+     * possible values:
+     * @returns The `override search` method returns an array of values that match the search criteria
+     * specified by the input parameters. The method performs a search operation on a binary tree
+     * structure based on the provided key, predicate, and other options. The search results are
+     * collected in an array and returned as the output of the method.
      */
-    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+    search(keyNodeEntryRawOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
       if (keyNodeEntryRawOrPredicate === void 0) return [];
       if (keyNodeEntryRawOrPredicate === null) return [];
       startNode = this.ensureNode(startNode);
       if (!startNode) return [];
-      const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+      let predicate;
+      const isRange = this.isRange(keyNodeEntryRawOrPredicate);
+      if (isRange) {
+        predicate = (node) => keyNodeEntryRawOrPredicate.isInRange(node.key, this._comparator);
+      } else {
+        predicate = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+      }
+      const isToLeftByRange = (cur) => {
+        if (isRange) {
+          const range = keyNodeEntryRawOrPredicate;
+          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;
+      };
+      const isToRightByRange = (cur) => {
+        if (isRange) {
+          const range = keyNodeEntryRawOrPredicate;
+          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;
+      };
       const ans = [];
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
-          if (callback(cur)) {
-            ans.push(cur);
+          if (predicate(cur)) {
+            ans.push(callback(cur));
             if (onlyOne) return;
           }
           if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
-          if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-            const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
-            if (this.isRealNode(cur.left) && benchmarkKey !== null && benchmarkKey !== void 0 && this.comparator(cur.key, benchmarkKey) > 0)
+          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(keyNodeEntryRawOrPredicate)) {
+            const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
+            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.comparator(cur.key, benchmarkKey) < 0)
+            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);
@@ -9176,15 +9402,18 @@ var dataStructureTyped = (() => {
         const stack = [startNode];
         while (stack.length > 0) {
           const cur = stack.pop();
-          if (callback(cur)) {
-            ans.push(cur);
+          if (predicate(cur)) {
+            ans.push(callback(cur));
             if (onlyOne) return ans;
           }
-          if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-            const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
-            if (this.isRealNode(cur.right) && benchmarkKey !== null && benchmarkKey !== void 0 && this.comparator(cur.key, benchmarkKey) < 0)
+          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(keyNodeEntryRawOrPredicate)) {
+            const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
+            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.comparator(cur.key, benchmarkKey) > 0)
+            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);
@@ -9218,22 +9447,6 @@ var dataStructureTyped = (() => {
       var _a;
       return (_a = this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0]) != null ? _a : void 0;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The function `getNodeByKey` returns a node with a specific key from a tree data structure.
-     * @param {K} key - The key parameter is the value used to search for a specific node in the tree. It
-     * is typically a unique identifier or a value that can be used to determine the position of the node
-     * in the tree structure.
-     * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
-     * parameter that specifies the type of iteration to be used when searching for a node in the tree.
-     * It has a default value of `'ITERATIVE'`.
-     * @returns The method is returning a NODE object or undefined.
-     */
-    getNodeByKey(key, iterationType = this.iterationType) {
-      return this.getNode(key, this._root, iterationType);
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -9327,7 +9540,7 @@ var dataStructureTyped = (() => {
       const targetKey = targetNodeEnsured.key;
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
-          const compared = this.comparator(cur.key, targetKey);
+          const compared = this._compare(cur.key, targetKey);
           if (Math.sign(compared) === lesserOrGreater) ans.push(callback(cur));
           if (this.isRealNode(cur.left)) dfs(cur.left);
           if (this.isRealNode(cur.right)) dfs(cur.right);
@@ -9339,7 +9552,7 @@ var dataStructureTyped = (() => {
         while (queue.size > 0) {
           const cur = queue.shift();
           if (this.isRealNode(cur)) {
-            const compared = this.comparator(cur.key, targetKey);
+            const compared = this._compare(cur.key, targetKey);
             if (Math.sign(compared) === lesserOrGreater) ans.push(callback(cur));
             if (this.isRealNode(cur.left)) queue.push(cur.left);
             if (this.isRealNode(cur.right)) queue.push(cur.right);
@@ -9451,6 +9664,14 @@ var dataStructureTyped = (() => {
     get comparator() {
       return this._comparator;
     }
+    /**
+     * This function returns the value of the `_extractComparable` property.
+     * @returns The method `extractComparable()` is being returned, which is a getter method for the
+     * `_extractComparable` property.
+     */
+    get extractComparable() {
+      return this._extractComparable;
+    }
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
@@ -9462,6 +9683,9 @@ var dataStructureTyped = (() => {
       }
       this._root = v;
     }
+    _compare(a, b) {
+      return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
+    }
   };
 
   // src/data-structures/binary-tree/binary-indexed-tree.ts
@@ -10097,8 +10321,9 @@ var dataStructureTyped = (() => {
       return new _AVLTree([], __spreadValues({
         iterationType: this.iterationType,
         isMapMode: this._isMapMode,
-        comparator: this._comparator,
-        toEntryFn: this._toEntryFn
+        extractComparable: this._extractComparable,
+        toEntryFn: this._toEntryFn,
+        isReverse: this._isReverse
       }, options));
     }
     /**
@@ -10384,7 +10609,7 @@ var dataStructureTyped = (() => {
      */
     _balancePath(node) {
       node = this.ensureNode(node);
-      const path = this.getPathToRoot((node2) => node2, node, false);
+      const path = this.getPathToRoot(node, (node2) => node2, false);
       for (let i = 0; i < path.length; i++) {
         const A = path[i];
         if (A) {
@@ -10516,7 +10741,7 @@ var dataStructureTyped = (() => {
       return new _RedBlackTree([], __spreadValues({
         iterationType: this.iterationType,
         isMapMode: this._isMapMode,
-        comparator: this._comparator,
+        extractComparable: this._extractComparable,
         toEntryFn: this._toEntryFn
       }, options));
     }
@@ -10725,7 +10950,7 @@ var dataStructureTyped = (() => {
       let parent = void 0;
       while (this.isRealNode(current)) {
         parent = current;
-        const compared = this.comparator(node.key, current.key);
+        const compared = this._compare(node.key, current.key);
         if (compared < 0) {
           current = (_a = current.left) != null ? _a : this.NIL;
         } else if (compared > 0) {
@@ -11040,8 +11265,9 @@ var dataStructureTyped = (() => {
       return new _AVLTreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
         isMapMode: this._isMapMode,
-        comparator: this._comparator,
-        toEntryFn: this._toEntryFn
+        extractComparable: this._extractComparable,
+        toEntryFn: this._toEntryFn,
+        isReverse: this._isReverse
       }, options));
     }
     /**
@@ -11075,15 +11301,12 @@ var dataStructureTyped = (() => {
         const finalValue = value != null ? value : entryValue;
         return [this.createNode(key, finalValue, count), finalValue];
       }
-      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, count), value];
       if (this.isRaw(keyNodeEntryOrRaw)) {
-        if (this._toEntryFn) {
-          const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-          const finalValue = value != null ? value : entryValue;
-          if (this.isKey(key)) return [this.createNode(key, finalValue, count), finalValue];
-        }
-        return [void 0, void 0];
+        const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+        const finalValue = value != null ? value : entryValue;
+        if (this.isKey(key)) return [this.createNode(key, finalValue, count), finalValue];
       }
+      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, count), value];
       return [void 0, void 0];
     }
     /**
@@ -11402,7 +11625,7 @@ var dataStructureTyped = (() => {
       return new _TreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
         isMapMode: this._isMapMode,
-        comparator: this._comparator,
+        extractComparable: this._extractComparable,
         toEntryFn: this._toEntryFn
       }, options));
     }
@@ -11427,7 +11650,7 @@ var dataStructureTyped = (() => {
         const finalValue = value != null ? value : entryValue;
         if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
       }
-      if (this._toEntryFn) {
+      if (this.isRaw(keyNodeEntryOrRaw)) {
         const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
         const finalValue = value != null ? value : entryValue;
         if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
@@ -12546,10 +12769,16 @@ var dataStructureTyped = (() => {
   };
   var Trie = class _Trie extends IterableElementBase {
     /**
-     * The constructor function for the Trie class.
-     * @param words: Iterable string Initialize the trie with a set of words
-     * @param options?: TrieOptions Allow the user to pass in options for the trie
-     * @return This
+     * The constructor initializes a Trie data structure with optional options and words provided as
+     * input.
+     * @param {Iterable<string> | Iterable<R>} words - The `words` parameter in the constructor is an
+     * iterable containing either strings or elements of type `R`. It is used to initialize the Trie with
+     * a list of words or elements. If no `words` are provided, an empty iterable is used as the default
+     * value.
+     * @param [options] - The `options` parameter in the constructor is an optional object that can
+     * contain configuration options for the Trie data structure. One of the options it can have is
+     * `caseSensitive`, which is a boolean value indicating whether the Trie should be case-sensitive or
+     * not. If `caseSensitive` is set to `
      */
     constructor(words = [], options) {
       super(options);
@@ -12561,13 +12790,7 @@ var dataStructureTyped = (() => {
         if (caseSensitive !== void 0) this._caseSensitive = caseSensitive;
       }
       if (words) {
-        for (const word of words) {
-          if (this.toElementFn) {
-            this.add(this.toElementFn(word));
-          } else {
-            this.add(word);
-          }
-        }
+        this.addMany(words);
       }
     }
     /**
@@ -12618,6 +12841,29 @@ var dataStructureTyped = (() => {
       }
       return isNewWord;
     }
+    /**
+     * Time Complexity: O(n * l)
+     * Space Complexity: O(1)
+     *
+     * The `addMany` function in TypeScript takes an iterable of strings or elements of type R, converts
+     * them using a provided function if available, and adds them to a data structure while returning an
+     * array of boolean values indicating success.
+     * @param {Iterable<string> | Iterable<R>} words - The `words` parameter in the `addMany` function is
+     * an iterable that contains either strings or elements of type `R`.
+     * @returns The `addMany` method returns an array of boolean values indicating whether each word in
+     * the input iterable was successfully added to the data structure.
+     */
+    addMany(words = []) {
+      const ans = [];
+      for (const word of words) {
+        if (this.toElementFn) {
+          ans.push(this.add(this.toElementFn(word)));
+        } else {
+          ans.push(this.add(word));
+        }
+      }
+      return ans;
+    }
     /**
      * Time Complexity: O(l), where l is the length of the input word.
      * Space Complexity: O(1) - Constant space.