data-structure-typed 1.53.7 → 1.53.9

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

@@ -231,7 +231,7 @@ var dataStructureTyped = (() => {
     every(predicate, thisArg) {
       let index = 0;
       for (const item of this) {
-        if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
+        if (!predicate.call(thisArg, item[0], item[1], index++, this)) {
           return false;
         }
       }
@@ -255,7 +255,7 @@ var dataStructureTyped = (() => {
     some(predicate, thisArg) {
       let index = 0;
       for (const item of this) {
-        if (predicate.call(thisArg, item[1], item[0], index++, this)) {
+        if (predicate.call(thisArg, item[0], item[1], index++, this)) {
           return true;
         }
       }
@@ -278,7 +278,7 @@ var dataStructureTyped = (() => {
       let index = 0;
       for (const item of this) {
         const [key, value] = item;
-        callbackfn.call(thisArg, value, key, index++, this);
+        callbackfn.call(thisArg, key, value, index++, this);
       }
     }
     /**
@@ -302,7 +302,7 @@ var dataStructureTyped = (() => {
       let index = 0;
       for (const item of this) {
         const [key, value] = item;
-        if (callbackfn.call(thisArg, value, key, index++, this)) return item;
+        if (callbackfn.call(thisArg, key, value, index++, this)) return item;
       }
       return;
     }
@@ -771,6 +771,9 @@ var dataStructureTyped = (() => {
       return this._hashFn;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given element is an array with exactly two elements.
      * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
      * data type.
@@ -780,6 +783,9 @@ var dataStructureTyped = (() => {
       return Array.isArray(rawElement) && rawElement.length === 2;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the size of an object is equal to zero and returns a boolean value.
      * @returns A boolean value indicating whether the size of the object is 0 or not.
      */
@@ -787,6 +793,9 @@ var dataStructureTyped = (() => {
       return this._size === 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function resets the state of an object by clearing its internal store, object map, and
      * size.
      */
@@ -796,6 +805,9 @@ var dataStructureTyped = (() => {
       this._size = 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
      * the key is not already present.
      * @param {K} key - The key parameter is the key used to identify the value in the data structure. It
@@ -820,6 +832,9 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
      * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
      * pair using a mapping function, and sets each key-value pair in the current object.
      * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
@@ -843,6 +858,9 @@ var dataStructureTyped = (() => {
       return results;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
      * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
@@ -860,6 +878,9 @@ var dataStructureTyped = (() => {
       }
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `has` function checks if a given key exists in the `_objMap` or `_store` based on whether it
      * is an object key or not.
      * @param {K} key - The parameter "key" is of type K, which means it can be any type.
@@ -874,6 +895,9 @@ var dataStructureTyped = (() => {
       }
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `delete` function removes an element from a map-like data structure based on the provided key.
      * @param {K} key - The `key` parameter is the key of the element that you want to delete from the
      * data structure.
@@ -927,7 +951,7 @@ var dataStructureTyped = (() => {
       const resultMap = new _HashMap();
       let index = 0;
       for (const [key, value] of this) {
-        resultMap.set(key, callbackfn.call(thisArg, value, key, index++, this));
+        resultMap.set(key, callbackfn.call(thisArg, key, value, index++, this));
       }
       return resultMap;
     }
@@ -951,7 +975,7 @@ var dataStructureTyped = (() => {
       const filteredMap = new _HashMap();
       let index = 0;
       for (const [key, value] of this) {
-        if (predicate.call(thisArg, value, key, index++, this)) {
+        if (predicate.call(thisArg, key, value, index++, this)) {
           filteredMap.set(key, value);
         }
       }
@@ -1195,6 +1219,9 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
      * The function `setMany` takes an iterable collection, converts each element into a key-value pair
      * using a provided function, and sets each key-value pair in the current object, returning an array
      * of booleans indicating the success of each set operation.
@@ -1219,6 +1246,9 @@ var dataStructureTyped = (() => {
       return results;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given key exists in a map, using different logic depending on whether the
      * key is a weak key or not.
      * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.
@@ -1390,7 +1420,7 @@ var dataStructureTyped = (() => {
       const filteredMap = new _LinkedHashMap();
       let index = 0;
       for (const [key, value] of this) {
-        if (predicate.call(thisArg, value, key, index, this)) {
+        if (predicate.call(thisArg, key, value, index, this)) {
           filteredMap.set(key, value);
         }
         index++;
@@ -1418,8 +1448,8 @@ var dataStructureTyped = (() => {
       const mappedMap = new _LinkedHashMap();
       let index = 0;
       for (const [key, value] of this) {
-        const newValue = callback.call(thisArg, value, key, index, this);
-        mappedMap.set(key, newValue);
+        const [newKey, newValue] = callback.call(thisArg, key, value, index, this);
+        mappedMap.set(newKey, newValue);
         index++;
       }
       return mappedMap;
@@ -1514,15 +1544,7 @@ var dataStructureTyped = (() => {
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_size", 0);
-      if (elements) {
-        for (const el of elements) {
-          if (this.toElementFn) {
-            this.push(this.toElementFn(el));
-          } else {
-            this.push(el);
-          }
-        }
-      }
+      this.pushMany(elements);
     }
     /**
      * The `head` function returns the first node of a singly linked list.
@@ -1563,6 +1585,22 @@ 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)
@@ -1648,6 +1686,53 @@ var dataStructureTyped = (() => {
       this._size++;
       return true;
     }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `pushMany` iterates over elements and pushes them into a data structure, applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `pushMany` function can accept an iterable containing elements of type `E`, `R`,
+     * or `SinglyLinkedListNode<E>`.
+     * @returns The `pushMany` function returns an array of boolean values indicating whether each
+     * element was successfully pushed into the data structure.
+     */
+    pushMany(elements) {
+      const ans = [];
+      for (const el of elements) {
+        if (this.toElementFn) {
+          ans.push(this.push(this.toElementFn(el)));
+          continue;
+        }
+        ans.push(this.push(el));
+      }
+      return ans;
+    }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `unshiftMany` iterates over elements and adds them to a data structure, optionally
+     * converting them using a provided function.
+     * @param {Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `unshiftMany` function can accept an iterable containing elements of type `E`,
+     * `R`, or `SinglyLinkedListNode<E>`. The function iterates over each element in the iterable and
+     * performs an `unshift` operation on the linked list for each
+     * @returns The `unshiftMany` function is returning an array of boolean values, where each value
+     * represents the result of calling the `unshift` method on the current instance of the class.
+     */
+    unshiftMany(elements) {
+      const ans = [];
+      for (const el of elements) {
+        if (this.toElementFn) {
+          ans.push(this.unshift(this.toElementFn(el)));
+          continue;
+        }
+        ans.push(this.unshift(el));
+      }
+      return ans;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -1819,6 +1904,9 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the length of a data structure is equal to zero and returns a boolean value indicating
      * whether it is empty or not.
      * @returns A boolean value indicating whether the length of the object is equal to 0.
@@ -1827,6 +1915,9 @@ var dataStructureTyped = (() => {
       return this._size === 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
      */
     clear() {
@@ -2095,22 +2186,6 @@ 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.
@@ -2235,13 +2310,7 @@ var dataStructureTyped = (() => {
       this._head = void 0;
       this._tail = void 0;
       this._size = 0;
-      if (elements) {
-        for (const el of elements) {
-          if (this.toElementFn) {
-            this.push(this.toElementFn(el));
-          } else this.push(el);
-        }
-      }
+      this.pushMany(elements);
     }
     /**
      * The `head` function returns the first node of a doubly linked list.
@@ -2287,6 +2356,18 @@ var dataStructureTyped = (() => {
       var _a;
       return (_a = this.tail) == null ? void 0 : _a.value;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `fromArray` function creates a new instance of a DoublyLinkedList 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 DoublyLinkedList object.
+     */
+    static fromArray(data) {
+      return new _DoublyLinkedList(data);
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -2389,6 +2470,55 @@ var dataStructureTyped = (() => {
       this._size++;
       return true;
     }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `pushMany` iterates over elements and pushes them into a data structure, applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `pushMany` function can accept an iterable containing elements of type `E`, `R`,
+     * or `DoublyLinkedListNode<E>`. The function iterates over each element in the iterable and pushes
+     * it onto the linked list. If a transformation function `to
+     * @returns The `pushMany` function is returning an array of boolean values (`ans`) which indicate
+     * the success or failure of pushing each element into the data structure.
+     */
+    pushMany(elements) {
+      const ans = [];
+      for (const el of elements) {
+        if (this.toElementFn) {
+          ans.push(this.push(this.toElementFn(el)));
+          continue;
+        }
+        ans.push(this.push(el));
+      }
+      return ans;
+    }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `unshiftMany` iterates through a collection of elements and adds them to the
+     * beginning of a Doubly Linked List, returning an array of boolean values indicating the success of
+     * each insertion.
+     * @param {Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `unshiftMany` function can accept an iterable containing elements of type `E`,
+     * `R`, or `DoublyLinkedListNode<E>`. The function iterates over each element in the iterable and
+     * performs an `unshift` operation on the doubly linked list
+     * @returns The `unshiftMany` function returns an array of boolean values indicating the success of
+     * each unshift operation performed on the elements passed as input.
+     */
+    unshiftMany(elements) {
+      const ans = [];
+      for (const el of elements) {
+        if (this.toElementFn) {
+          ans.push(this.unshift(this.toElementFn(el)));
+          continue;
+        }
+        ans.push(this.unshift(el));
+      }
+      return ans;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -2825,6 +2955,12 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
+     * The function `countOccurrences` iterates through a doubly linked list and counts the occurrences
+     * of a specified element or nodes that satisfy a given predicate.
+     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<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 doubly linked list.
      */
     countOccurrences(elementOrNode) {
       const predicate = this._ensurePredicate(elementOrNode);
@@ -2838,18 +2974,6 @@ var dataStructureTyped = (() => {
       }
       return count;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `fromArray` function creates a new instance of a DoublyLinkedList 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 DoublyLinkedList object.
-     */
-    static fromArray(data) {
-      return new _DoublyLinkedList(data);
-    }
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */
@@ -3144,15 +3268,7 @@ var dataStructureTyped = (() => {
     constructor(elements = [], options) {
       super(options);
       __publicField(this, "_elements", []);
-      if (elements) {
-        for (const el of elements) {
-          if (this.toElementFn) {
-            this.push(this.toElementFn(el));
-          } else {
-            this.push(el);
-          }
-        }
-      }
+      this.pushMany(elements);
     }
     /**
      * The elements function returns the elements of this set.
@@ -3168,10 +3284,6 @@ var dataStructureTyped = (() => {
     get size() {
       return this.elements.length;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -3185,6 +3297,9 @@ var dataStructureTyped = (() => {
       return new _Stack(elements);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if an array is empty and returns a boolean value.
      * @returns A boolean value indicating whether the `_elements` array is empty or not.
      */
@@ -3227,18 +3342,46 @@ var dataStructureTyped = (() => {
       return this.elements.pop();
     }
     /**
-     * The delete function removes an element from the stack.
-     * @param element: E Specify the element to be deleted
-     * @return A boolean value indicating whether the element was successfully deleted or not
+     * Time Complexity: O(k)
+     * Space Complexity: O(1)
+     *
+     * The function `pushMany` iterates over elements and pushes them into an array after applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `pushMany` function
+     * is an iterable containing elements of type `E` or `R`. The function iterates over each element in
+     * the iterable and pushes it into the data structure. If a transformation function `toElementFn` is
+     * provided, it is used to
+     * @returns The `pushMany` function is returning an array of boolean values indicating whether each
+     * element was successfully pushed into the data structure.
+     */
+    pushMany(elements) {
+      const ans = [];
+      for (const el of elements) {
+        if (this.toElementFn) {
+          ans.push(this.push(this.toElementFn(el)));
+        } else {
+          ans.push(this.push(el));
+        }
+      }
+      return ans;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type E.
      */
     delete(element) {
       const index = this.elements.indexOf(element);
       return this.deleteAt(index);
     }
     /**
-     * The deleteAt function deletes the element at a given index.
-     * @param index: number Determine the index of the element to be deleted
-     * @return A boolean value
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type E.
      */
     deleteAt(index) {
       const spliced = this.elements.splice(index, 1);
@@ -3351,12 +3494,7 @@ var dataStructureTyped = (() => {
         const { autoCompactRatio = 0.5 } = options;
         this._autoCompactRatio = autoCompactRatio;
       }
-      if (elements) {
-        for (const el of elements) {
-          if (this.toElementFn) this.push(this.toElementFn(el));
-          else this.push(el);
-        }
-      }
+      this.pushMany(elements);
     }
     /**
      * The elements function returns the elements of this set.
@@ -3441,6 +3579,25 @@ var dataStructureTyped = (() => {
       this.elements.push(element);
       return true;
     }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The `pushMany` function iterates over elements and pushes them into an array after applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `pushMany` function
+     * is an iterable containing elements of type `E` or `R`.
+     * @returns The `pushMany` function is returning an array of boolean values indicating whether each
+     * element was successfully pushed into the data structure.
+     */
+    pushMany(elements) {
+      const ans = [];
+      for (const el of elements) {
+        if (this.toElementFn) ans.push(this.push(this.toElementFn(el)));
+        else ans.push(this.push(el));
+      }
+      return ans;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -3457,6 +3614,9 @@ var dataStructureTyped = (() => {
       return first;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The delete function removes an element from the list.
      * @param {E} element - Specify the element to be deleted
      * @return A boolean value indicating whether the element was successfully deleted or not
@@ -3466,6 +3626,9 @@ var dataStructureTyped = (() => {
       return this.deleteAt(index);
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The deleteAt function deletes the element at a given index.
      * @param {number} index - Determine the index of the element to be deleted
      * @return A boolean value
@@ -3478,7 +3641,12 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * @param index
+     * The `at` function returns the element at a specified index adjusted by an offset, or `undefined`
+     * if the index is out of bounds.
+     * @param {number} index - The `index` parameter represents the position of the element you want to
+     * retrieve from the data structure.
+     * @returns The `at` method is returning the element at the specified index adjusted by the offset
+     * `_offset`.
      */
     at(index) {
       return this.elements[index + this._offset];
@@ -3514,6 +3682,9 @@ var dataStructureTyped = (() => {
       this._offset = 0;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The `compact` function in TypeScript slices the elements array based on the offset and resets the
      * offset to zero.
      * @returns The `compact()` method is returning a boolean value of `true`.
@@ -3563,6 +3734,20 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new Queue by applying a callback function to each
+     * element in the original Queue.
+     * @param callback - The `callback` parameter is a function that will be applied to each element in
+     * the queue. It takes the current element, its index, and the queue itself as arguments, and returns
+     * a new element.
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be provided to
+     * convert a raw element of type `RM` to a new element of type `EM`. This function is used within the
+     * `map` method to transform each raw element before passing it to the `callback` function. If
+     * @param {any} [thisArg] - The `thisArg` parameter in the `map` function is used to specify the
+     * value of `this` when executing the `callback` function. It allows you to set the context (the
+     * value of `this`) within the callback function. If `thisArg` is provided, it will be
+     * @returns A new Queue object containing elements of type EM, which are the result of applying the
+     * callback function to each element in the original Queue object.
      */
     map(callback, toElementFn, thisArg) {
       const newDeque = new _Queue([], { toElementFn });
@@ -3643,13 +3828,7 @@ var dataStructureTyped = (() => {
       const needBucketNum = calcMinUnitsRequired(_size, this._bucketSize);
       this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
       this._firstInBucket = this._lastInBucket = this._bucketSize - _size % this._bucketSize >> 1;
-      for (const el of elements) {
-        if (this.toElementFn) {
-          this.push(this.toElementFn(el));
-        } else {
-          this.push(el);
-        }
-      }
+      this.pushMany(elements);
     }
     /**
      * The bucketSize function returns the size of the bucket.
@@ -3787,6 +3966,32 @@ var dataStructureTyped = (() => {
       this._size -= 1;
       return element;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `shift()` function removes and returns the first element from a data structure, updating the
+     * internal state variables accordingly.
+     * @returns The element that is being removed from the beginning of the data structure is being
+     * returned.
+     */
+    shift() {
+      if (this._size === 0) return;
+      const element = this._buckets[this._bucketFirst][this._firstInBucket];
+      if (this._size !== 1) {
+        if (this._firstInBucket < this._bucketSize - 1) {
+          this._firstInBucket += 1;
+        } else if (this._bucketFirst < this._bucketCount - 1) {
+          this._bucketFirst += 1;
+          this._firstInBucket = 0;
+        } else {
+          this._bucketFirst = 0;
+          this._firstInBucket = 0;
+        }
+      }
+      this._size -= 1;
+      return element;
+    }
     /**
      * Time Complexity: Amortized O(1)
      * Space Complexity: O(n)
@@ -3816,30 +4021,53 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
      *
-     * The `shift()` function removes and returns the first element from a data structure, updating the
-     * internal state variables accordingly.
-     * @returns The element that is being removed from the beginning of the data structure is being
-     * returned.
+     * The function `pushMany` iterates over elements and pushes them into an array after applying a
+     * transformation function if provided.
+     * @param {IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>} elements - The `elements`
+     * parameter in the `pushMany` function is expected to be an iterable containing elements of type `E`
+     * or `R`. It can be either an `IterableWithSizeOrLength<E>` or an `IterableWithSizeOrLength<R>`. The
+     * function iterates over each element
+     * @returns The `pushMany` function is returning an array of boolean values, where each value
+     * represents the result of calling the `push` method on the current object instance with the
+     * corresponding element from the input `elements` iterable.
      */
-    shift() {
-      if (this._size === 0) return;
-      const element = this._buckets[this._bucketFirst][this._firstInBucket];
-      if (this._size !== 1) {
-        if (this._firstInBucket < this._bucketSize - 1) {
-          this._firstInBucket += 1;
-        } else if (this._bucketFirst < this._bucketCount - 1) {
-          this._bucketFirst += 1;
-          this._firstInBucket = 0;
+    pushMany(elements) {
+      const ans = [];
+      for (const el of elements) {
+        if (this.toElementFn) {
+          ans.push(this.push(this.toElementFn(el)));
         } else {
-          this._bucketFirst = 0;
-          this._firstInBucket = 0;
+          ans.push(this.push(el));
         }
       }
-      this._size -= 1;
-      return element;
+      return ans;
+    }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The `unshiftMany` function in TypeScript iterates over elements and adds them to the beginning of
+     * an array, optionally converting them using a provided function.
+     * @param {IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>} elements - The `elements`
+     * parameter in the `unshiftMany` function is an iterable containing elements of type `E` or `R`. It
+     * can be an array or any other iterable data structure that has a known size or length. The function
+     * iterates over each element in the `elements` iterable and
+     * @returns The `unshiftMany` function returns an array of boolean values indicating whether each
+     * element was successfully added to the beginning of the array.
+     */
+    unshiftMany(elements = []) {
+      const ans = [];
+      for (const el of elements) {
+        if (this.toElementFn) {
+          ans.push(this.unshift(this.toElementFn(el)));
+        } else {
+          ans.push(this.unshift(el));
+        }
+      }
+      return ans;
     }
     /**
      * Time Complexity: O(1)
@@ -4356,12 +4584,7 @@ var dataStructureTyped = (() => {
         const { comparator } = options;
         if (comparator) this._comparator = comparator;
       }
-      if (elements) {
-        for (const el of elements) {
-          if (this.toElementFn) this.add(this.toElementFn(el));
-          else this.add(el);
-        }
-      }
+      this.addMany(elements);
     }
     /**
      * The function returns an array of elements.
@@ -4397,13 +4620,40 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Insert an element into the heap and maintain the heap properties.
-     * @param element - The element to be inserted.
+     * The add function pushes an element into an array and then triggers a bubble-up operation.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the
+     * data structure.
+     * @returns The `add` method is returning a boolean value, which is the result of calling the
+     * `_bubbleUp` method with the index `this.elements.length - 1` as an argument.
      */
     add(element) {
       this._elements.push(element);
       return this._bubbleUp(this.elements.length - 1);
     }
+    /**
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     *
+     * The `addMany` function iterates over elements and adds them to a collection, returning an array of
+     * boolean values indicating success or failure.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `addMany` method is
+     * an iterable containing elements of type `E` or `R`. The method iterates over each element in the
+     * iterable and adds them to the data structure. If a transformation function `_toElementFn` is
+     * provided, it transforms the element
+     * @returns The `addMany` method returns an array of boolean values indicating whether each element
+     * in the input iterable was successfully added to the data structure.
+     */
+    addMany(elements) {
+      const ans = [];
+      for (const el of elements) {
+        if (this._toElementFn) {
+          ans.push(this.add(this._toElementFn(el)));
+          continue;
+        }
+        ans.push(this.add(el));
+      }
+      return ans;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -4597,7 +4847,7 @@ var dataStructureTyped = (() => {
       return filteredList;
     }
     /**
-     * Time Complexity: O(n log n)
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * The `map` function creates a new heap by applying a callback function to each element of the
@@ -5942,7 +6192,7 @@ var dataStructureTyped = (() => {
       const filtered = [];
       let index = 0;
       for (const [key, value] of this) {
-        if (predicate.call(thisArg, value, key, index, this)) {
+        if (predicate.call(thisArg, key, value, index, this)) {
           filtered.push([key, value]);
         }
         index++;
@@ -5966,7 +6216,7 @@ var dataStructureTyped = (() => {
       const mapped = [];
       let index = 0;
       for (const [key, value] of this) {
-        mapped.push(callback.call(thisArg, value, key, index, this));
+        mapped.push(callback.call(thisArg, key, value, index, this));
         index++;
       }
       return mapped;
@@ -7120,6 +7370,8 @@ var dataStructureTyped = (() => {
       this.high = high;
       this.includeLow = includeLow;
       this.includeHigh = includeHigh;
+      if (!(isComparable(low) && isComparable(high))) throw new RangeError("low or high is not comparable");
+      if (low > high) throw new RangeError("low must be less than or equal to high");
     }
     // Determine whether a key is within the range
     isInRange(key, comparator) {
@@ -7219,65 +7471,40 @@ var dataStructureTyped = (() => {
       return this._toEntryFn;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new binary tree node with a specified key and optional value.
      * @param {K} key - The `key` parameter is the key of the node being created in the binary tree.
-     * @param {V} [value] - The `value` parameter in the `createNode` function is optional, meaning it is
-     * not required to be provided when calling the function. If a `value` is provided, it should be of
-     * type `V`, which is the type of the value associated with the node.
-     * @returns A new BinaryTreeNode instance with the provided key and value is being returned, casted
-     * as NODE.
-     */
-    createNode(key, value) {
-      return new BinaryTreeNode(key, this._isMapMode ? void 0 : value);
-    }
-    /**
-     * The function creates a binary tree with the specified options.
-     * @param [options] - The `options` parameter in the `createTree` function is an optional parameter
-     * that allows you to provide partial configuration options for creating a binary tree. It is of type
-     * `Partial<BinaryTreeOptions<K, V, R>>`, which means you can pass in an object containing a subset
-     * of properties
-     * @returns A new instance of a binary tree with the specified options is being returned.
-     */
-    createTree(options) {
-      return new _BinaryTree([], __spreadValues({
-        iterationType: this.iterationType,
-        isMapMode: this._isMapMode,
-        toEntryFn: this._toEntryFn
-      }, options));
-    }
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
-     * or returns null.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
-     * can be of type `BTNRep<K, V, NODE>` 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<NODE>`) based on the input parameters provided. The function checks the type of the
-     * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
-     * value.
-     */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
-      if (keyNodeEntryOrRaw === void 0) return [void 0, void 0];
-      if (keyNodeEntryOrRaw === null) return [null, void 0];
-      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
-      if (this.isEntry(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = keyNodeEntryOrRaw;
-        if (key === void 0) return [void 0, void 0];
-        else if (key === null) return [null, void 0];
-        const finalValue = value != null ? value : entryValue;
-        return [this.createNode(key, finalValue), finalValue];
-      }
-      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), finalValue];
-      }
-      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
-      return [void 0, void 0];
+     * @param {V} [value] - The `value` parameter in the `createNode` function is optional, meaning it is
+     * not required to be provided when calling the function. If a `value` is provided, it should be of
+     * type `V`, which is the type of the value associated with the node.
+     * @returns A new BinaryTreeNode instance with the provided key and value is being returned, casted
+     * as NODE.
+     */
+    createNode(key, value) {
+      return new BinaryTreeNode(key, this._isMapMode ? void 0 : value);
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `createTree` function creates a new binary tree based on the provided options.
+     * @param [options] - The `options` parameter in the `createTree` method is of type
+     * `BinaryTreeOptions<K, V, R>`. This type likely contains configuration options for creating a
+     * binary tree, such as the iteration type, whether the tree is in map mode, and functions for
+     * converting entries.
+     * @returns The `createTree` method is returning an instance of the `BinaryTree` class with the
+     * provided options. The method is creating a new `BinaryTree` object with an empty array as the
+     * initial data, and then setting various options such as `iterationType`, `isMapMode`, and
+     * `toEntryFn` based on the current object's properties and the provided `options`. Finally, it
+     */
+    createTree(options) {
+      return new _BinaryTree([], __spreadValues({
+        iterationType: this.iterationType,
+        isMapMode: this._isMapMode,
+        toEntryFn: this._toEntryFn
+      }, options));
     }
     /**
      * Time Complexity: O(n)
@@ -7437,7 +7664,7 @@ var dataStructureTyped = (() => {
      * key was found and the node was replaced instead of inserted.
      */
     add(keyNodeEntryOrRaw, value) {
-      const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+      const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
       if (newNode === void 0) return false;
       if (!this._root) {
         this._setRoot(newNode);
@@ -8481,7 +8708,7 @@ var dataStructureTyped = (() => {
       const newTree = this.createTree();
       let index = 0;
       for (const [key, value] of this) {
-        if (predicate.call(thisArg, value, key, index++, this)) {
+        if (predicate.call(thisArg, key, value, index++, this)) {
           newTree.add([key, value]);
         }
       }
@@ -8491,34 +8718,29 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function iterates over key-value pairs in a tree data structure, applies a callback
-     * function to each value, and returns a new tree with the updated values.
-     * @param callback - The `callback` parameter in the `map` method is a function that will be called
-     * on each entry in the tree. It takes four arguments:
-     * @param {any} [thisArg] - The `thisArg` parameter in the `map` function is an optional parameter
-     * that specifies the value to be passed as `this` when executing the callback function. If provided,
-     * the `thisArg` value will be used as the `this` value within the callback function. If `thisArg
-     * @returns The `map` method is returning a new tree with the entries modified by the provided
-     * callback function. Each entry in the original tree is passed to the callback function, and the
-     * result of the callback function is added to the new tree.
-     */
-    map(callback, thisArg) {
-      const newTree = this.createTree();
+     * The `map` function in TypeScript creates a new BinaryTree by applying a callback function to each
+     * entry in the original BinaryTree.
+     * @param callback - A function that will be called for each entry in the current binary tree. It
+     * takes the key, value (which can be undefined), and an array containing the mapped key and value as
+     * arguments.
+     * @param [options] - The `options` parameter in the `map` method is of type `BinaryTreeOptions<MK,
+     * MV, MR>`. It is an optional parameter that allows you to specify additional options for the binary
+     * tree being created during the mapping process. These options could include things like custom
+     * comparators, initial
+     * @param {any} [thisArg] - The `thisArg` parameter in the `map` method is used to specify the value
+     * of `this` when executing the `callback` function. It allows you to set the context (value of
+     * `this`) within the callback function. If `thisArg` is provided, it will be passed
+     * @returns The `map` function is returning a new `BinaryTree` instance filled with entries that are
+     * the result of applying the provided `callback` function to each entry in the original tree.
+     */
+    map(callback, options, thisArg) {
+      const newTree = new _BinaryTree([], options);
       let index = 0;
       for (const [key, value] of this) {
-        newTree.add([key, callback.call(thisArg, value, key, index++, this)]);
+        newTree.add(callback.call(thisArg, key, value, index++, this));
       }
       return newTree;
     }
-    // // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-    // // map<NV>(callback: (entry: [K, V | undefined], tree: this) => NV) {
-    // //   const newTree = this.createTree();
-    // //   for (const [key, value] of this) {
-    // //     newTree.add(key, callback([key, value], this));
-    // //   }
-    // //   return newTree;
-    // // }
-    //
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -8549,7 +8771,7 @@ var dataStructureTyped = (() => {
       if (opts.isShowRedBlackNIL) output += `S for Sentinel Node(NIL)
 `;
       const display = (root) => {
-        const [lines, , ,] = this._displayAux(root, opts);
+        const [lines, ,] = this._displayAux(root, opts);
         let paragraph = "";
         for (const line of lines) {
           paragraph += line + "\n";
@@ -8577,6 +8799,40 @@ var dataStructureTyped = (() => {
     print(options, startNode = this._root) {
       console.log(this.toVisual(startNode, options));
     }
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
+     * or returns null.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
+     * can be of type `BTNRep<K, V, NODE>` 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<NODE>`) based on the input parameters provided. The function checks the type of the
+     * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
+     * value.
+     */
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
+      if (keyNodeEntryOrRaw === void 0) return [void 0, void 0];
+      if (keyNodeEntryOrRaw === null) return [null, void 0];
+      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
+      if (this.isEntry(keyNodeEntryOrRaw)) {
+        const [key, entryValue] = keyNodeEntryOrRaw;
+        if (key === void 0) return [void 0, void 0];
+        else if (key === null) return [null, void 0];
+        const finalValue = value != null ? value : entryValue;
+        return [this.createNode(key, finalValue), finalValue];
+      }
+      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), finalValue];
+      }
+      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
+      return [void 0, void 0];
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -9049,22 +9305,22 @@ var dataStructureTyped = (() => {
           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;
+        if (this._specifyComparable) {
+          if (this._specifyComparable(a) > this._specifyComparable(b)) return 1;
+          if (this._specifyComparable(a) < this._specifyComparable(b)) return -1;
           return 0;
         }
         if (typeof a === "object" || typeof b === "object") {
           throw TypeError(
-            `When comparing object types, a custom extractComparable must be defined in the constructor's options parameter.`
+            `When comparing object types, a custom specifyComparable must be defined in the constructor's options parameter.`
           );
         }
         return 0;
       });
-      __publicField(this, "_extractComparable");
+      __publicField(this, "_specifyComparable");
       if (options) {
-        const { extractComparable, isReverse } = options;
-        if (typeof extractComparable === "function") this._extractComparable = extractComparable;
+        const { specifyComparable, isReverse } = options;
+        if (typeof specifyComparable === "function") this._specifyComparable = specifyComparable;
         if (isReverse !== void 0) this._isReverse = isReverse;
       }
       if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
@@ -9084,6 +9340,21 @@ var dataStructureTyped = (() => {
     get isReverse() {
       return this._isReverse;
     }
+    /**
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
+     */
+    get comparator() {
+      return this._comparator;
+    }
+    /**
+     * This function returns the value of the `_specifyComparable` property.
+     * @returns The method `specifyComparable()` is being returned, which is a getter method for the
+     * `_specifyComparable` property.
+     */
+    get specifyComparable() {
+      return this._specifyComparable;
+    }
     /**
      * 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
@@ -9096,35 +9367,26 @@ var dataStructureTyped = (() => {
       return new BSTNode(key, this._isMapMode ? void 0 : value);
     }
     /**
-     * The function creates a new binary search tree with the specified options.
-     * @param [options] - The `options` parameter is an optional object that allows you to customize the
-     * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which has the
-     * following properties:
-     * @returns a new instance of the BST class with the provided options.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `createTree` function in TypeScript overrides the default options with the provided options to
+     * create a new Binary Search Tree.
+     * @param [options] - The `options` parameter in the `createTree` method is an optional object that
+     * can contain the following properties:
+     * @returns A new instance of a Binary Search Tree (BST) is being returned with the specified options
+     * and properties inherited from the current instance.
      */
+    // @ts-ignore
     createTree(options) {
       return new _BST([], __spreadValues({
         iterationType: this.iterationType,
         isMapMode: this._isMapMode,
-        extractComparable: this._extractComparable,
+        specifyComparable: this._specifyComparable,
         toEntryFn: this._toEntryFn,
         isReverse: this._isReverse
       }, options));
     }
-    /**
-     * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
-     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
-     * element.
-     * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
-     * value associated with a key in a key-value pair.
-     * @returns either a NODE object or undefined.
-     */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
-      const [node, entryValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
-      if (node === null) return [void 0, void 0];
-      return [node, value != null ? value : entryValue];
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -9163,7 +9425,7 @@ var dataStructureTyped = (() => {
      * this._DEFAULT_COMPARATOR`.
      */
     isKey(key) {
-      return isComparable(key, this._extractComparable !== void 0);
+      return isComparable(key, this._specifyComparable !== void 0);
     }
     /**
      * Time Complexity: O(log n)
@@ -9177,7 +9439,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     add(keyNodeEntryOrRaw, value) {
-      const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+      const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
       if (newNode === void 0) return false;
       if (this._root === void 0) {
         this._setRoot(newNode);
@@ -9423,6 +9685,31 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(n)
+     *
+     * The `rangeSearch` function searches for nodes within a specified range in a binary search tree.
+     * @param {Range<K> | [K, K]} range - The `range` parameter in the `rangeSearch` function can be
+     * 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<NODE>`, where `NODE` is the type of nodes in the
+     * data structure.
+     * @param {BTNRep<K, V, NODE> | R} 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
+     * is used to specify the type of iteration to be performed during the search operation. It has a
+     * default value of `this.iterationType`, which suggests that it is likely a property of the class or
+     * object that the `rangeSearch`
+     * @returns The `rangeSearch` function is returning the result of calling the `search` method with
+     * the specified parameters.
+     */
+    rangeSearch(range, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+      const searchRange = range instanceof Range ? range : new Range(range[0], range[1]);
+      return this.search(searchRange, false, callback, startNode, iterationType);
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -9657,20 +9944,28 @@ var dataStructureTyped = (() => {
       }
       return balanced;
     }
-    /**
-     * The function returns the value of the _comparator property.
-     * @returns The `_comparator` property is being returned.
-     */
-    get comparator() {
-      return this._comparator;
+    // @ts-ignore
+    map(callback, options, thisArg) {
+      const newTree = new _BST([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        newTree.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return newTree;
     }
     /**
-     * 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.
+     * The function overrides a method and converts a key, value pair or entry or raw element to a node.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
+     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+     * element.
+     * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
+     * value associated with a key in a key-value pair.
+     * @returns either a NODE object or undefined.
      */
-    get extractComparable() {
-      return this._extractComparable;
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
+      const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+      if (node === null) return [void 0, void 0];
+      return [node, value != null ? value : entryValue];
     }
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
@@ -10311,17 +10606,21 @@ var dataStructureTyped = (() => {
       return new AVLTreeNode(key, this._isMapMode ? void 0 : value);
     }
     /**
-     * The function creates a new AVL tree with the specified options and returns it.
-     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
-     * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
-     * being created.
-     * @returns a new AVLTree object.
-     */
+     * The function `createTree` in TypeScript overrides the default AVLTree creation with the provided
+     * options.
+     * @param [options] - The `options` parameter in the `createTree` function is an object that contains
+     * configuration options for creating an AVL tree. These options can include properties such as
+     * `iterationType`, `isMapMode`, `specifyComparable`, `toEntryFn`, and `isReverse`. The function
+     * creates a
+     * @returns An AVLTree object is being returned with the specified options and properties inherited
+     * from the current object.
+     */
+    // @ts-ignore
     createTree(options) {
       return new _AVLTree([], __spreadValues({
         iterationType: this.iterationType,
         isMapMode: this._isMapMode,
-        extractComparable: this._extractComparable,
+        specifyComparable: this._specifyComparable,
         toEntryFn: this._toEntryFn,
         isReverse: this._isReverse
       }, options));
@@ -10377,6 +10676,15 @@ var dataStructureTyped = (() => {
       }
       return deletedResults;
     }
+    // @ts-ignore
+    map(callback, options, thisArg) {
+      const newTree = new _AVLTree([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        newTree.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return newTree;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -10655,7 +10963,7 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/data-structures/binary-tree/rb-tree.ts
+  // src/data-structures/binary-tree/red-black-tree.ts
   var RedBlackTreeNode = class extends BSTNode {
     /**
      * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
@@ -10693,9 +11001,9 @@ var dataStructureTyped = (() => {
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
-     * initialize the RBTree with the provided elements.
+     * initialize the RedBlackTree with the provided elements.
      * @param [options] - The `options` parameter is an optional object that can be passed to the
-     * constructor. It is of type `RBTreeOptions<K, V, R>`. This object can contain various options for
+     * constructor. It is of type `RedBlackTreeOptions<K, V, R>`. This object can contain various options for
      * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
      * depend on the implementation
      */
@@ -10732,16 +11040,20 @@ var dataStructureTyped = (() => {
       return new RedBlackTreeNode(key, this._isMapMode ? void 0 : value, color);
     }
     /**
-     * The function creates a new Red-Black Tree with the specified options.
-     * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the Red-Black Tree. It has the following properties:
-     * @returns a new instance of a RedBlackTree object.
+     * The function `createTree` overrides the default implementation to create a Red-Black Tree with
+     * specified options in TypeScript.
+     * @param [options] - The `options` parameter in the `createTree` method is of type `RedBlackTreeOptions<K,
+     * V, R>`, which is a generic type with three type parameters `K`, `V`, and `R`. This parameter
+     * allows you to pass additional configuration options when creating a new Red-
+     * @returns A new instance of a RedBlackTree with the specified options and properties from the
+     * current object is being returned.
      */
+    // @ts-ignore
     createTree(options) {
       return new _RedBlackTree([], __spreadValues({
         iterationType: this.iterationType,
         isMapMode: this._isMapMode,
-        extractComparable: this._extractComparable,
+        specifyComparable: this._specifyComparable,
         toEntryFn: this._toEntryFn
       }, options));
     }
@@ -10758,41 +11070,6 @@ var dataStructureTyped = (() => {
     isNode(keyNodeEntryOrRaw) {
       return keyNodeEntryOrRaw instanceof RedBlackTreeNode;
     }
-    // /**
-    //  * Time Complexity: O(1)
-    //  * Space Complexity: O(1)
-    //  */
-    //
-    // /**
-    //  * Time Complexity: O(1)
-    //  * Space Complexity: O(1)
-    //  *
-    //  * The function `keyValueNodeEntryRawToNodeAndValue` takes a key, value, or entry and returns a node if it is
-    //  * valid, otherwise it returns undefined.
-    //  * @param {BTNRep<K, V, NODE>} keyNodeEntryOrRaw - The key, value, or entry to convert.
-    //  * @param {V} [value] - The value associated with the key (if `keyNodeEntryOrRaw` is a key).
-    //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
-    //  */
-    // override keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): NODE | undefined {
-    //
-    //   if (keyNodeEntryOrRaw === null || keyNodeEntryOrRaw === undefined) return;
-    //   if (this.isNode(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw;
-    //
-    //   if (this._toEntryFn) {
-    //     const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw as R);
-    //     if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'RED');
-    //   }
-    //
-    //   if (this.isEntry(keyNodeEntryOrRaw)) {
-    //     const [key, value] = keyNodeEntryOrRaw;
-    //     if (key === undefined || key === null) return;
-    //     else return  this.createNode(key, value, 'RED');
-    //   }
-    //
-    //   if (this.isKey(keyNodeEntryOrRaw)) return this.createNode(keyNodeEntryOrRaw, value, 'RED');
-    //
-    //   return ;
-    // }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -10820,7 +11097,7 @@ var dataStructureTyped = (() => {
      * returns true. If the node cannot be added or updated, the method returns false.
      */
     add(keyNodeEntryOrRaw, value) {
-      const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+      const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
       if (!this.isRealNode(newNode)) return false;
       const insertStatus = this._insert(newNode);
       if (insertStatus === "CREATED") {
@@ -10902,6 +11179,35 @@ var dataStructureTyped = (() => {
       results.push({ deleted: nodeToDelete, needBalanced: void 0 });
       return results;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
+     * applying a callback to each entry in the original tree.
+     * @param callback - A function that will be called for each entry in the tree, with parameters
+     * representing the key, value, index, and the tree itself. It should return an entry for the new
+     * tree.
+     * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
+     * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
+     * Tree that will be created during the mapping process. These options could include things like
+     * custom comparators
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function. This can be useful when you want to access properties
+     * or
+     * @returns A new Red-Black Tree is being returned, where each entry has been transformed using the
+     * provided callback function.
+     */
+    // @ts-ignore
+    map(callback, options, thisArg) {
+      const newTree = new _RedBlackTree([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        newTree.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return newTree;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -10963,7 +11269,7 @@ var dataStructureTyped = (() => {
       node.parent = parent;
       if (!parent) {
         this._setRoot(node);
-      } else if (node.key < parent.key) {
+      } else if (this._compare(node.key, parent.key) < 0) {
         parent.left = node;
       } else {
         parent.right = node;
@@ -11261,11 +11567,12 @@ var dataStructureTyped = (() => {
      * @returns a new instance of the AVLTreeMultiMap class, with the specified options, as a TREE
      * object.
      */
+    // @ts-ignore
     createTree(options) {
       return new _AVLTreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
         isMapMode: this._isMapMode,
-        extractComparable: this._extractComparable,
+        specifyComparable: this._specifyComparable,
         toEntryFn: this._toEntryFn,
         isReverse: this._isReverse
       }, options));
@@ -11280,35 +11587,6 @@ var dataStructureTyped = (() => {
     isNode(keyNodeEntryOrRaw) {
       return keyNodeEntryOrRaw instanceof AVLTreeMultiMapNode;
     }
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
-     * a node object.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyNodeEntryOrRaw` parameter can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `override` function. It represents the value associated with the key in the data structure. If no
-     * value is provided, it will default to `undefined`.
-     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
-     * @returns either a NODE object or undefined.
-     */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
-      if (keyNodeEntryOrRaw === void 0 || keyNodeEntryOrRaw === null) return [void 0, void 0];
-      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
-      if (this.isEntry(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = keyNodeEntryOrRaw;
-        if (key === void 0 || key === null) return [void 0, void 0];
-        const finalValue = value != null ? value : entryValue;
-        return [this.createNode(key, finalValue, count), finalValue];
-      }
-      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, count), finalValue];
-      }
-      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, count), value];
-      return [void 0, void 0];
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -11327,7 +11605,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     add(keyNodeEntryOrRaw, value, count = 1) {
-      const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
+      const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
       if (newNode === void 0) return false;
       const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
       const inserted = super.add(newNode, newValue);
@@ -11468,6 +11746,7 @@ var dataStructureTyped = (() => {
      * The function overrides the clone method to create a deep copy of a tree object.
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
+    // @ts-ignore
     clone() {
       const cloned = this.createTree();
       if (this._isMapMode) this.bfs((node) => cloned.add(node.key, void 0, node.count));
@@ -11475,6 +11754,62 @@ var dataStructureTyped = (() => {
       if (this._isMapMode) cloned._store = this._store;
       return cloned;
     }
+    /**
+     * The `map` function in TypeScript overrides the default behavior to create a new AVLTreeMultiMap
+     * with modified entries based on a provided callback.
+     * @param callback - The `callback` parameter is a function that will be called for each entry in the
+     * AVLTreeMultiMap. It takes four arguments:
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `AVLTreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional
+     * configuration options when creating a new `AVLTreeMultiMap` instance within the `map` function.
+     * These options
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function. This can be useful when you want to access properties
+     * or
+     * @returns The `map` method is returning a new `AVLTreeMultiMap` instance with the entries
+     * transformed by the provided `callback` function. Each entry in the original tree is passed to the
+     * `callback` function along with the index and the original tree itself. The transformed entries are
+     * then added to the new `AVLTreeMultiMap` instance, which is returned at the end.
+     */
+    // @ts-ignore
+    map(callback, options, thisArg) {
+      const newTree = new _AVLTreeMultiMap([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        newTree.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return newTree;
+    }
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
+     * a node object.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyNodeEntryOrRaw` parameter can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
+     * `override` function. It represents the value associated with the key in the data structure. If no
+     * value is provided, it will default to `undefined`.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
+     * @returns either a NODE object or undefined.
+     */
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
+      if (keyNodeEntryOrRaw === void 0 || keyNodeEntryOrRaw === null) return [void 0, void 0];
+      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
+      if (this.isEntry(keyNodeEntryOrRaw)) {
+        const [key, entryValue] = keyNodeEntryOrRaw;
+        if (key === void 0 || key === null) return [void 0, void 0];
+        const finalValue = value != null ? value : entryValue;
+        return [this.createNode(key, finalValue, count), finalValue];
+      }
+      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, count), finalValue];
+      }
+      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, count), value];
+      return [void 0, void 0];
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -11621,43 +11956,15 @@ var dataStructureTyped = (() => {
      * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
      * existing `iterationType` property. The returned value is casted as `TREE`.
      */
+    // @ts-ignore
     createTree(options) {
       return new _TreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
         isMapMode: this._isMapMode,
-        extractComparable: this._extractComparable,
+        specifyComparable: this._specifyComparable,
         toEntryFn: this._toEntryFn
       }, options));
     }
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
-     * node based on the input.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @param {V} [value] - The `value` parameter is an optional value that represents the value
-     * associated with the key in the node. It is used when creating a new node or updating the value of
-     * an existing node.
-     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
-     * @returns either a NODE object or undefined.
-     */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
-      if (keyNodeEntryOrRaw === void 0 || keyNodeEntryOrRaw === null) return [void 0, void 0];
-      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
-      if (this.isEntry(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = keyNodeEntryOrRaw;
-        if (key === void 0 || key === null) return [void 0, void 0];
-        const finalValue = value != null ? value : entryValue;
-        if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
-      }
-      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];
-      }
-      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, "BLACK", count), value];
-      return [void 0, void 0];
-    }
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
      * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
@@ -11685,7 +11992,7 @@ var dataStructureTyped = (() => {
      * was successful, and false otherwise.
      */
     add(keyNodeEntryOrRaw, value, count = 1) {
-      const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
+      const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
       const orgCount = (newNode == null ? void 0 : newNode.count) || 0;
       const isSuccessAdded = super.add(newNode, newValue);
       if (isSuccessAdded) {
@@ -11856,12 +12163,66 @@ var dataStructureTyped = (() => {
      * The function overrides the clone method to create a deep copy of a tree object.
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
+    // @ts-ignore
     clone() {
       const cloned = this.createTree();
       this.bfs((node) => cloned.add(node.key, void 0, node.count));
       if (this._isMapMode) cloned._store = this._store;
       return cloned;
     }
+    /**
+     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap with
+     * modified entries based on a provided callback.
+     * @param callback - The `callback` parameter is a function that will be called for each entry in the
+     * map. It takes four arguments:
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
+     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
+     * include things like
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function when it is called within the `map` function. This
+     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
+     * by the provided callback function.
+     */
+    // @ts-ignore
+    map(callback, options, thisArg) {
+      const newTree = new _TreeMultiMap([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        newTree.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return newTree;
+    }
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
+     * node based on the input.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {V} [value] - The `value` parameter is an optional value that represents the value
+     * associated with the key in the node. It is used when creating a new node or updating the value of
+     * an existing node.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
+     * @returns either a NODE object or undefined.
+     */
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
+      if (keyNodeEntryOrRaw === void 0 || keyNodeEntryOrRaw === null) return [void 0, void 0];
+      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
+      if (this.isEntry(keyNodeEntryOrRaw)) {
+        const [key, entryValue] = keyNodeEntryOrRaw;
+        if (key === void 0 || key === null) return [void 0, void 0];
+        const finalValue = value != null ? value : entryValue;
+        if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
+      }
+      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];
+      }
+      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, "BLACK", count), value];
+      return [void 0, void 0];
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -12853,7 +13214,7 @@ var dataStructureTyped = (() => {
      * @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 = []) {
+    addMany(words) {
       const ans = [];
       for (const word of words) {
         if (this.toElementFn) {
@@ -12945,9 +13306,14 @@ var dataStructureTyped = (() => {
       return isDeleted;
     }
     /**
-     * Time Complexity: O(n), where n is the total number of nodes in the trie.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      *
+     * The function `getHeight` calculates the height of a trie data structure starting from the root
+     * node.
+     * @returns The `getHeight` method returns the maximum depth or height of the trie tree starting from
+     * the root node. It calculates the depth using a breadth-first search (BFS) traversal of the trie
+     * tree and returns the maximum depth found.
      */
     getHeight() {
       const startNode = this.root;