data-structure-typed 1.51.7 → 1.51.9

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

@@ -160,6 +160,7 @@ var dataStructureTyped = (() => {
     arrayRemove: () => arrayRemove,
     calcMinUnitsRequired: () => calcMinUnitsRequired,
     getMSB: () => getMSB,
+    isComparable: () => isComparable,
     isThunk: () => isThunk,
     isWeakKey: () => isWeakKey,
     rangeCheck: () => rangeCheck,
@@ -711,6 +712,29 @@ var dataStructureTyped = (() => {
     const multiplier = Math.pow(10, digit);
     return Math.round(num * multiplier) / multiplier;
   };
+  function isComparable(key) {
+    const keyType = typeof key;
+    if (keyType === "number")
+      return !isNaN(key);
+    if (keyType === "string")
+      return true;
+    if (keyType === "bigint")
+      return true;
+    if (keyType === "boolean")
+      return true;
+    if (keyType === "symbol")
+      return false;
+    if (keyType === "undefined")
+      return false;
+    if (keyType === "function")
+      return isComparable(key());
+    if (keyType === "object") {
+      if (key === null)
+        return true;
+      return false;
+    }
+    return false;
+  }
 
   // src/utils/number.ts
   function toBinaryString(num, digit = 32) {
@@ -724,23 +748,15 @@ var dataStructureTyped = (() => {
     /**
      * The constructor function initializes a HashMap object with an optional initial collection and
      * options.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
      * `T`. It is an optional parameter and its default value is an empty array `[]`.
      * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
-    constructor(rawCollection = [], options) {
+    constructor(entryOrRawElements = [], options) {
       super();
       __publicField(this, "_store", {});
       __publicField(this, "_objMap", /* @__PURE__ */ new Map());
-      __publicField(this, "_toEntryFn", (rawElement) => {
-        if (this.isEntry(rawElement)) {
-          return rawElement;
-        } else {
-          throw new Error(
-            "If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified."
-          );
-        }
-      });
+      __publicField(this, "_toEntryFn");
       __publicField(this, "_size", 0);
       __publicField(this, "_hashFn", (key) => String(key));
       if (options) {
@@ -752,8 +768,8 @@ var dataStructureTyped = (() => {
           this._toEntryFn = toEntryFn;
         }
       }
-      if (rawCollection) {
-        this.setMany(rawCollection);
+      if (entryOrRawElements) {
+        this.setMany(entryOrRawElements);
       }
     }
     /**
@@ -847,23 +863,24 @@ var dataStructureTyped = (() => {
     /**
      * 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 rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
      * `T`.
      * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(rawCollection) {
+    setMany(entryOrRawElements) {
       const results = [];
-      for (const rawEle of rawCollection) {
+      for (const rawEle of entryOrRawElements) {
         let key, value;
         if (this.isEntry(rawEle)) {
           key = rawEle[0];
           value = rawEle[1];
-        } else {
+        } else if (this.toEntryFn) {
           const item = this.toEntryFn(rawEle);
           key = item[0];
           value = item[1];
         }
-        results.push(this.set(key, value));
+        if (key !== void 0 && value !== void 0)
+          results.push(this.set(key, value));
       }
       return results;
     }
@@ -1044,14 +1061,14 @@ var dataStructureTyped = (() => {
   var LinkedHashMap = class _LinkedHashMap extends IterableEntryBase {
     /**
      * The constructor initializes a LinkedHashMap object with an optional raw collection and options.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements. It is
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements. It is
      * used to initialize the HashMapLinked instance with key-value pairs. Each element in the
-     * `rawCollection` is converted to a key-value pair using the `toEntryFn` function (if provided) and
+     * `entryOrRawElements` is converted to a key-value pair using the `toEntryFn` function (if provided) and
      * then added to the HashMap
      * @param [options] - The `options` parameter is an optional object that can contain the following
      * properties:
      */
-    constructor(rawCollection = [], options) {
+    constructor(entryOrRawElements = [], options) {
       super();
       __publicField(this, "_sentinel");
       __publicField(this, "_hashFn", (key) => String(key));
@@ -1065,7 +1082,7 @@ var dataStructureTyped = (() => {
           return rawElement;
         } else {
           throw new Error(
-            "If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified."
+            "If the provided entryOrRawElements does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified."
           );
         }
       });
@@ -1082,8 +1099,8 @@ var dataStructureTyped = (() => {
           this._toEntryFn = toEntryFn;
         }
       }
-      if (rawCollection) {
-        for (const el of rawCollection) {
+      if (entryOrRawElements) {
+        for (const el of entryOrRawElements) {
           const [key, value] = this.toEntryFn(el);
           this.set(key, value);
         }
@@ -1122,7 +1139,7 @@ var dataStructureTyped = (() => {
     /**
      * The function returns the head node of a HashMapLinkedNode.
      * @returns The method `getHead()` is returning a `HashMapLinkedNode` object with key type `K` and
-     * value type `V | undefined`.
+     * a value type `V | undefined`.
      */
     get head() {
       return this._head;
@@ -1258,13 +1275,13 @@ var dataStructureTyped = (() => {
      * The function `setMany` takes an iterable collection, converts each element into a key-value pair
      * using a provided function, and sets each key-value pair in the current object, returning an array
      * of booleans indicating the success of each set operation.
-     * @param rawCollection - The rawCollection parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The entryOrRawElements parameter is an iterable collection of elements of type
      * R.
      * @returns The `setMany` function returns an array of booleans.
      */
-    setMany(rawCollection) {
+    setMany(entryOrRawElements) {
       const results = [];
-      for (const rawEle of rawCollection) {
+      for (const rawEle of entryOrRawElements) {
         const [key, value] = this.toEntryFn(rawEle);
         results.push(this.set(key, value));
       }
@@ -1314,21 +1331,20 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(1)
-       * /
-    
-       /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(1)
-       *
-       * The function `at` retrieves the key-value pair at a specified index in a linked list.
-       * @param {number} index - The index parameter is a number that represents the position of the
-       * element we want to retrieve from the data structure.
-       * @returns The method `at(index: number)` is returning an array containing the key-value pair at
-       * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
-       * where `K` is the key and `V` is the value.
-       */
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `at` retrieves the key-value pair at a specified index in a linked list.
+     * @param {number} index - The index parameter is a number that represents the position of the
+     * element we want to retrieve from the data structure.
+     * @returns The method `at(index: number)` is returning an array containing the key-value pair at
+     * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
+     * where `K` is the key and `V` is the value.
+     */
     at(index) {
       rangeCheck(index, 0, this._size - 1);
       let node = this.head;
@@ -1338,20 +1354,19 @@ var dataStructureTyped = (() => {
       return node.value;
     }
     /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       * /
-    
-       /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       *
-       * The `delete` function removes a key-value pair from a map-like data structure.
-       * @param {K} key - The `key` parameter is the key that you want to delete from the data structure.
-       * It can be of any type, but typically it is a string or an object.
-       * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
-       * was not found.
-       */
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `delete` function removes a key-value pair from a map-like data structure.
+     * @param {K} key - The `key` parameter is the key that you want to delete from the data structure.
+     * It can be of any type, but typically it is a string or an object.
+     * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
+     * was not found.
+     */
     delete(key) {
       let node;
       if (isWeakKey(key)) {
@@ -1373,19 +1388,18 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(1)
-       * /
-    
-       /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(1)
-       *
-       * The `deleteAt` function deletes a node at a specified index in a linked list.
-       * @param {number} index - The index parameter represents the position at which the node should be
-       * deleted in the linked list.
-       * @returns The size of the list after deleting the element at the specified index.
-       */
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `deleteAt` function deletes a node at a specified index in a linked list.
+     * @param {number} index - The index parameter represents the position at which the node should be
+     * deleted in the linked list.
+     * @returns The size of the list after deleting the element at the specified index.
+     */
     deleteAt(index) {
       rangeCheck(index, 0, this._size - 1);
       let node = this.head;
@@ -1395,18 +1409,17 @@ var dataStructureTyped = (() => {
       return this._deleteNode(node);
     }
     /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       * /
-    
-       /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       *
-       * The function checks if a data structure is empty by comparing its size to zero.
-       * @returns The method is returning a boolean value indicating whether the size of the object is 0 or
-       * not.
-       */
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function checks if a data structure is empty by comparing its size to zero.
+     * @returns The method is returning a boolean value indicating whether the size of the object is 0 or
+     * not.
+     */
     isEmpty() {
       return this._size === 0;
     }
@@ -1420,16 +1433,15 @@ var dataStructureTyped = (() => {
       return Array.isArray(rawElement) && rawElement.length === 2;
     }
     /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       * /
-    
-       /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       *
-       * The `clear` function clears all the entries in a data structure and resets its properties.
-       */
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `clear` function clears all the entries in a data structure and resets its properties.
+     */
     clear() {
       this._noObjMap = {};
       this._size = 0;
@@ -1457,25 +1469,24 @@ var dataStructureTyped = (() => {
       return cloned;
     }
     /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(n)
-       * /
-    
-       /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(n)
-       *
-       * The `filter` function creates a new `LinkedHashMap` containing key-value pairs from the original
-       * map that satisfy a given predicate function.
-       * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
-       * `value`, `key`, `index`, and `this`. It should return a boolean value indicating whether the
-       * current element should be included in the filtered map or not.
-       * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-       * specify the value of `this` within the `predicate` function. It is used when you want to bind a
-       * specific object as the context for the `predicate` function. If `thisArg` is not provided, `this
-       * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
-       * `LinkedHashMap` object that satisfy the given predicate function.
-       */
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new `LinkedHashMap` containing key-value pairs from the original
+     * map that satisfy a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+     * `value`, `key`, `index`, and `this`. It should return a boolean value indicating whether the
+     * current element should be included in the filtered map or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is not provided, `this
+     * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
+     * `LinkedHashMap` object that satisfy the given predicate function.
+     */
     filter(predicate, thisArg) {
       const filteredMap = new _LinkedHashMap();
       let index = 0;
@@ -1488,27 +1499,26 @@ var dataStructureTyped = (() => {
       return filteredMap;
     }
     /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(n)
-       * /
-    
-       /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(n)
-       *
-       * The `map` function in TypeScript creates a new `LinkedHashMap` by applying a callback function to
-       * each key-value pair in the original map.
-       * @param callback - The callback parameter is a function that will be called for each key-value pair
-       * in the map. It takes four arguments: the value of the current key-value pair, the key of the
-       * current key-value pair, the index of the current key-value pair, and the map itself. The callback
-       * function should
-       * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-       * specify the value of `this` within the callback function. If provided, the callback function will
-       * be called with `thisArg` as its `this` value. If not provided, `this` will refer to the current
-       * map
-       * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
-       * function.
-       */
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new `LinkedHashMap` by applying a callback function to
+     * each key-value pair in the original map.
+     * @param callback - The callback parameter is a function that will be called for each key-value pair
+     * in the map. It takes four arguments: the value of the current key-value pair, the key of the
+     * current key-value pair, the index of the current key-value pair, and the map itself. The callback
+     * function should
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If provided, the callback function will
+     * be called with `thisArg` as its `this` value. If not provided, `this` will refer to the current
+     * map
+     * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
+     * function.
+     */
     map(callback, thisArg) {
       const mappedMap = new _LinkedHashMap();
       let index = 0;
@@ -1538,18 +1548,17 @@ var dataStructureTyped = (() => {
       return this.set(key, value);
     }
     /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(1)
-       * where n is the number of entries in the LinkedHashMap.
-       * /
-    
-       /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(1)
-       * where n is the number of entries in the LinkedHashMap.
-       *
-       * The above function is an iterator that yields key-value pairs from a linked list.
-       */
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * where n is the number of entries in the LinkedHashMap.
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * where n is the number of entries in the LinkedHashMap.
+     *
+     * The above function is an iterator that yields key-value pairs from a linked list.
+     */
     *_getIterator() {
       let node = this.head;
       while (node !== this._sentinel) {
@@ -4552,17 +4561,16 @@ var dataStructureTyped = (() => {
       return newDeque;
     }
     /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(1)
-       * /
-    
-       /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(1)
-       *
-       * The above function is an implementation of the iterator protocol in TypeScript, allowing the
-       * object to be iterated over using a for...of loop.
-       */
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The above function is an implementation of the iterator protocol in TypeScript, allowing the
+     * object to be iterated over using a for...of loop.
+     */
     *_getIterator() {
       for (let i = 0; i < this.size; ++i) {
         yield this.at(i);
@@ -5859,13 +5867,12 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-       *  Dijkstra algorithm time: O(VE) space: O(VO + EO)
-       * /
-    
-       /**
-       * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
-       * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-       */
+     *  Dijkstra algorithm time: O(VE) space: O(VO + EO)
+     */
+    /**
+     * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
+     * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
+     */
     /**
      * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
@@ -5980,18 +5987,17 @@ var dataStructureTyped = (() => {
       return { distMap, preMap, seen, paths, minDist, minPath };
     }
     /**
-       *  Dijkstra algorithm time: O(logVE) space: O(VO + EO)
-       *
-       * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
-       * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edgeMap.
-       * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(VO^3), where VO is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
-       *
-       * /
-    
-       /**
-       * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
-       * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
-       */
+     *  Dijkstra algorithm time: O(logVE) space: O(VO + EO)
+     *
+     * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
+     * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edgeMap.
+     * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(VO^3), where VO is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
+     *
+     */
+    /**
+     * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
+     * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
+     */
     /**
      * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
      * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
@@ -6104,29 +6110,28 @@ var dataStructureTyped = (() => {
       return { distMap, preMap, seen, paths, minDist, minPath };
     }
     /**
-       * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
-       * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
-       * one to rest pairs
-       * /
-    
-       /**
-       * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
-       * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
-       *
-       * one to rest pairs
-       * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edgeMap for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edgeMap, the Bellman-Ford algorithm is more flexible in some scenarios.
-       * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
-       * all other vertexMap in a graph, and optionally detects negative cycles and generates the minimum path.
-       * @param {VO | VertexKey} src - The `src` parameter is the source vertex from which the Bellman-Ford algorithm will
-       * start calculating the shortest paths. It can be either a vertex object or a vertex ID.
-       * @param {boolean} [scanNegativeCycle] - A boolean flag indicating whether to scan for negative cycles in the graph.
-       * @param {boolean} [getMin] - The `getMin` parameter is a boolean flag that determines whether the algorithm should
-       * calculate the minimum distance from the source vertex to all other vertexMap in the graph. If `getMin` is set to
-       * `true`, the algorithm will find the minimum distance and update the `min` variable with the minimum
-       * @param {boolean} [genPath] - A boolean flag indicating whether to generate paths for all vertexMap from the source
-       * vertex.
-       * @returns The function `bellmanFord` returns an object with the following properties:
-       */
+     * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
+     * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
+     * one to rest pairs
+     */
+    /**
+     * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
+     * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
+     *
+     * one to rest pairs
+     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edgeMap for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edgeMap, the Bellman-Ford algorithm is more flexible in some scenarios.
+     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+     * all other vertexMap in a graph, and optionally detects negative cycles and generates the minimum path.
+     * @param {VO | VertexKey} src - The `src` parameter is the source vertex from which the Bellman-Ford algorithm will
+     * start calculating the shortest paths. It can be either a vertex object or a vertex ID.
+     * @param {boolean} [scanNegativeCycle] - A boolean flag indicating whether to scan for negative cycles in the graph.
+     * @param {boolean} [getMin] - The `getMin` parameter is a boolean flag that determines whether the algorithm should
+     * calculate the minimum distance from the source vertex to all other vertexMap in the graph. If `getMin` is set to
+     * `true`, the algorithm will find the minimum distance and update the `min` variable with the minimum
+     * @param {boolean} [genPath] - A boolean flag indicating whether to generate paths for all vertexMap from the source
+     * vertex.
+     * @returns The function `bellmanFord` returns an object with the following properties:
+     */
     bellmanFord(src, scanNegativeCycle, getMin, genPath) {
       if (getMin === void 0)
         getMin = false;
@@ -6212,13 +6217,12 @@ var dataStructureTyped = (() => {
       return { hasNegativeCycle, distMap, preMap, paths, min, minPath };
     }
     /**
-       * Dijkstra algorithm time: O(logVE) space: O(VO + EO)
-       * /
-    
-       /**
-       * Dijkstra algorithm time: O(logVE) space: O(VO + EO)
-       * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
-       */
+     * Dijkstra algorithm time: O(logVE) space: O(VO + EO)
+     */
+    /**
+     * Dijkstra algorithm time: O(logVE) space: O(VO + EO)
+     * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
+     */
     /**
      * BellmanFord time:O(VE) space:O(VO)
      * one to rest pairs
@@ -6226,27 +6230,26 @@ var dataStructureTyped = (() => {
      * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
      */
     /**
-       * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
-       * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
-       * Not support graph with negative weight cycle
-       * all pairs
-       * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edgeMap, and it can simultaneously compute shortest paths between any two nodes.
-       * /
-    
-       /**
-       * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
-       * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
-       *
-       * Not support graph with negative weight cycle
-       * all pairs
-       * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edgeMap, and it can simultaneously compute shortest paths between any two nodes.
-       * The function implements the Floyd-Warshall algorithm to find the shortest path between all pairs of vertexMap in a
-       * graph.
-       * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
-       * property is a 2D array of numbers representing the shortest path costs between vertexMap in a graph. The
-       * `predecessor` property is a 2D array of vertexMap (or `undefined`) representing the predecessor vertexMap in the shortest
-       * path between vertexMap in the
-       */
+     * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
+     * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
+     * Not support graph with negative weight cycle
+     * all pairs
+     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edgeMap, and it can simultaneously compute shortest paths between any two nodes.
+     */
+    /**
+     * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
+     * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
+     *
+     * Not support graph with negative weight cycle
+     * all pairs
+     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edgeMap, and it can simultaneously compute shortest paths between any two nodes.
+     * The function implements the Floyd-Warshall algorithm to find the shortest path between all pairs of vertexMap in a
+     * graph.
+     * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
+     * property is a 2D array of numbers representing the shortest path costs between vertexMap in a graph. The
+     * `predecessor` property is a 2D array of vertexMap (or `undefined`) representing the predecessor vertexMap in the shortest
+     * path between vertexMap in the
+     */
     floydWarshall() {
       var _a;
       const idAndVertices = [...this._vertexMap];
@@ -7734,39 +7737,31 @@ var dataStructureTyped = (() => {
   };
   var BinaryTree = class _BinaryTree extends IterableEntryBase {
     /**
-     * The constructor function initializes a binary tree object with optional keysOrNodesOrEntries and options.
-     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * The constructor function initializes a binary tree object with optional keysOrNodesOrEntriesOrRawElements and options.
+     * @param [keysOrNodesOrEntriesOrRawElements] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
      * nodes to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
      * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
      * required.
      */
-    constructor(keysOrNodesOrEntries = [], options) {
+    constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
       super();
       __publicField(this, "iterationType", "ITERATIVE");
-      __publicField(this, "_extractor", (key) => typeof key === "number" ? key : Number(key));
       __publicField(this, "_root");
-      __publicField(this, "_size");
+      __publicField(this, "_size", 0);
       __publicField(this, "_NIL", new BinaryTreeNode(NaN));
+      __publicField(this, "_toEntryFn");
       __publicField(this, "_DEFAULT_CALLBACK", (node) => node ? node.key : void 0);
       if (options) {
-        const { iterationType, extractor } = options;
+        const { iterationType, toEntryFn } = options;
         if (iterationType)
           this.iterationType = iterationType;
-        if (extractor)
-          this._extractor = extractor;
+        if (typeof toEntryFn === "function")
+          this._toEntryFn = toEntryFn;
       }
-      this._size = 0;
-      if (keysOrNodesOrEntries)
-        this.addMany(keysOrNodesOrEntries);
-    }
-    /**
-     * The function returns the value of the `_extractor` property.
-     * @returns The `_extractor` property is being returned.
-     */
-    get extractor() {
-      return this._extractor;
+      if (keysOrNodesOrEntriesOrRawElements)
+        this.addMany(keysOrNodesOrEntriesOrRawElements);
     }
     /**
      * The function returns the root node, which can be of type NODE, null, or undefined.
@@ -7790,6 +7785,13 @@ var dataStructureTyped = (() => {
     get NIL() {
       return this._NIL;
     }
+    /**
+     * The function returns the value of the _toEntryFn property.
+     * @returns The function being returned is `this._toEntryFn`.
+     */
+    get toEntryFn() {
+      return this._toEntryFn;
+    }
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {K} key - The key for the new node.
@@ -7810,36 +7812,42 @@ var dataStructureTyped = (() => {
       return new _BinaryTree([], __spreadValues({ iterationType: this.iterationType }, options));
     }
     /**
-     * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
+     * The function `keyValueOrEntryOrRawElementToNode` converts a key-value pair, entry, or raw element
+     * into a node object.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If no value
-     * is provided, it will be `undefined`.
-     * @returns a value of type NODE (node), or null, or undefined.
+     * `keyValueOrEntryOrRawElementToNode` function. It represents the value associated with a key in a
+     * key-value pair. If provided, it will be used to create a node with the specified key and value.
+     * @returns The function `keyValueOrEntryOrRawElementToNode` returns either a `NODE` object, `null`,
+     * or `undefined`.
      */
-    keyValueOrEntryToNode(keyOrNodeOrEntry, value) {
-      if (keyOrNodeOrEntry === void 0)
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value) {
+      if (keyOrNodeOrEntryOrRawElement === void 0)
         return;
-      let node;
-      if (keyOrNodeOrEntry === null) {
-        node = null;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value2] = keyOrNodeOrEntry;
-        if (key === void 0) {
+      if (keyOrNodeOrEntryOrRawElement === null)
+        return null;
+      if (this.isNode(keyOrNodeOrEntryOrRawElement))
+        return keyOrNodeOrEntryOrRawElement;
+      if (this.toEntryFn) {
+        const [key, entryValue] = this.toEntryFn(keyOrNodeOrEntryOrRawElement);
+        if (key)
+          return this.createNode(key, entryValue != null ? entryValue : value);
+        else
           return;
-        } else if (key === null) {
-          node = null;
-        } else {
-          node = this.createNode(key, value2);
-        }
-      } else if (this.isNode(keyOrNodeOrEntry)) {
-        node = keyOrNodeOrEntry;
-      } else if (!this.isNode(keyOrNodeOrEntry)) {
-        node = this.createNode(keyOrNodeOrEntry, value);
-      } else {
-        return;
       }
-      return node;
+      if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
+        const [key, value2] = keyOrNodeOrEntryOrRawElement;
+        if (key === void 0)
+          return;
+        else if (key === null)
+          return null;
+        else
+          return this.createNode(key, value2);
+      }
+      if (this.isKey(keyOrNodeOrEntryOrRawElement))
+        return this.createNode(keyOrNodeOrEntryOrRawElement, value);
+      return;
     }
     /**
      * Time Complexity: O(n)
@@ -7849,56 +7857,56 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
      *
-     * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
-     * key, otherwise it returns the key itself.
-     * @param {K | NODE | null | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `NODE`,
-     * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be used when searching for a node by key. It has a default value of
-     * `'ITERATIVE'`.
-     * @returns either the node corresponding to the given key if it is a valid node key, or the key
-     * itself if it is not a valid node key.
-     */
-    ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE") {
-      if (keyOrNodeOrEntry === this.NIL)
+     * The `ensureNode` function checks if the input is a valid node and returns it, or converts it to a
+     * node if it is a key or entry.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, `KeyOrNodeOrEntry<K, V, NODE>`, or
+     * a raw element.
+     * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
+     * parameter that specifies the type of iteration to be used when searching for a node. It has a
+     * default value of `'ITERATIVE'`.
+     * @returns The function `ensureNode` returns either a `NODE` object, `null`, or `undefined`.
+     */
+    ensureNode(keyOrNodeOrEntryOrRawElement, iterationType = "ITERATIVE") {
+      if (keyOrNodeOrEntryOrRawElement === null)
+        return null;
+      if (keyOrNodeOrEntryOrRawElement === void 0)
         return;
-      if (this.isRealNode(keyOrNodeOrEntry)) {
-        return keyOrNodeOrEntry;
-      }
-      if (this.isEntry(keyOrNodeOrEntry)) {
-        const key = keyOrNodeOrEntry[0];
+      if (keyOrNodeOrEntryOrRawElement === this.NIL)
+        return;
+      if (this.isNode(keyOrNodeOrEntryOrRawElement))
+        return keyOrNodeOrEntryOrRawElement;
+      if (this.toEntryFn) {
+        const [key] = this.toEntryFn(keyOrNodeOrEntryOrRawElement);
+        if (key)
+          return this.getNodeByKey(key);
+      }
+      if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
+        const key = keyOrNodeOrEntryOrRawElement[0];
         if (key === null)
           return null;
         if (key === void 0)
           return;
         return this.getNodeByKey(key, iterationType);
       }
-      if (keyOrNodeOrEntry === null)
-        return null;
-      if (keyOrNodeOrEntry === void 0)
-        return;
-      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
-    }
-    /**
-     * The function checks if a given node is a real node or null.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-     * @returns a boolean value.
-     */
-    isNodeOrNull(node) {
-      return this.isRealNode(node) || node === null;
+      if (this.isKey(keyOrNodeOrEntryOrRawElement))
+        return this.getNodeByKey(keyOrNodeOrEntryOrRawElement, iterationType);
+      return;
     }
     /**
-     * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the class NODE.
+     * The function checks if the input is an instance of the BinaryTreeNode class.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * an instance of the `BinaryTreeNode` class.
      */
-    isNode(keyOrNodeOrEntry) {
-      return keyOrNodeOrEntry instanceof BinaryTreeNode;
+    isNode(keyOrNodeOrEntryOrRawElement) {
+      return keyOrNodeOrEntryOrRawElement instanceof BinaryTreeNode;
     }
     /**
-     * The function checks if a given node is a real node by verifying if it is an instance of
-     * BinaryTreeNode and its key is not NaN.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * The function checks if a given node is a valid node in a binary search tree.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
     isRealNode(node) {
@@ -7907,21 +7915,64 @@ var dataStructureTyped = (() => {
       return this.isNode(node);
     }
     /**
-     * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * The function checks if a given node is a real node or null.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value.
+     */
+    isNodeOrNull(node) {
+      return this.isRealNode(node) || node === null;
+    }
+    /**
+     * The function checks if a given node is equal to the NIL value.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
     isNIL(node) {
       return node === this.NIL;
     }
     /**
-     * The function checks if a given value is an entry in a binary tree node.
-     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
-     * two type parameters V and NODE, representing the value and node type respectively.
+     * The function checks if the input is an array with two elements, indicating it is a binary tree
+     * node entry.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value.
+     */
+    isEntry(keyOrNodeOrEntryOrRawElement) {
+      return Array.isArray(keyOrNodeOrEntryOrRawElement) && keyOrNodeOrEntryOrRawElement.length === 2;
+    }
+    /**
+     * The function checks if a given value is a valid key by evaluating its type and value.
+     * @param {any} key - The `key` parameter can be of any type. It is the value that we want to check
+     * if it is a valid key.
+     * @param [isCheckValueOf=true] - The `isCheckValueOf` parameter is a boolean flag that determines
+     * whether the function should check the valueOf() method of an object when the key is of type
+     * 'object'. If `isCheckValueOf` is true, the function will recursively call itself with the value
+     * returned by key.valueOf().
      * @returns a boolean value.
      */
-    isEntry(keyOrNodeOrEntry) {
-      return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
+    isKey(key, isCheckValueOf = true) {
+      if (key === null)
+        return true;
+      const keyType = typeof key;
+      if (keyType === "string" || keyType === "bigint" || keyType === "boolean")
+        return true;
+      if (keyType === "number")
+        return !isNaN(key);
+      if (keyType === "symbol" || keyType === "undefined")
+        return false;
+      if (keyType === "function")
+        return this.isKey(key());
+      if (keyType === "object") {
+        if (typeof key.toString === "function")
+          return true;
+        if (isCheckValueOf && typeof key.valueOf === "function") {
+          this.isKey(key.valueOf(), false);
+        }
+        return false;
+      }
+      return false;
     }
     /**
      * Time Complexity O(n)
@@ -7931,14 +7982,20 @@ var dataStructureTyped = (() => {
      * Time Complexity O(n)
      * Space Complexity O(1)
      *
-     * The `add` function adds a new node to a binary tree, either by creating a new node or replacing an
-     * existing node with the same key.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
-     * @param {V} [value] - The value to be inserted into the binary tree.
-     * @returns The function `add` returns either a node (`NODE`), `null`, or `undefined`.
-     */
-    add(keyOrNodeOrEntry, value) {
-      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
+     * The `add` function is used to insert a new node into a binary tree, checking for duplicate keys
+     * and finding the appropriate insertion position.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * `keyOrNodeOrEntryOrRawElement` parameter can accept a value of type `R`, which represents the key,
+     * node, entry, or raw element to be added to the tree. It can also accept a value of type
+     * `KeyOrNodeOrEntry<K, V, NODE>
+     * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
+     * key being added to the tree. It represents the value that will be stored in the tree for the given
+     * key.
+     * @returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
+     * insertion position cannot be found or if there are duplicate keys.
+     */
+    add(keyOrNodeOrEntryOrRawElement, value) {
+      const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value);
       if (newNode === void 0)
         return false;
       if (!this.root) {
@@ -7986,19 +8043,23 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
      *
-     * The `addMany` function takes in a collection of keysOrNodesOrEntries and an optional collection of values, and
-     * adds each node with its corresponding value to the data structure.
-     * @param keysOrNodesOrEntries - An iterable collection of KeyOrNodeOrEntry objects.
-     * @param [values] - An optional iterable of values that will be assigned to each node being added.
-     * @returns The function `addMany` returns an array of `NODE`, `null`, or `undefined` values.
+     * The `addMany` function takes in an iterable of keys or nodes or entries or raw elements, and an
+     * optional iterable of values, and adds each key or node or entry with its corresponding value to a
+     * data structure, returning an array of booleans indicating whether each insertion was successful.
+     * @param keysOrNodesOrEntriesOrRawElements - An iterable containing keys, nodes, entries, or raw
+     * elements. These elements will be added to the data structure.
+     * @param [values] - An optional iterable of values that correspond to the keys or nodes or entries
+     * in the `keysOrNodesOrEntriesOrRawElements` parameter.
+     * @returns The function `addMany` returns an array of booleans indicating whether each element was
+     * successfully added to the data structure.
      */
-    addMany(keysOrNodesOrEntries, values) {
+    addMany(keysOrNodesOrEntriesOrRawElements, values) {
       const inserted = [];
       let valuesIterator;
       if (values) {
         valuesIterator = values[Symbol.iterator]();
       }
-      for (const keyOrNodeOrEntry of keysOrNodesOrEntries) {
+      for (const keyOrNodeOrEntryOrRawElement of keysOrNodesOrEntriesOrRawElements) {
         let value = void 0;
         if (valuesIterator) {
           const valueResult = valuesIterator.next();
@@ -8006,7 +8067,7 @@ var dataStructureTyped = (() => {
             value = valueResult.value;
           }
         }
-        inserted.push(this.add(keyOrNodeOrEntry, value));
+        inserted.push(this.add(keyOrNodeOrEntryOrRawElement, value));
       }
       return inserted;
     }
@@ -8019,38 +8080,36 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
      *
-     * The `refill` function clears the current data and adds new key-value pairs to the data structure.
-     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries. These can be of type
-     * KeyOrNodeOrEntry<K, V, NODE>.
-     * @param [values] - The `values` parameter is an optional iterable that contains the values to be
-     * associated with the keys or nodes or entries in the `keysOrNodesOrEntries` parameter. If provided,
-     * the values will be associated with the corresponding keys or nodes or entries in the
-     * `keysOrNodesOrEntries` iterable
+     * The `refill` function clears the current data and adds new data to the collection.
+     * @param keysOrNodesOrEntriesOrRawElements - An iterable collection of keys, nodes, entries, or raw
+     * elements. These can be of any type (R) or a specific type (KeyOrNodeOrEntry<K, V, NODE>).
+     * @param [values] - The `values` parameter is an optional iterable of values that will be associated
+     * with the keys or nodes being added. If provided, the values will be assigned to the corresponding
+     * keys or nodes. If not provided, the values will be set to `undefined`.
      */
-    refill(keysOrNodesOrEntries, values) {
+    refill(keysOrNodesOrEntriesOrRawElements, values) {
       this.clear();
-      this.addMany(keysOrNodesOrEntries, values);
-    }
-    /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(1)
-       * /
-    
-       /**
-       * Time Complexity: O(n)
-       * Space Complexity: O(1)
-       *
-       * The function deletes a node from a binary tree and returns an array of the deleted nodes along
-       * with the nodes that need to be balanced.
-       * @param {ReturnType<C> | null | undefined} identifier - The identifier parameter is the value or
-       * object that you want to delete from the binary tree. It can be of any type that is compatible with
-       * the callback function's return type. It can also be null or undefined if you want to delete a
-       * specific node based on its value or object.
-       * @param {C} callback - The `callback` parameter is a function that is used to determine the
-       * identifier of the node to be deleted. It is optional and has a default value of
-       * `this._DEFAULT_CALLBACK`. The `callback` function should return the identifier of the node.
-       * @returns an array of `BinaryTreeDeleteResult<NODE>`.
-       */
+      this.addMany(keysOrNodesOrEntriesOrRawElements, values);
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The above function is a TypeScript implementation of deleting a node from a binary tree, returning
+     * the deleted node and the node that needs to be balanced.
+     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
+     * used to identify the node that needs to be deleted from the binary tree. It can be of any type
+     * that is returned by the callback function.
+     * @param {C} callback - The `callback` parameter is a function that is used to determine the
+     * identifier of the node to be deleted. It is of type `C`, which extends the `BTNCallback<NODE>`
+     * interface. The `BTNCallback<NODE>` interface represents a callback function that takes a node of
+     * type `NODE
+     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
+     */
     delete(identifier, callback = this._DEFAULT_CALLBACK) {
       const deletedResult = [];
       if (!this.root)
@@ -8099,28 +8158,27 @@ var dataStructureTyped = (() => {
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(k + log n).
+     * Space Complexity: O(k + log n)
      *
-     * The function `getNodes` retrieves nodes from a binary tree based on a given identifier and
-     * callback function.
+     * The function `getNodes` returns an array of nodes that match a given identifier, using either a
+     * recursive or iterative approach.
      * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
-     * that you want to search for in the binary tree. It can be of any type that is returned by the
-     * callback function `C`. It can also be `null` or `undefined` if you don't want to search for a
-     * specific value.
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
-     * input and returns a value of type `C`. It is used to determine if a node matches the given
-     * identifier. If no callback is provided, the `_DEFAULT_CALLBACK` function is used as the
-     * default
-     * @param [onlyOne=false] - A boolean value indicating whether to only return the first node that
-     * matches the identifier. If set to true, the function will stop iterating once it finds a matching
-     * node and return that node. If set to false (default), the function will continue iterating and
-     * return all nodes that match the identifier.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node for the traversal. It can be either a key, a node object, or `null`/`undefined`. If
-     * it is `null` or `undefined`, an empty array will be returned.
-     * @param iterationType - The `iterationType` parameter determines the type of iteration used to
-     * traverse the binary tree. It can have two possible values:
-     * @returns an array of nodes of type `NODE`.
+     * that is used to identify the nodes. It can be of any type and is used to match against the result
+     * of the callback function for each node.
+     * @param {C} callback - The `callback` parameter is a function that takes a node as input and
+     * returns a value. This value is used to identify the nodes that match the given identifier. The
+     * `callback` function is optional and defaults to a default callback function
+     * (`this._DEFAULT_CALLBACK`) if not provided.
+     * @param [onlyOne=false] - A boolean value indicating whether to return only one node that matches
+     * the identifier or all nodes that match the identifier. If set to true, only the first matching
+     * node will be returned. If set to false, all matching nodes will be returned. The default value is
+     * false.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for the search. It can be either a node object, a key-value pair, or a key. If it is not
+     * provided, the `root` of the data structure is used as the starting point.
+     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
+     * iteration to be performed on the nodes of a binary tree. It can have two possible values:
+     * @returns an array of NODE objects.
      */
     getNodes(identifier, callback = this._DEFAULT_CALLBACK, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNode(beginRoot);
@@ -8164,24 +8222,21 @@ var dataStructureTyped = (() => {
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Space Complexity: O(log n).
      *
-     * The function `getNode` returns the first node that matches the given identifier and callback
-     * function.
+     * The function `getNode` returns the first node that matches the given identifier and callback,
+     * starting from the specified root node and using the specified iteration type.
      * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
-     * used to identify the node you want to retrieve. It can be of any type that is returned by the
-     * callback function `C`. It can also be `null` or `undefined` if you don't have a specific
-     * identifier.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
-     * function should take a single parameter of type `NODE` (the type of the nodes in the binary tree) and
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for searching the binary tree. It can be either a key value, a node object, or `null`/`undefined`.
-     * If `null` or `undefined` is passed, the search will start from the root of the binary tree.
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed when searching for nodes in the binary tree. It determines the order in which the
-     * nodes are visited during the search.
-     * @returns a value of type `NODE | null | undefined`.
+     * used to identify the node you want to retrieve. It can be of any type that is the return type of
+     * the `C` callback function, or it can be `null` or `undefined`.
+     * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
+     * node matches the desired criteria. It should return a value that can be used to identify the node.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for searching nodes in a tree structure. It can be either a root node, a key-value pair, or
+     * a node entry. If not provided, the search will start from the root of the tree.
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
+     * of iteration to be performed when searching for nodes. It can have one of the following values:
+     * @returns The method is returning a NODE object, or null, or undefined.
      */
     getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
       var _a;
@@ -8195,15 +8250,13 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
      *
-     * The function `getNodeByKey` searches for a node in a binary tree by its key, using either
-     * recursive or iterative iteration.
-     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
-     * It is used to find the node with the matching key value.
-     * @param iterationType - The `iterationType` parameter is used to determine whether the search for
-     * the node with the given key should be performed iteratively or recursively. It has two possible
-     * values:
-     * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
-     * found in the binary tree. If no node is found, it returns `undefined`.
+     * The function `getNodeByKey` returns a node with a specific key value from a tree structure.
+     * @param {K} key - The key parameter is the value that you want to search for in the tree. It is
+     * used to find the node with the matching key value.
+     * @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 a value of type NODE, null, or undefined.
      */
     getNodeByKey(key, iterationType = "ITERATIVE") {
       return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
@@ -8216,23 +8269,22 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
      *
-     * The function `get` retrieves the value of a node in a binary tree based on the provided identifier
-     * and callback function.
+     * The function `get` in TypeScript overrides the base class method and returns the value associated
+     * with the given identifier.
      * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
-     * used to identify the node in the binary tree. It can be of any type that is the return type of the
+     * used to identify the node in the binary tree. It can be of any type that is returned by the
      * callback function `C`. It can also be `null` or `undefined` if no identifier is provided.
-     * @param {C} callback - The `callback` parameter is a function that will be called with each node in
-     * the binary tree. It is used to determine whether a node matches the given identifier. The callback
-     * function should return a value that can be compared to the identifier to determine if it is a
-     * match.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
-     * node), a node object of type `NODE`, or `null`/`undefined` to start the search from the root of
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed when searching for a node in the binary tree. It is an optional parameter with a
-     * default value specified by `this.iterationType`.
-     * @returns The value of the node with the given identifier is being returned. If the node is not
-     * found, `undefined` is returned.
+     * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
+     * node matches the given identifier. It is optional and defaults to `this._DEFAULT_CALLBACK`.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for the search in the binary tree. It can be either a root node of the tree or a key, node,
+     * or entry object that exists in the tree. If no specific starting point is provided, the search
+     * will begin from the root of the
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
+     * of iteration to be performed when searching for a node in the tree. It can have one of the
+     * following values:
+     * @returns The method is returning the value associated with the specified identifier in the binary
+     * tree.
      */
     get(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
       var _a;
@@ -8240,28 +8292,27 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n).
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n).
+     * Space Complexity: O(log n)
      *
-     * The function checks if a Binary Tree Node with a specific identifier exists in the tree.
+     * The `has` function checks if a given identifier exists in the data structure and returns a boolean
+     * value.
      * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
-     * that you want to search for in the binary tree. It can be of any type that is returned by the
-     * callback function `C`. It can also be `null` or `undefined` if you don't want to specify a
-     * specific identifier.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the binary tree. It is used to filter the nodes based on certain conditions. The `callback`
-     * function should return a boolean value indicating whether the node should be included in the
-     * result or not.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
-     * node in the binary tree), a node object (`NODE`), or `null`/`undefined` to start the search from
-     * @param iterationType - The `iterationType` parameter is a variable that determines the type of
-     * iteration to be performed on the binary tree. It is used to specify whether the iteration should
-     * be performed in a pre-order, in-order, or post-order manner.
-     * @returns a boolean value.
+     * used to identify a specific node or entry in the data structure. It can be of any type that is
+     * returned by the callback function `C`. It can also be `null` or `undefined` if no specific
+     * identifier is provided.
+     * @param {C} callback - The `callback` parameter is a function that will be used to determine
+     * whether a node should be included in the result or not. It is of type `C`, which extends the
+     * `BTNCallback<NODE>` type.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for the iteration in the data structure. It can be either a root node, a key-value pair, or
+     * a node entry. If not specified, it defaults to the root of the data structure.
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
+     * of iteration to be performed. It is an optional parameter with a default value of `IterationType`.
+     * @returns The method is returning a boolean value.
      */
     has(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
       callback = this._ensureCallback(identifier, callback);
@@ -8305,9 +8356,10 @@ var dataStructureTyped = (() => {
      *
      * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
      * height of the tree.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for calculating the height and minimum height of a binary tree. It can be either a `K` (a key
-     * value of a binary tree node), `NODE` (a node of a binary tree), `null`, or `undefined`. If
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The parameter `beginRoot` is optional and
+     * has a default value of `this.root`. It represents the starting point for checking if the tree is
+     * perfectly balanced. It can be either a root node (`R`), a key or node or entry
+     * (`KeyOrNodeOrEntry<K, V, NODE
      * @returns a boolean value.
      */
     isPerfectlyBalanced(beginRoot = this.root) {
@@ -8321,12 +8373,14 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function `isSubtreeBST` checks if a given binary tree is a valid binary search tree.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the root
-     * node of the binary search tree (BST) that you want to check if it is a subtree of another BST.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when checking if a subtree is a binary search tree (BST). It can have two
-     * possible values:
+     * The function `isBST` checks if a binary search tree is valid, either recursively or iteratively.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point for checking if a binary search tree (BST) is valid. It can be either a root node
+     * of the BST, a key value of a node in the BST, or an entry object containing both the key and value
+     * of a node in the BST
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to determine the type
+     * of iteration to be performed while checking if the binary search tree (BST) is valid. It can have
+     * two possible values:
      * @returns a boolean value.
      */
     isBST(beginRoot = this.root, iterationType = this.iterationType) {
@@ -8337,7 +8391,7 @@ var dataStructureTyped = (() => {
         const dfs = (cur, min, max) => {
           if (!this.isRealNode(cur))
             return true;
-          const numKey = this.extractor(cur.key);
+          const numKey = Number(cur.key);
           if (numKey <= min || numKey >= max)
             return false;
           return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
@@ -8356,7 +8410,7 @@ var dataStructureTyped = (() => {
               curr = curr.left;
             }
             curr = stack.pop();
-            const numKey = this.extractor(curr.key);
+            const numKey = Number(curr.key);
             if (!this.isRealNode(curr) || !checkMax && prev >= numKey || checkMax && prev <= numKey)
               return false;
             prev = numKey;
@@ -8376,25 +8430,26 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function calculates the depth of a given node in a binary tree.
-     * @param {K | NODE | null | undefined} dist - The `dist` parameter represents the node in
-     * the binary tree whose depth we want to find. It can be of type `K`, `NODE`, `null`, or
-     * `undefined`.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
-     * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
-     * `NODE` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
-     * @returns the depth of the `dist` relative to the `beginRoot`.
+     * The function calculates the depth of a given node or key in a tree-like data structure.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} dist - The `dist` parameter can be either a `R`
+     * (representing a root node), or a `KeyOrNodeOrEntry<K, V, NODE>` (representing a key, node, or
+     * entry).
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is optional and
+     * represents the starting point from which to calculate the depth. It can be either a reference to a
+     * node in the tree or a key-value pair or an entry object. If not provided, the default value is
+     * `this.root`, which refers to the root node
+     * @returns the depth of a node in a tree structure.
      */
     getDepth(dist, beginRoot = this.root) {
-      dist = this.ensureNode(dist);
-      beginRoot = this.ensureNode(beginRoot);
+      let distEnsured = this.ensureNode(dist);
+      const beginRootEnsured = this.ensureNode(beginRoot);
       let depth = 0;
-      while (dist == null ? void 0 : dist.parent) {
-        if (dist === beginRoot) {
+      while (distEnsured == null ? void 0 : distEnsured.parent) {
+        if (distEnsured === beginRootEnsured) {
           return depth;
         }
         depth++;
-        dist = dist.parent;
+        distEnsured = distEnsured.parent;
       }
       return depth;
     }
@@ -8404,17 +8459,16 @@ var dataStructureTyped = (() => {
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Space Complexity: O(1)
      *
-     * The function `getHeight` calculates the maximum height of a binary tree using either recursive or
-     * iterative traversal.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node of the binary tree from which we want to calculate the height. It can be of type
-     * `K`, `NODE`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
-     * @param iterationType - The `iterationType` parameter is used to determine whether to calculate the
-     * height of the tree using a recursive approach or an iterative approach. It can have two possible
-     * values:
-     * @returns the height of the binary tree.
+     * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
+     * or iterative approach.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point for calculating the height of a tree. It can be either a root node (`R`), a key or
+     * node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current tree.
+     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
+     * iteration used to calculate the height of the tree. It can have two possible values:
+     * @returns the maximum height of the binary tree.
      */
     getHeight(beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNode(beginRoot);
@@ -8453,12 +8507,15 @@ var dataStructureTyped = (() => {
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node of the binary tree from which we want to calculate the minimum height. It can be of
-     * type `K`, `NODE`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
-     * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
-     * to calculate the minimum height of a binary tree. It can have two possible values:
-     * @returns The function `getMinHeight` returns the minimum height of a binary tree.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point for calculating the minimum height of a tree. It can be either a root node (`R`), a
+     * key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current
+     * tree.
+     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
+     * iteration to be used when calculating the minimum height of the tree. It can have two possible
+     * values:
+     * @returns The function `getMinHeight` returns a number, which represents the minimum height of the
+     * binary tree.
      */
     getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
       var _a, _b, _c;
@@ -8503,34 +8560,32 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-       * Time Complexity: O(log n)
-       * Space Complexity: O(log n)
-       * /
-    
-       /**
-       * Time Complexity: O(log n)
-       * Space Complexity: O(log n)
-       *
-       * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
-       * structure, with the option to reverse the order of the nodes.
-       * @param {K | NODE | null | undefined} beginNode - The `beginRoot` parameter represents the
-       * starting node from which you want to find the path to the root. It can be of type `K`, `NODE`,
-       * `null`, or `undefined`.
-       * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
-       * resulting path should be reversed or not. If `isReverse` is set to `true`, the path will be
-       * reversed before returning it. If `isReverse` is set to `false`, the path will be returned as is
-       * @returns The function `getPathToRoot` returns an array of nodes (`NODE[]`).
-       */
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     *
+     * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
+     * up to the root node, with an option to reverse the order of the nodes.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginNode - The `beginNode` parameter can be either of
+     * type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
+     * resulting path should be reversed or not. If `isReverse` is set to `true`, the path will be
+     * reversed before returning it. If `isReverse` is set to `false` or not provided, the path will
+     * @returns The function `getPathToRoot` returns an array of `NODE` objects.
+     */
     getPathToRoot(beginNode, isReverse = true) {
       const result = [];
-      beginNode = this.ensureNode(beginNode);
-      if (!beginNode)
+      let beginNodeEnsured = this.ensureNode(beginNode);
+      if (!beginNodeEnsured)
         return result;
-      while (beginNode.parent) {
-        result.push(beginNode);
-        beginNode = beginNode.parent;
+      while (beginNodeEnsured.parent) {
+        result.push(beginNodeEnsured);
+        beginNodeEnsured = beginNodeEnsured.parent;
       }
-      result.push(beginNode);
+      result.push(beginNodeEnsured);
       return isReverse ? result.reverse() : result;
     }
     /**
@@ -8541,15 +8596,14 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `getLeftMost` returns the leftmost node in a binary tree, either recursively or
-     * iteratively.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for finding the leftmost node in a binary tree. It can be either a `K` (a key value), `NODE` (a
-     * node), `null`, or `undefined`. If not provided, it defaults to `this.root`,
-     * @param iterationType - The `iterationType` parameter is used to determine the type of iteration to
-     * be performed when finding the leftmost node in a binary tree. It can have two possible values:
-     * @returns The function `getLeftMost` returns the leftmost node (`NODE`) in the binary tree. If there
-     * is no leftmost node, it returns `null` or `undefined` depending on the input.
+     * The `getLeftMost` function returns the leftmost node in a binary tree, either using recursive or
+     * iterative traversal.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point for finding the leftmost node in a binary tree. It can be either a root node (`R`),
+     * a key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
+     * of iteration to be performed. It can have two possible values:
+     * @returns The function `getLeftMost` returns the leftmost node in a binary tree.
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
       if (this.isNIL(beginRoot))
@@ -8581,16 +8635,15 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `getRightMost` returns the rightmost node in a binary tree, either recursively or
+     * The `getRightMost` function returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node from which we want to find the rightmost node. It can be of type `K`, `NODE`,
-     * `null`, or `undefined`. If not provided, it defaults to `this.root`, which is a property of the
-     * current object.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when finding the rightmost node. It can have one of two values:
-     * @returns The function `getRightMost` returns the rightmost node (`NODE`) in a binary tree. If there
-     * is no rightmost node, it returns `null` or `undefined`, depending on the input.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point for finding the rightmost node in a binary tree. It can be either a root node
+     * (`R`), a key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
+     * of iteration to be performed when finding the rightmost node in a binary tree. It can have two
+     * possible values:
+     * @returns The function `getRightMost` returns a NODE object, `null`, or `undefined`.
      */
     getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
       if (this.isNIL(beginRoot))
@@ -8622,10 +8675,10 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function returns the predecessor of a given node in a tree.
-     * @param {NODE} node - The parameter `node` is of type `RedBlackTreeNode`, which represents a node in a
+     * The function returns the predecessor node of a given node in a binary tree.
+     * @param {NODE} node - The parameter "node" is of type "NODE", which represents a node in a binary
      * tree.
-     * @returns the predecessor of the given 'node'.
+     * @returns the predecessor node of the given node.
      */
     getPredecessor(node) {
       if (this.isRealNode(node.left)) {
@@ -8650,8 +8703,8 @@ var dataStructureTyped = (() => {
      *
      * The function `getSuccessor` returns the next node in a binary tree given a current node.
      * @param {K | NODE | null} [x] - The parameter `x` can be of type `K`, `NODE`, or `null`.
-     * @returns the successor of the given node or key. The successor is the node that comes immediately
-     * after the given node in the inorder traversal of the binary tree.
+     * @returns The function `getSuccessor` returns a `NODE` object if a successor exists, `null` if
+     * there is no successor, and `undefined` if the input `x` is not a valid node.
      */
     getSuccessor(x) {
       x = this.ensureNode(x);
@@ -8668,33 +8721,32 @@ var dataStructureTyped = (() => {
       return y;
     }
     /**
-       * Time complexity: O(n)
-       * Space complexity: O(n)
-       * /
-    
-       /**
-       * Time complexity: O(n)
-       * Space complexity: O(n)
-       *
-       * The `dfs` function performs a depth-first search traversal on a binary tree or graph, based on the
-       * specified pattern and iteration type, and returns an array of values obtained from applying a
-       * callback function to each visited node.
-       * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-       * the tree during the depth-first search. It takes a single parameter, which can be of type `NODE`,
-       * `null`, or `undefined`, and returns a value of any type. The default value for this parameter is
-       * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
-       * nodes are traversed during the depth-first search. It can have one of the following values:
-       * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
-       * for the depth-first search traversal. It can be specified as a key, a node object, or
-       * `null`/`undefined`. If not provided, the `beginRoot` will default to the root node of the tree.
-       * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
-       * iteration to use when traversing the tree. It can have one of the following values:
-       * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
-       * whether null or undefined nodes should be included in the traversal. If `includeNull` is set to
-       * `true`, null or undefined nodes will be included in the traversal. If `includeNull` is set to
-       * `false`, null or undefined
-       * @returns an array of values that are the return values of the callback function.
-       */
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `dfs` function performs a depth-first search traversal on a binary tree, executing a callback
+     * function on each node according to a specified pattern and iteration type.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node
+     * visited during the depth-first search. It takes a node as an argument and returns a value. The
+     * return type of the callback function is determined by the generic type `C`.
+     * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter determines the order in which the
+     * nodes are visited during the depth-first search. It can have one of the following values:
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point of the depth-first search. It can be either a node object, a key-value pair, or a key. If it
+     * is a key or key-value pair, the method will find the corresponding node in the tree and start the
+     * search from there.
+     * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter determines the
+     * type of iteration to use during the depth-first search. It can have two possible values:
+     * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
+     * whether or not to include null values in the depth-first search traversal. If `includeNull` is set
+     * to `true`, null values will be included in the traversal. If `includeNull` is set to `false`, null
+     * values will
+     * @returns an array of the return types of the callback function.
+     */
     dfs(callback = this._DEFAULT_CALLBACK, pattern = "IN", beginRoot = this.root, iterationType = "ITERATIVE", includeNull = false) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
@@ -8802,22 +8854,23 @@ var dataStructureTyped = (() => {
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
-     * The `bfs` function performs a breadth-first search traversal on a binary tree, executing a
-     * callback function on each node.
+     * The `bfs` function performs a breadth-first search on a binary tree, calling a callback function
+     * on each node and returning an array of the results.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the breadth-first search traversal. It takes a single parameter, which is the current node being
+     * the breadth-first search traversal. It takes a single argument, which is the current node being
      * visited, and returns a value of any type.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node for the breadth-first search traversal. It can be specified as a key, a node object,
-     * or `null`/`undefined` to indicate the root of the tree. If not provided, the `root` property of
-     * the class is used as
-     * @param iterationType - The `iterationType` parameter determines the type of iteration to be
-     * performed during the breadth-first search (BFS). It can have two possible values:
-     * @param [includeNull=false] - The `includeNull` parameter is a boolean flag that determines whether
-     * to include null values in the breadth-first search traversal. If `includeNull` is set to
-     * `true`, null values will be included in the traversal, otherwise they will be skipped.
-     * @returns an array of values that are the result of invoking the callback function on each node in
-     * the breadth-first traversal of a binary tree.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point of the breadth-first search. It can be either a root node of a tree or a key, node,
+     * or entry object. If no value is provided, the `root` property of the class is used as the default
+     * starting point.
+     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
+     * iteration to be performed. It can have two possible values:
+     * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
+     * whether or not to include null values in the breadth-first search (BFS) traversal. If
+     * `includeNull` is set to `true`, null values will be included in the traversal. If `includeNull` is
+     * set to `false
+     * @returns The function `bfs` returns an array of values that are the result of invoking the
+     * `callback` function on each node in the breadth-first order traversal of the binary tree.
      */
     bfs(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
       beginRoot = this.ensureNode(beginRoot);
@@ -8877,18 +8930,18 @@ var dataStructureTyped = (() => {
      * Space complexity: O(n)
      *
      * The `listLevels` function returns an array of arrays, where each inner array represents a level in
-     * a binary tree and contains the values returned by a callback function applied to the nodes at that
-     * level.
+     * a binary tree and contains the results of applying a callback function to the nodes at that level.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It takes a single parameter, which can be of type `NODE`, `null`, or `undefined`, and
-     * returns a value of any type.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node for traversing the tree. It can be either a node object (`NODE`), a key value
-     * (`K`), `null`, or `undefined`. If not provided, it defaults to the root node of the tree.
-     * @param iterationType - The `iterationType` parameter determines the type of iteration to be
-     * performed on the tree. It can have two possible values:
+     * the tree. It takes a node as an argument and returns a value. The return type of the callback
+     * function is determined by the generic type `C` which extends `BTNCallback<NODE | null>`.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point for traversing the tree. It can be either a root node, a key-value pair, or a node
+     * entry. If no value is provided, the `root` property of the class is used as the default starting
+     * point.
+     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
+     * iteration to be performed on the binary tree. It can have two possible values:
      * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
-     * whether to include null values in the resulting levels. If `includeNull` is set to `true`,
+     * whether or not to include null values in the resulting levels. If `includeNull` is set to `true`,
      * null values will be included in the levels. If `includeNull` is set to `false`, null values will
      * be excluded
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
@@ -8950,17 +9003,17 @@ var dataStructureTyped = (() => {
      * The `morris` function performs a depth-first traversal on a binary tree using the Morris traversal
      * algorithm.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It takes a single parameter of type `NODE` (the type of the nodes in the tree) and returns
-     * a value of any type.
-     * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
-     * determines the order in which the nodes of a binary tree are traversed. It can have one of the
+     * the tree. It takes a single argument, which is the current node, and can return any value. The
+     * return type of the `callback` function is determined by the `ReturnType<C>` type, which represents
+     * the return
+     * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `morris` function is used
+     * to specify the order in which the nodes of a binary tree are traversed. It can take one of the
      * following values:
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
-     * for the traversal. It can be specified as a key, a node object, or `null`/`undefined` to indicate
-     * the root of the tree. If no value is provided, the default value is the root of the tree.
-     * @returns The function `morris` returns an array of values that are the result of invoking the
-     * `callback` function on each node in the binary tree. The type of the array nodes is determined
-     * by the return type of the `callback` function.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for the traversal. It can be either a node object, a key, or an entry object. If no value is
+     * provided, the `root` of the tree is used as the starting point.
+     * @returns The function `morris` returns an array of values that are the return values of the
+     * callback function `callback`.
      */
     morris(callback = this._DEFAULT_CALLBACK, pattern = "IN", beginRoot = this.root) {
       beginRoot = this.ensureNode(beginRoot);
@@ -9051,8 +9104,7 @@ var dataStructureTyped = (() => {
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
-     * The `clone` function creates a new tree object and copies all the nodes from the original tree to
-     * the new tree.
+     * The `clone` function creates a deep copy of a tree object.
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
     clone() {
@@ -9078,16 +9130,16 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function creates a new tree by iterating over the nodes of the current tree and
-     * adding only the nodes that satisfy the given predicate function.
-     * @param predicate - The `predicate` parameter is a function that takes three arguments: `value`,
-     * `key`, and `index`. It should return a boolean value indicating whether the pair should be
-     * included in the filtered tree or not.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
-     * it will be passed as the first argument to the `predicate` function. If `thisArg` is
-     * @returns The `filter` method is returning a new tree object that contains the key-value pairs that
-     * pass the given predicate function.
+     * The `filter` function creates a new tree with entries that pass a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that is used to test each
+     * element in the tree. It takes three arguments: `value`, `key`, and `index`. The `value` argument
+     * represents the value of the current element being processed, the `key` argument represents the key
+     * of the
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. When the `predicate` function is
+     * called, `thisArg` will be used as the value of `this` within the function. If `thisArg`
+     * @returns The `filter` method is returning a new tree object that contains the entries that pass
+     * the given predicate function.
      */
     filter(predicate, thisArg) {
       const newTree = this.createTree();
@@ -9107,15 +9159,15 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function creates a new tree by applying a callback function to each key-value pair in
-     * the original tree.
-     * @param callback - The callback parameter is a function that will be called for each key-value pair
-     * in the tree. It takes four arguments: the value of the current pair, the key of the current pair,
-     * the index of the current pair, and a reference to the tree itself. The callback function should
-     * return a new
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-     * specify the value of `this` within the callback function. If you pass a value for `thisArg`, it
-     * will be used as the `this` value when the callback function is called. If you don't pass a value
+     * The `map` function creates a new tree by applying a callback function to each entry in the current
+     * tree.
+     * @param callback - The callback parameter is a function that will be called for each entry in the
+     * tree. It takes three arguments: value, key, and index. The value argument represents the value of
+     * the current entry, the key argument represents the key of the current entry, and the index
+     * argument represents the index of the
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
      * @returns The `map` method is returning a new tree object.
      */
     map(callback, thisArg) {
@@ -9143,11 +9195,15 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {K | NODE | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | NODE | null |
-     * undefined`. It represents the root node of a binary tree. The root node can have one of the
-     * following types:
-     * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
+     * The `print` function in TypeScript prints the binary tree structure with customizable options.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for printing the binary tree. It can be either a node of the binary tree or a key or entry
+     * that exists in the binary tree. If no value is provided, the root of the binary tree will be used
+     * as the starting point.
+     * @param {BinaryTreePrintOptions} [options] - The `options` parameter is an optional object that
+     * allows you to customize the printing behavior. It has the following properties:
+     * @returns Nothing is being returned. The function has a return type of `void`, which means it does
+     * not return any value.
      */
     print(beginRoot = this.root, options) {
       const opts = __spreadValues({ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false }, options);
@@ -9158,10 +9214,10 @@ var dataStructureTyped = (() => {
         console.log(`U for undefined
       `);
       if (opts.isShowNull)
-        console.log(`NODE for null
+        console.log(`N for null
       `);
       if (opts.isShowRedBlackNIL)
-        console.log(`S for Sentinel Node
+        console.log(`S for Sentinel Node(NIL)
       `);
       const display = (root) => {
         const [lines, , ,] = this._displayAux(root, opts);
@@ -9172,13 +9228,18 @@ var dataStructureTyped = (() => {
       display(beginRoot);
     }
     /**
-     * The function `_getIterator` is a protected generator function that returns an iterator for the
-     * key-value pairs in a binary search tree.
-     * @param node - The `node` parameter represents the current node in the binary search tree. It is an
-     * optional parameter with a default value of `this.root`, which means if no node is provided, the
-     * root node of the tree will be used as the starting point for iteration.
-     * @returns The function `_getIterator` returns an `IterableIterator` of key-value pairs `[K, V |
-     * undefined]`.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `_getIterator` is a generator function that returns an iterator for the key-value
+     * pairs in a binary search tree.
+     * @param node - The `node` parameter represents the current node in the binary search tree. It is
+     * initially set to the root node of the tree.
+     * @returns an IterableIterator<[K, V | undefined]>.
      */
     *_getIterator(node = this.root) {
       if (!node)
@@ -9187,27 +9248,34 @@ var dataStructureTyped = (() => {
         const stack = [];
         let current = node;
         while (current || stack.length > 0) {
-          while (current && !isNaN(this.extractor(current.key))) {
+          while (this.isRealNode(current)) {
             stack.push(current);
             current = current.left;
           }
           current = stack.pop();
-          if (current && !isNaN(this.extractor(current.key))) {
+          if (this.isRealNode(current)) {
             yield [current.key, current.value];
             current = current.right;
           }
         }
       } else {
-        if (node.left && !isNaN(this.extractor(node.key))) {
+        if (node.left && this.isRealNode(node)) {
           yield* __yieldStar(this[Symbol.iterator](node.left));
         }
         yield [node.key, node.value];
-        if (node.right && !isNaN(this.extractor(node.key))) {
+        if (node.right && this.isRealNode(node)) {
           yield* __yieldStar(this[Symbol.iterator](node.right));
         }
       }
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The `_displayAux` function is responsible for generating the display layout of a binary tree node,
      * taking into account various options such as whether to show null, undefined, or NaN nodes.
      * @param {NODE | null | undefined} node - The `node` parameter represents a node in a binary tree.
@@ -9228,10 +9296,10 @@ var dataStructureTyped = (() => {
         return emptyDisplayLayout;
       } else if (node === void 0 && !isShowUndefined) {
         return emptyDisplayLayout;
-      } else if (node !== null && node !== void 0 && isNaN(this.extractor(node.key)) && !isShowRedBlackNIL) {
+      } else if (this.isNIL(node) && !isShowRedBlackNIL) {
         return emptyDisplayLayout;
       } else if (node !== null && node !== void 0) {
-        const key = node.key, line = isNaN(this.extractor(key)) ? "S" : this.extractor(key).toString(), width = line.length;
+        const key = node.key, line = this.isNIL(node) ? "S" : key.toString(), width = line.length;
         return _buildNodeDisplay(
           line,
           width,
@@ -9262,10 +9330,21 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Swap the data of two nodes in the binary tree.
-     * @param {NODE} srcNode - The source node to swap.
-     * @param {NODE} destNode - The destination node to swap.
-     * @returns {NODE} - The destination node after the swap.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `_swapProperties` swaps the key-value properties between two nodes.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} srcNode - The source node that will be swapped with the
+     * destination node. It can be either an instance of the class `R`, or an object of type
+     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} destNode - The `destNode` parameter is the node where
+     * the properties will be swapped with the `srcNode`.
+     * @returns either the `destNode` object with its properties swapped with the `srcNode` object's
+     * properties, or `undefined` if either `srcNode` or `destNode` is falsy.
      */
     _swapProperties(srcNode, destNode) {
       srcNode = this.ensureNode(srcNode);
@@ -9284,12 +9363,20 @@ var dataStructureTyped = (() => {
       return void 0;
     }
     /**
-     * The function replaces an old node with a new node in a binary tree.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function replaces a node in a binary tree with a new node, updating the parent, left child,
+     * right child, and root if necessary.
      * @param {NODE} oldNode - The oldNode parameter represents the node that needs to be replaced in the
      * tree.
      * @param {NODE} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
      * tree.
-     * @returns The method is returning the newNode.
+     * @returns the newNode.
      */
     _replaceNode(oldNode, newNode) {
       if (oldNode.parent) {
@@ -9308,10 +9395,17 @@ var dataStructureTyped = (() => {
       return newNode;
     }
     /**
-     * The function sets the root property of an object to a given value, and if the value is not null,
-     * it also sets the parent property of the value to undefined.
-     * @param {NODE | null | undefined} v - The parameter `v` is of type `NODE | null | undefined`, which means it can either be of
-     * type `NODE` or `null`.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function sets the root property of an object to the provided value, and also updates the
+     * parent property of the new root.
+     * @param {NODE | null | undefined} v - The parameter `v` is of type `NODE | null | undefined`. This
+     * means that it can accept a value of type `NODE`, `null`, or `undefined`.
      */
     _setRoot(v) {
       if (v) {
@@ -9319,6 +9413,23 @@ var dataStructureTyped = (() => {
       }
       this._root = v;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `_ensureCallback` ensures that a callback function is provided and returns it.
+     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is of type
+     * `ReturnType<C> | null | undefined`. This means it can accept a value that is the return type of
+     * the generic type `C`, or it can be `null` or `undefined`.
+     * @param {C} callback - The `callback` parameter is a function that takes a `node` as an argument
+     * and returns a value. It is of type `C`, which is a generic type that extends the
+     * `BTNCallback<NODE>` type.
+     * @returns the callback parameter.
+     */
     _ensureCallback(identifier, callback = this._DEFAULT_CALLBACK) {
       if ((!callback || callback === this._DEFAULT_CALLBACK) && this.isNode(identifier)) {
         callback = (node) => node;
@@ -9378,25 +9489,44 @@ var dataStructureTyped = (() => {
   };
   var BST = class _BST extends BinaryTree {
     /**
-     * This is the constructor function for a TypeScript class that initializes a binary search tree with
-     * optional keys or nodes or entries and options.
-     * @param keysOrNodesOrEntries - An iterable object that contains keys, nodes, or entries. It is used
-     * to initialize the binary search tree with the provided keys, nodes, or entries.
-     * @param [options] - The `options` parameter is an optional object that can contain additional
-     * configuration options for the binary search tree. It can have the following properties:
+     * This is the constructor function for a Binary Search Tree class in TypeScript.
+     * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+     * iterable that can contain either keys, nodes, entries, or raw elements. These elements will be
+     * added to the binary search tree during the construction of the object.
+     * @param [options] - An optional object that contains additional options for the Binary Search Tree.
+     * It can include a comparator function that defines the order of the elements in the tree.
      */
-    constructor(keysOrNodesOrEntries = [], options) {
+    constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
       super([], options);
       __publicField(this, "_root");
-      __publicField(this, "_variant", "STANDARD");
+      /**
+       * Time complexity: O(n)
+       * Space complexity: O(n)
+       */
+      __publicField(this, "_DEFAULT_COMPARATOR", (a, b) => {
+        if (typeof a === "object" && typeof b === "object" && this.comparator === this._DEFAULT_COMPARATOR) {
+          throw TypeError(
+            "When comparing two object types, it is necessary to customize a [comparator] function of options parameter during the instantiation of the data structure."
+          );
+        }
+        if (a > b)
+          return 1;
+        if (a < b)
+          return -1;
+        return 0;
+      });
+      /**
+       * Time complexity: O(n)
+       * Space complexity: O(n)
+       */
+      __publicField(this, "_comparator", this._DEFAULT_COMPARATOR);
       if (options) {
-        const { variant } = options;
-        if (variant)
-          this._variant = variant;
+        const { comparator } = options;
+        if (comparator)
+          this._comparator = comparator;
       }
-      this._root = void 0;
-      if (keysOrNodesOrEntries)
-        this.addMany(keysOrNodesOrEntries);
+      if (keysOrNodesOrEntriesOrRawElements)
+        this.addMany(keysOrNodesOrEntriesOrRawElements);
     }
     /**
      * The function returns the root node of a tree structure.
@@ -9405,13 +9535,6 @@ var dataStructureTyped = (() => {
     get root() {
       return this._root;
     }
-    /**
-     * The function returns the value of the _variant property.
-     * @returns The value of the `_variant` property.
-     */
-    get variant() {
-      return this._variant;
-    }
     /**
      * 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
@@ -9426,104 +9549,71 @@ var dataStructureTyped = (() => {
     /**
      * 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 is of type `Partial<BSTOptions<K>>`, which means it is a
-     * partial object of type `BSTOptions<K>`.
-     * @returns a new instance of the BST class, with the provided options merged with the default
-     * options. The returned value is casted as TREE.
+     * 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.
      */
     createTree(options) {
       return new _BST([], __spreadValues({
         iterationType: this.iterationType,
-        variant: this.variant
+        comparator: this.comparator
       }, options));
     }
     /**
-     * The function `keyValueOrEntryToNode` takes an keyOrNodeOrEntry and returns a node if the keyOrNodeOrEntry is valid,
-     * otherwise it returns undefined.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, where:
-     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node.
-     * @returns a node of type NODE or undefined.
+     * The function overrides a method and converts a key, value pair or entry or raw element to a node.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
+     * type R or KeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+     * 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.
      */
-    keyValueOrEntryToNode(keyOrNodeOrEntry, value) {
-      let node;
-      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
-        return;
-      } else if (this.isNode(keyOrNodeOrEntry)) {
-        node = keyOrNodeOrEntry;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value2] = keyOrNodeOrEntry;
-        if (key === void 0 || key === null) {
-          return;
-        } else {
-          node = this.createNode(key, value2);
-        }
-      } else if (!this.isNode(keyOrNodeOrEntry)) {
-        node = this.createNode(keyOrNodeOrEntry, value);
-      } else {
-        return;
-      }
-      return node;
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value) {
+      var _a;
+      return (_a = super.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value)) != null ? _a : void 0;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
-     * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
-     * otherwise it returns the key itself.
-     * @param {K | NODE | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `NODE`, or
-     * `undefined`.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be performed. It has a default value of `'ITERATIVE'`.
-     * @returns either a node object (NODE) or undefined.
-     */
-    ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE") {
-      if (keyOrNodeOrEntry === this.NIL)
-        return;
-      if (this.isRealNode(keyOrNodeOrEntry)) {
-        return keyOrNodeOrEntry;
-      }
-      if (this.isEntry(keyOrNodeOrEntry)) {
-        const key2 = keyOrNodeOrEntry[0];
-        if (key2 === null || key2 === void 0)
-          return;
-        return this.getNodeByKey(key2, iterationType);
-      }
-      const key = keyOrNodeOrEntry;
-      if (key === null || key === void 0)
-        return;
-      return this.getNodeByKey(key, iterationType);
+     * The function ensures the existence of a node in a data structure and returns it, or undefined if
+     * it doesn't exist.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, which represents the key, node,
+     * entry, or raw element that needs to be ensured in the tree.
+     * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
+     * parameter that specifies the type of iteration to be used when ensuring a node. It has a default
+     * value of `'ITERATIVE'`.
+     * @returns The method is returning either the node that was ensured or `undefined` if the node could
+     * not be ensured.
+     */
+    ensureNode(keyOrNodeOrEntryOrRawElement, iterationType = "ITERATIVE") {
+      var _a;
+      return (_a = super.ensureNode(keyOrNodeOrEntryOrRawElement, iterationType)) != null ? _a : void 0;
     }
     /**
-     * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the BSTNode class.
+     * The function checks if the input is an instance of the BSTNode class.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * an instance of the `BSTNode` class.
      */
-    isNode(keyOrNodeOrEntry) {
-      return keyOrNodeOrEntry instanceof BSTNode;
+    isNode(keyOrNodeOrEntryOrRawElement) {
+      return keyOrNodeOrEntryOrRawElement instanceof BSTNode;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `add` function adds a new node to a binary tree, updating the value if the key already exists
-     * or inserting a new node if the key is unique.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
-     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-     * being added to the binary tree.
-     * @returns The method `add` returns either the newly added node (`newNode`) or `undefined` if the
-     * node was not added.
+     * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
+     * key in the binary search tree. If provided, it will be stored in the node along with the key.
+     * @returns a boolean value.
      */
-    add(keyOrNodeOrEntry, value) {
-      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
+    add(keyOrNodeOrEntryOrRawElement, value) {
+      const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value);
       if (newNode === void 0)
         return false;
       if (this.root === void 0) {
@@ -9533,10 +9623,10 @@ var dataStructureTyped = (() => {
       }
       let current = this.root;
       while (current !== void 0) {
-        if (this._compare(current.key, newNode.key) === "EQ") {
+        if (this.comparator(current.key, newNode.key) === 0) {
           this._replaceNode(current, newNode);
           return true;
-        } else if (this._compare(current.key, newNode.key) === "GT") {
+        } else if (this.comparator(current.key, newNode.key) > 0) {
           if (current.left === void 0) {
             current.left = newNode;
             this._size++;
@@ -9555,37 +9645,38 @@ var dataStructureTyped = (() => {
       return false;
     }
     /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(k + log n)
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(k log n)
      * Space Complexity: O(k + log n)
      *
-     * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
-     * balancing the tree after each addition.
-     * @param keysOrNodesOrEntries - An iterable containing the keys, nodes, or entries to be added to
-     * the binary tree.
+     * The `addMany` function in TypeScript adds multiple keys or nodes to a data structure and returns
+     * an array indicating whether each key or node was successfully inserted.
+     * @param keysOrNodesOrEntriesOrRawElements - An iterable containing keys, nodes, entries, or raw
+     * elements to be added to the data structure.
      * @param [values] - An optional iterable of values to be associated with the keys or nodes being
      * added. If provided, the values will be assigned to the corresponding keys or nodes in the same
      * order. If not provided, undefined will be assigned as the value for each key or node.
-     * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
-     * balanced or not. If set to true, the add operation will be balanced using a binary search tree
-     * algorithm. If set to false, the add operation will not be balanced and the nodes will be added
-     * in the order they appear in the input.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when adding multiple keys or nodes. It has a default value of
-     * `this.iterationType`, which suggests that it is a property of the current object.
-     * @returns The function `addMany` returns an array of nodes (`NODE`) or `undefined` values.
-     */
-    addMany(keysOrNodesOrEntries, values, isBalanceAdd = true, iterationType = this.iterationType) {
+     * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
+     * adding the elements. If set to true, the tree will be balanced using a binary search tree
+     * algorithm. If set to false, the elements will be added without balancing the tree. The default
+     * value is true.
+     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
+     * specifies the type of iteration to use when adding multiple keys or nodes to the binary search
+     * tree. It can have two possible values:
+     * @returns The function `addMany` returns an array of booleans indicating whether each element was
+     * successfully inserted into the data structure.
+     */
+    addMany(keysOrNodesOrEntriesOrRawElements, values, isBalanceAdd = true, iterationType = this.iterationType) {
       const inserted = [];
       let valuesIterator;
       if (values) {
         valuesIterator = values[Symbol.iterator]();
       }
       if (!isBalanceAdd) {
-        for (const kve of keysOrNodesOrEntries) {
+        for (const kve of keysOrNodesOrEntriesOrRawElements) {
           const value = valuesIterator == null ? void 0 : valuesIterator.next().value;
           const nn = this.add(kve, value);
           inserted.push(nn);
@@ -9598,25 +9689,34 @@ var dataStructureTyped = (() => {
           return false;
         return !(this.isEntry(kve) && (kve[0] === void 0 || kve[0] === null));
       };
-      for (const kve of keysOrNodesOrEntries) {
+      for (const kve of keysOrNodesOrEntriesOrRawElements) {
         isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
       }
       let sorted = [];
       sorted = realBTNExemplars.sort((a, b) => {
-        let aR, bR;
+        let keyA, keyB;
         if (this.isEntry(a))
-          aR = this.extractor(a[0]);
+          keyA = a[0];
         else if (this.isRealNode(a))
-          aR = this.extractor(a.key);
-        else
-          aR = this.extractor(a);
+          keyA = a.key;
+        else if (this.toEntryFn) {
+          keyA = this.toEntryFn(a)[0];
+        } else {
+          keyA = a;
+        }
         if (this.isEntry(b))
-          bR = this.extractor(b[0]);
+          keyB = b[0];
         else if (this.isRealNode(b))
-          bR = this.extractor(b.key);
-        else
-          bR = this.extractor(b);
-        return aR - bR;
+          keyB = b.key;
+        else if (this.toEntryFn) {
+          keyB = this.toEntryFn(b)[0];
+        } else {
+          keyB = b;
+        }
+        if (keyA !== void 0 && keyA !== null && keyB !== void 0 && keyB !== null) {
+          return this.comparator(keyA, keyB);
+        }
+        return 0;
       });
       const _dfs = (arr) => {
         if (arr.length === 0)
@@ -9652,33 +9752,27 @@ var dataStructureTyped = (() => {
       return inserted;
     }
     /**
-       * Time Complexity: O(log n)
-       * Space Complexity: O(k + log n)
-       * /
-    
-       /**
-       * Time Complexity: O(log n)
-       * Space Complexity: O(k + log n)
-       *
-       * The function `getNodes` returns an array of nodes that match a given identifier, using either a
-       * recursive or iterative approach.
-       * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
-       * want to search for in the nodes of the binary tree. It can be of any type that is returned by the
-       * callback function `C`.
-       * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as its
-       * argument and returns a value of type `ReturnType<C>`. The `C` type parameter represents a callback
-       * function type that extends the `BTNCallback<NODE>` type. The `BTNCallback<NODE>` type is
-       * @param [onlyOne=false] - A boolean flag indicating whether to stop searching after finding the
-       * first node that matches the identifier. If set to true, the function will return an array
-       * containing only the first matching node. If set to false (default), the function will continue
-       * searching for all nodes that match the identifier and return an array containing
-       * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter represents the starting node
-       * for the traversal. It can be either a key value or a node object. If it is undefined, the
-       * traversal will start from the root of the tree.
-       * @param iterationType - The `iterationType` parameter determines the type of iteration to be
-       * performed on the binary tree. It can have two possible values:
-       * @returns The method returns an array of nodes (`NODE[]`).
-       */
+     * Time Complexity: O(log n)
+     * Space Complexity: O(k + log n)
+     *
+     * The `getNodes` function in TypeScript retrieves nodes from a binary tree based on a given
+     * identifier and callback function.
+     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
+     * want to search for in the binary tree. It can be of any type that is returned by the callback
+     * function.
+     * @param {C} callback - The `callback` parameter is a function that takes a node as input and
+     * returns a value. This value is used to identify the nodes that match the given identifier. The
+     * `callback` function is optional and defaults to `this._DEFAULT_CALLBACK`.
+     * @param [onlyOne=false] - A boolean value indicating whether to return only the first matching node
+     * or all matching nodes. If set to true, only the first matching node will be returned. If set to
+     * false, all matching nodes will be returned. The default value is false.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for the search in the binary tree. It can be either a node object, a key-value pair, or an
+     * entry object. If it is not provided, the `root` of the binary tree is used as the starting point.
+     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
+     * iteration to be performed. It can have two possible values:
+     * @returns The method `getNodes` returns an array of `NODE` objects.
+     */
     getNodes(identifier, callback = this._DEFAULT_CALLBACK, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
@@ -9696,9 +9790,9 @@ var dataStructureTyped = (() => {
           if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return;
           if (callback === this._DEFAULT_CALLBACK) {
-            if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === "GT")
+            if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier) > 0)
               dfs(cur.left);
-            if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === "LT")
+            if (this.isRealNode(cur.right) && this.comparator(cur.key, identifier) < 0)
               dfs(cur.right);
           } else {
             this.isRealNode(cur.left) && dfs(cur.left);
@@ -9717,9 +9811,9 @@ var dataStructureTyped = (() => {
               return ans;
           }
           if (callback === this._DEFAULT_CALLBACK) {
-            if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === "LT")
+            if (this.isRealNode(cur.right) && this.comparator(cur.key, identifier) < 0)
               stack.push(cur.right);
-            if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === "GT")
+            if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier) > 0)
               stack.push(cur.left);
           } else {
             this.isRealNode(cur.right) && stack.push(cur.right);
@@ -9737,51 +9831,50 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
-     * callback function.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
-     * that you want to search for in the binary search tree. It can be of any type that is compatible
-     * with the type of nodes in the tree.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It is used to determine whether a node matches the given identifier. The `callback`
-     * function should take a node as its parameter and return a value that can be compared to the
-     * `identifier` parameter.
+     * The function `getNode` returns the first node that matches the given identifier and callback
+     * function in a binary search tree.
+     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
+     * want to search for in the binary search tree. It can be of any type that is compatible with the
+     * type returned by the callback function.
+     * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
+     * node matches the desired criteria. It should be a function that takes a node as an argument and
+     * returns a boolean value indicating whether the node matches the criteria or not. If no callback is
+     * provided, the default callback will be
      * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
-     * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
-     * using the `ensureNode` method. If it is not provided, the `root`
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed when searching for nodes in the binary search tree. It is an optional parameter and
-     * its default value is taken from the `iterationType` property of the class.
-     * @returns The method is returning a value of type `NODE | null | undefined`.
+     * search tree. It can be either a key or a node. If it is a key, the search will start from the node
+     * with that key. If it is a node, the search will start from that node.
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
+     * of iteration to be performed when searching for nodes in the binary search tree. It can have one
+     * of the following values:
+     * @returns The method is returning a NODE object or undefined.
      */
     getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
       var _a;
       return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
     }
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(k + log n)
      */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
-     * either recursive or iterative methods.
-     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
-     * It is used to identify the node that we want to retrieve.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when searching for a node in the binary tree. It can have two possible
-     * values:
-     * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
-     * found in the binary tree. If no node is found, it returns `undefined`.
+     * 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 = "ITERATIVE") {
       return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
     }
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
+     * Time Complexity: O(log n)
+     * Space Complexity: O(k + log n)
      */
     /**
      * Time complexity: O(n)
@@ -9790,15 +9883,16 @@ var dataStructureTyped = (() => {
      * The function overrides the depth-first search method and returns an array of the return types of
      * the callback function.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
-     * during the depth-first search traversal. It is an optional parameter and if not provided, a
-     * default callback function will be used.
-     * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter specifies the order in which the
-     * nodes are visited during the depth-first search. It can have one of the following values:
-     * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for the
-     * Depth-First Search (DFS) traversal. It can be either a key, a node, or an entry in the tree. If no
-     * value is provided, the DFS traversal will start from the root of the tree.
-     * @param {IterationType} iterationType - The `iterationType` parameter specifies the type of
-     * iteration to be used during the Depth-First Search (DFS) traversal. It can have one of the
+     * during the depth-first search traversal. It is an optional parameter and defaults to
+     * `this._DEFAULT_CALLBACK`. The type `C` represents the type of the callback function.
+     * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
+     * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
+     * take one of the following values:
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
+     * node entry. If not specified, the default value is the root of the tree.
+     * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
+     * type of iteration to be used during the Depth-First Search (DFS) traversal. It can have one of the
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
@@ -9806,8 +9900,8 @@ var dataStructureTyped = (() => {
       return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
      * Time complexity: O(n)
@@ -9816,38 +9910,38 @@ var dataStructureTyped = (() => {
      * The function overrides the breadth-first search method and returns an array of the return types of
      * the callback function.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
-     * visited during the breadth-first search traversal. It is an optional parameter and if not
-     * provided, a default callback function will be used.
-     * @param beginRoot - The `beginRoot` parameter is the starting point for the breadth-first search
-     * traversal. It can be either a key, a node, or an entry in the tree. If not specified, the root of
-     * the tree is used as the starting point.
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed during the breadth-first search (BFS) traversal. It determines the order in which the
-     * nodes are visited.
-     * @returns The method is returning an array of the return type of the callback function.
+     * visited during the breadth-first search. It should take a single argument, which is the current
+     * node being visited, and it can return a value of any type.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
+     * object. If no value is provided, the default value is the root of the tree.
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
+     * of iteration to be performed during the breadth-first search (BFS) traversal. It can have one of
+     * the following values:
+     * @returns an array of the return type of the callback function.
      */
     bfs(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
       return super.bfs(callback, beginRoot, iterationType, false);
     }
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
-     * The function overrides the listLevels method and returns an array of arrays containing the return
-     * type of the callback function for each level of the tree.
+     * The function overrides the listLevels method from the superclass and returns an array of arrays
+     * containing the results of the callback function applied to each level of the tree.
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
-     * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the tree
-     * during the level listing process.
-     * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for listing the
-     * levels of a binary tree. It can be either a key, a node, or an entry in the binary tree. If not
-     * provided, the root of the binary tree is used as the starting point.
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed on the tree. It determines the order in which the nodes are visited during the
-     * iteration.
+     * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the
+     * tree during the iteration process.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for listing the levels of the binary tree. It can be either a root node of the tree, a
+     * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
+     * value is provided, the root of
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
+     * of iteration to be performed on the tree. It can have one of the following values:
      * @returns The method is returning a two-dimensional array of the return type of the callback
      * function.
      */
@@ -9855,74 +9949,42 @@ var dataStructureTyped = (() => {
       return super.listLevels(callback, beginRoot, iterationType, false);
     }
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
-     * leftmost node if the comparison result is greater than.
-     * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `K`, `NODE`, or `undefined`. It represents the starting point for finding the last key in
-     * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
-     * the key of the leftmost node if the comparison result is greater than, and the key of the
-     * rightmost node otherwise. If no node is found, it returns 0.
-     */
-    lastKey(beginRoot = this.root) {
-      let current = this.ensureNode(beginRoot);
-      if (!current)
-        return void 0;
-      if (this._variant === "STANDARD") {
-        while (current.right !== void 0) {
-          current = current.right;
-        }
-      } else {
-        while (current.left !== void 0) {
-          current = current.left;
-        }
-      }
-      return current.key;
-    }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * Time complexity: O(n)
+     * Space complexity: O(n)
      */
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * Time complexity: O(n)
+     * Space complexity: O(n)
      *
-     * The `lesserOrGreaterTraverse` function traverses a binary tree and returns an array of nodes that
-     * are either lesser or greater than a target node, depending on the specified comparison type.
+     * The `lesserOrGreaterTraverse` function traverses a binary tree and applies a callback function to
+     * each node that meets a certain condition based on a target node and a comparison value.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
-     * that satisfies the condition specified by the `lesserOrGreater` parameter. It takes a single
-     * parameter of type `NODE` (the node type) and returns a value of any type.
+     * that meets the condition specified by the `lesserOrGreater` parameter. It takes a single argument,
+     * which is the current node being traversed, and returns a value of any type.
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
-     * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It is of type
-     * `CP`, which is a custom type representing the comparison operator. The possible values for
-     * `lesserOrGreater` are
-     * @param {K | NODE | undefined} targetNode - The `targetNode` parameter represents the node in the
-     * binary tree that you want to traverse from. It can be specified either by its key, by the node
-     * object itself, or it can be left undefined to start the traversal from the root of the tree.
-     * @param iterationType - The `iterationType` parameter determines the type of traversal to be
-     * performed on the binary tree. It can have two possible values:
+     * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
+     * 0, or 1, where:
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} targetNode - The `targetNode` parameter is the node in
+     * the binary tree that you want to start traversing from. It can be specified either by providing
+     * the key of the node, the node itself, or an entry containing the key and value of the node. If no
+     * `targetNode` is provided,
+     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
+     * traversal to be performed on the binary tree. It can have two possible values:
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._DEFAULT_CALLBACK, lesserOrGreater = "LT", targetNode = this.root, iterationType = this.iterationType) {
-      targetNode = this.ensureNode(targetNode);
+    lesserOrGreaterTraverse(callback = this._DEFAULT_CALLBACK, lesserOrGreater = -1, targetNode = this.root, iterationType = this.iterationType) {
+      const targetNodeEnsured = this.ensureNode(targetNode);
       const ans = [];
-      if (!targetNode)
+      if (!targetNodeEnsured)
         return ans;
       if (!this.root)
         return ans;
-      const targetKey = targetNode.key;
+      const targetKey = targetNodeEnsured.key;
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
-          const compared = this._compare(cur.key, targetKey);
-          if (compared === lesserOrGreater)
+          const compared = this.comparator(cur.key, targetKey);
+          if (Math.sign(compared) === lesserOrGreater)
             ans.push(callback(cur));
           if (this.isRealNode(cur.left))
             dfs(cur.left);
@@ -9936,8 +9998,8 @@ var dataStructureTyped = (() => {
         while (queue.size > 0) {
           const cur = queue.shift();
           if (this.isRealNode(cur)) {
-            const compared = this._compare(cur.key, targetKey);
-            if (compared === lesserOrGreater)
+            const compared = this.comparator(cur.key, targetKey);
+            if (Math.sign(compared) === lesserOrGreater)
               ans.push(callback(cur));
             if (this.isRealNode(cur.left))
               queue.push(cur.left);
@@ -9949,18 +10011,19 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * Time complexity: O(n)
+     * Space complexity: O(n)
      */
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * Time complexity: O(n)
+     * Space complexity: O(n)
      *
-     * The `perfectlyBalance` function balances a binary search tree by adding nodes in a way that
-     * ensures the tree is perfectly balanced.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when building a balanced binary search tree. It can have two possible
-     * values:
+     * The `perfectlyBalance` function takes an optional `iterationType` parameter and returns `true` if
+     * the binary search tree is perfectly balanced, otherwise it returns `false`.
+     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
+     * specifies the type of iteration to use when building a balanced binary search tree. It has a
+     * default value of `this.iterationType`, which means it will use the iteration type specified in the
+     * current instance of the class.
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
     perfectlyBalance(iterationType = this.iterationType) {
@@ -9999,25 +10062,19 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Balancing Adjustment:
-     * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
-     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
-     *
-     * Use Cases and Efficiency:
-     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
-     * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Time complexity: O(n)
+     * Space complexity: O(n)
      */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
      *
-     * The function checks if a binary tree is AVL balanced using either recursive or iterative approach.
-     * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
-     * to check if the AVL tree is balanced. It can have two possible values:
+     * The function `isAVLBalanced` checks if a binary tree is AVL balanced using either a recursive or
+     * iterative approach.
+     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
+     * specifies the type of iteration to use when checking if the AVL tree is balanced. It has a default
+     * value of `this.iterationType`, which means it will use the iteration type specified in the current
+     * instance of the AVL tree.
      * @returns a boolean value.
      */
     isAVLBalanced(iterationType = this.iterationType) {
@@ -10064,60 +10121,26 @@ var dataStructureTyped = (() => {
       return balanced;
     }
     /**
-     * The function sets the root property of an object and updates the parent property of the new root.
-     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. This means that it
-     * can either be an object of type `NODE` or it can be `undefined`.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      */
-    _setRoot(v) {
-      if (v) {
-        v.parent = void 0;
-      }
-      this._root = v;
-    }
     /**
-     * The function compares two values using a comparator function and returns whether the first value
-     * is greater than, less than, or equal to the second value.
-     * @param {K} a - The parameter "a" is of type K.
-     * @param {K} b - The parameter "b" in the above code represents a K.
-     * @returns a value of type CP (ComparisonResult). The possible return values are 'GT' (greater
-     * than), 'LT' (less than), or 'EQ' (equal).
-     */
-    _compare(a, b) {
-      const extractedA = this.extractor(a);
-      const extractedB = this.extractor(b);
-      const compared = this.variant === "STANDARD" ? extractedA - extractedB : extractedB - extractedA;
-      if (compared > 0)
-        return "GT";
-      if (compared < 0)
-        return "LT";
-      return "EQ";
-    }
-    /**
-     * The function `_lt` compares two values `a` and `b` using an extractor function and returns true if
-     * `a` is less than `b` based on the specified variant.
-     * @param {K} a - The parameter "a" is of type "K", which means it can be any type. It represents the
-     * first value to be compared in the function.
-     * @param {K} b - The parameter `b` is of type `K`, which means it can be any type. It is used as one
-     * of the arguments for the comparison in the `_lt` function.
-     * @returns a boolean value.
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
      */
-    _lt(a, b) {
-      const extractedA = this.extractor(a);
-      const extractedB = this.extractor(b);
-      return this.variant === "STANDARD" ? extractedA < extractedB : extractedA > extractedB;
+    get comparator() {
+      return this._comparator;
     }
     /**
-     * The function compares two values using a custom extractor function and returns true if the first
-     * value is greater than the second value.
-     * @param {K} a - The parameter "a" is of type K, which means it can be any type.
-     * @param {K} b - The parameter "b" is of type K, which means it can be any type. It is used as one
-     * of the arguments for the comparison in the function.
-     * @returns a boolean value.
+     * The function sets the root of a tree-like structure and updates the parent property of the new
+     * root.
+     * @param {NODE | undefined} v - v is a parameter of type NODE or undefined.
      */
-    _gt(a, b) {
-      const extractedA = this.extractor(a);
-      const extractedB = this.extractor(b);
-      return this.variant === "STANDARD" ? extractedA > extractedB : extractedA < extractedB;
+    _setRoot(v) {
+      if (v) {
+        v.parent = void 0;
+      }
+      this._root = v;
     }
   };
 
@@ -10719,27 +10742,29 @@ var dataStructureTyped = (() => {
   };
   var AVLTree = class _AVLTree extends BST {
     /**
-     * The constructor function initializes an AVLTree object with optional keysOrNodesOrEntries and options.
-     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, NODE>`
-     * objects. It represents a collection of nodes that will be added to the AVL tree during
-     * initialization.
-     * @param [options] - The `options` parameter is an optional object that allows you to customize the
-     * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
-     * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
+     * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
+     * entries, or raw elements.
+     * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+     * iterable object that can contain either keys, nodes, entries, or raw elements. These elements will
+     * be used to initialize the AVLTree.
+     * @param [options] - The `options` parameter is an optional object that can be used to customize the
+     * behavior of the AVLTree. It can include properties such as `compareFn` (a function used to compare
+     * keys), `allowDuplicates` (a boolean indicating whether duplicate keys are allowed), and
+     * `nodeBuilder` (
      */
-    constructor(keysOrNodesOrEntries = [], options) {
+    constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
       super([], options);
-      if (keysOrNodesOrEntries)
-        super.addMany(keysOrNodesOrEntries);
+      if (keysOrNodesOrEntriesOrRawElements)
+        super.addMany(keysOrNodesOrEntriesOrRawElements);
     }
     /**
-     * The function creates a new AVL tree node with the specified key and value.
-     * @param {K} key - The key parameter is the key value that will be associated with
-     * the new node. It is used to determine the position of the node in the binary search tree.
-     * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It is of
-     * type `V`, which means it can be any value that is assignable to the `value` property of the
-     * node type `NODE`.
-     * @returns a new AVLTreeNode object with the specified key and value.
+     * The function creates a new AVL tree node with the given key and value.
+     * @param {K} key - The key parameter is of type K, which represents the key of the node being
+     * created.
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
+     * value associated with the key in the node being created.
+     * @returns The method is returning a new instance of the AVLTreeNode class, casted as the generic
+     * type NODE.
      */
     createNode(key, value) {
       return new AVLTreeNode(key, value);
@@ -10754,16 +10779,18 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _AVLTree([], __spreadValues({
         iterationType: this.iterationType,
-        variant: this.variant
+        comparator: this.comparator
       }, options));
     }
     /**
-     * The function checks if an keyOrNodeOrEntry is an instance of AVLTreeNode.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeNode class.
+     * The function checks if the input is an instance of AVLTreeNode.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * an instance of the `AVLTreeNode` class.
      */
-    isNode(keyOrNodeOrEntry) {
-      return keyOrNodeOrEntry instanceof AVLTreeNode;
+    isNode(keyOrNodeOrEntryOrRawElement) {
+      return keyOrNodeOrEntryOrRawElement instanceof AVLTreeNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -10774,20 +10801,21 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function overrides the add method of a binary tree node and balances the tree after inserting
-     * a new node.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
-     * entry.
-     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-     * being added to the binary tree.
-     * @returns The method is returning either the inserted node or undefined.
+     * The function overrides the add method of a class and inserts a key-value pair into a data
+     * structure, then balances the path.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept values of type `R`, `KeyOrNodeOrEntry<K, V, NODE>`, or
+     * `RawElement`.
+     * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
+     * the key or node being added to the data structure.
+     * @returns The method is returning a boolean value.
      */
-    add(keyOrNodeOrEntry, value) {
-      if (keyOrNodeOrEntry === null)
+    add(keyOrNodeOrEntryOrRawElement, value) {
+      if (keyOrNodeOrEntryOrRawElement === null)
         return false;
-      const inserted = super.add(keyOrNodeOrEntry, value);
+      const inserted = super.add(keyOrNodeOrEntryOrRawElement, value);
       if (inserted)
-        this._balancePath(keyOrNodeOrEntry);
+        this._balancePath(keyOrNodeOrEntryOrRawElement);
       return inserted;
     }
     /**
@@ -10798,16 +10826,14 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function overrides the delete method of a binary tree, performs the deletion, and then
-     * balances the tree if necessary.
+     * The function overrides the delete method of a binary tree class and performs additional operations
+     * to balance the tree after deletion.
      * @param identifier - The `identifier` parameter is the value or condition used to identify the
-     * node(s) to be deleted from the binary tree. It can be of any type and is the return type of the
-     * `callback` function.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node
-     * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
-     * default to the `_DEFAULT_CALLBACK` function. The `callback` function should have a single
-     * parameter of type `NODE
-     * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
+     * node(s) to be deleted from the binary tree. It can be of any type that is compatible with the
+     * binary tree's node type.
+     * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
+     * node should be deleted or not. It is optional and has a default value of `this._DEFAULT_CALLBACK`.
+     * @returns The method is returning an array of BinaryTreeDeleteResult<NODE> objects.
      */
     delete(identifier, callback = this._DEFAULT_CALLBACK) {
       const deletedResults = super.delete(identifier, callback);
@@ -10819,31 +10845,38 @@ var dataStructureTyped = (() => {
       return deletedResults;
     }
     /**
-     * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
-     * tree.
-     * @param {K | NODE | undefined} srcNode - The `srcNode` parameter represents the source node that
-     * needs to be swapped with the destination node. It can be of type `K`, `NODE`, or `undefined`.
-     * @param {K | NODE  | undefined} destNode - The `destNode` parameter represents the destination
-     * node where the values from the source node will be swapped to.
-     * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
-     * if either `srcNode` or `destNode` is undefined.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a
+     * binary search tree.
+     * @param {R | BSTNKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents either a node
+     * object (`NODE`) or a key-value pair (`R`) that is being swapped with another node.
+     * @param {R | BSTNKeyOrNode<K, NODE>} destNode - The `destNode` parameter is either an instance of
+     * `R` or an instance of `BSTNKeyOrNode<K, NODE>`.
+     * @returns The method is returning the `destNodeEnsured` object if both `srcNodeEnsured` and
+     * `destNodeEnsured` are truthy. Otherwise, it returns `undefined`.
      */
     _swapProperties(srcNode, destNode) {
-      srcNode = this.ensureNode(srcNode);
-      destNode = this.ensureNode(destNode);
-      if (srcNode && destNode) {
-        const { key, value, height } = destNode;
+      const srcNodeEnsured = this.ensureNode(srcNode);
+      const destNodeEnsured = this.ensureNode(destNode);
+      if (srcNodeEnsured && destNodeEnsured) {
+        const { key, value, height } = destNodeEnsured;
         const tempNode = this.createNode(key, value);
         if (tempNode) {
           tempNode.height = height;
-          destNode.key = srcNode.key;
-          destNode.value = srcNode.value;
-          destNode.height = srcNode.height;
-          srcNode.key = tempNode.key;
-          srcNode.value = tempNode.value;
-          srcNode.height = tempNode.height;
+          destNodeEnsured.key = srcNodeEnsured.key;
+          destNodeEnsured.value = srcNodeEnsured.value;
+          destNodeEnsured.height = srcNodeEnsured.height;
+          srcNodeEnsured.key = tempNode.key;
+          srcNodeEnsured.value = tempNode.value;
+          srcNodeEnsured.height = tempNode.height;
         }
-        return destNode;
+        return destNodeEnsured;
       }
       return void 0;
     }
@@ -10856,7 +10889,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function calculates the balance factor of a node in a binary tree.
-     * @param {NODE} node - The parameter "node" represents a node in a binary tree data structure.
+     * @param {NODE} node - The parameter "node" is of type "NODE", which likely represents a node in a
+     * binary tree data structure.
      * @returns the balance factor of a given node. The balance factor is calculated by subtracting the
      * height of the left subtree from the height of the right subtree.
      */
@@ -10899,7 +10933,7 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_balanceLL` performs a left-left rotation to balance a binary tree.
+     * The `_balanceLL` function performs a left-left rotation to balance a binary search tree.
      * @param {NODE} A - A is a node in a binary tree.
      */
     _balanceLL(A) {
@@ -11089,8 +11123,8 @@ var dataStructureTyped = (() => {
      *
      * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
      * to restore balance in an AVL tree after inserting a node.
-     * @param {NODE} node - The `node` parameter in the `_balancePath` function represents the node in the
-     * AVL tree that needs to be balanced.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The `node` parameter can be of type `R` or
+     * `KeyOrNodeOrEntry<K, V, NODE>`.
      */
     _balancePath(node) {
       node = this.ensureNode(node);
@@ -11120,13 +11154,21 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * The function replaces an old node with a new node while preserving the height of the old node.
-     * @param {NODE} oldNode - The `oldNode` parameter is the node that you want to replace with the
-     * `newNode`.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function replaces an old node with a new node and sets the height of the new node to be the
+     * same as the old node.
+     * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
+     * the data structure.
      * @param {NODE} newNode - The `newNode` parameter is the new node that will replace the `oldNode` in
      * the data structure.
-     * @returns the result of calling the `_replaceNode` method on the superclass, passing in the
-     * `oldNode` and `newNode` as arguments.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, with the `oldNode` and `newNode` as arguments.
      */
     _replaceNode(oldNode, newNode) {
       newNode.height = oldNode.height;
@@ -11170,20 +11212,20 @@ var dataStructureTyped = (() => {
   var RedBlackTree = class _RedBlackTree extends BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
-     * @param keysOrNodesOrEntries - The `keysOrNodesOrEntries` parameter is an iterable object that can
-     * contain keys, nodes, or entries. It is used to initialize the RBTree with the provided keys,
-     * nodes, or entries.
+     * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` 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.
      * @param [options] - The `options` parameter is an optional object that can be passed to the
-     * constructor. It allows you to customize the behavior of the RBTree. It can include properties such
-     * as `compareKeys`, `compareValues`, `allowDuplicates`, etc. These properties define how the RBTree
-     * should compare keys and
+     * constructor. It is of type `RBTreeOptions<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
      */
-    constructor(keysOrNodesOrEntries = [], options) {
+    constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
       super([], options);
       __publicField(this, "_root");
       this._root = this.NIL;
-      if (keysOrNodesOrEntries) {
-        this.addMany(keysOrNodesOrEntries);
+      if (keysOrNodesOrEntriesOrRawElements) {
+        this.addMany(keysOrNodesOrEntriesOrRawElements);
       }
     }
     /**
@@ -11195,24 +11237,25 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
-     * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
-     * which is a generic type representing the key's data type.
+     * @param {K} key - The key parameter represents the key value of the node being created. It is of
+     * type K, which is a generic type that can be replaced with any specific type when using the
+     * function.
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the key in the node. It is not required and can be omitted if not needed.
-     * @param {RBTNColor} color - The "color" parameter is used to specify the color of the node in a
-     * Red-Black Tree. It is an optional parameter with a default value of "'BLACK'". The color
-     * can be either "'RED'" or "'BLACK'".
-     * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
-     * value, and color.
+     * associated with the key in the node. It is not required and can be omitted if you only need to
+     * create a node with a key.
+     * @param {RBTNColor} [color=BLACK] - The "color" parameter is used to specify the color of the node
+     * in a Red-Black Tree. It can have two possible values: "RED" or "BLACK". By default, the color is
+     * set to "BLACK" if not specified.
+     * @returns A new instance of a RedBlackTreeNode with the specified key, value, and color is being
+     * returned.
      */
     createNode(key, value, color = "BLACK") {
       return new RedBlackTreeNode(key, value, color);
     }
     /**
-     * The function creates a Red-Black Tree with the given options and returns it.
-     * @param [options] - The `options` parameter is an optional object that contains configuration
-     * options for creating the Red-Black Tree. It is of type `RBTreeOptions<K>`, where `K` represents
-     * the type of keys in the tree.
+     * 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.
      */
     createTree(options) {
@@ -11228,48 +11271,50 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `keyValueOrEntryToNode` takes a key, value, or entry and returns a node if it is
-     * valid, otherwise it returns undefined.
-     * @param {KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntry - The key, value, or entry to convert.
-     * @param {V} [value] - The value associated with the key (if `keyOrNodeOrEntry` is a key).
-     * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
+     * The function checks if the input is an instance of the RedBlackTreeNode class.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * an instance of the `RedBlackTreeNode` class.
      */
-    keyValueOrEntryToNode(keyOrNodeOrEntry, value) {
-      let node;
-      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
-        return;
-      } else if (this.isNode(keyOrNodeOrEntry)) {
-        node = keyOrNodeOrEntry;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value2] = keyOrNodeOrEntry;
-        if (key === void 0 || key === null) {
-          return;
-        } else {
-          node = this.createNode(key, value2, "RED");
-        }
-      } else if (!this.isNode(keyOrNodeOrEntry)) {
-        node = this.createNode(keyOrNodeOrEntry, value, "RED");
-      } else {
-        return;
-      }
-      return node;
-    }
-    /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       * /
-    
-       /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       *
-       * The function checks if the input is an instance of the RedBlackTreeNode class.
-       * @param {KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntry - The object to check.
-       * @returns {boolean} - `true` if the object is a Red-Black Tree node, `false` otherwise.
-       */
-    isNode(keyOrNodeOrEntry) {
-      return keyOrNodeOrEntry instanceof RedBlackTreeNode;
+    isNode(keyOrNodeOrEntryOrRawElement) {
+      return keyOrNodeOrEntryOrRawElement instanceof RedBlackTreeNode;
     }
+    // /**
+    //  * Time Complexity: O(1)
+    //  * Space Complexity: O(1)
+    //  */
+    //
+    // /**
+    //  * Time Complexity: O(1)
+    //  * Space Complexity: O(1)
+    //  *
+    //  * The function `keyValueOrEntryOrRawElementToNode` takes a key, value, or entry and returns a node if it is
+    //  * valid, otherwise it returns undefined.
+    //  * @param {KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The key, value, or entry to convert.
+    //  * @param {V} [value] - The value associated with the key (if `keyOrNodeOrEntryOrRawElement` is a key).
+    //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
+    //  */
+    // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined {
+    //
+    //   if (keyOrNodeOrEntryOrRawElement === null || keyOrNodeOrEntryOrRawElement === undefined) return;
+    //   if (this.isNode(keyOrNodeOrEntryOrRawElement)) return keyOrNodeOrEntryOrRawElement;
+    //
+    //   if (this.toEntryFn) {
+    //     const [key, entryValue] = this.toEntryFn(keyOrNodeOrEntryOrRawElement as R);
+    //     if (key) return this.createNode(key, entryValue ?? value, 'RED');
+    //   }
+    //
+    //   if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
+    //     const [key, value] = keyOrNodeOrEntryOrRawElement;
+    //     if (key === undefined || key === null) return;
+    //     else return  this.createNode(key, value, 'RED');
+    //   }
+    //
+    //   if (this.isKey(keyOrNodeOrEntryOrRawElement)) return this.createNode(keyOrNodeOrEntryOrRawElement, value, 'RED');
+    //
+    //   return ;
+    // }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -11293,17 +11338,19 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function adds a new node to a Red-Black Tree data structure and returns a boolean indicating
-     * whether the operation was successful.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
-     * entry.
-     * @param {V} [value] - The `value` parameter is the value associated with the key that is being
-     * added to the tree.
-     * @returns The method is returning a boolean value. It returns true if the node was successfully
-     * added or updated, and false otherwise.
+     * The function adds a new node to a binary search tree and returns true if the node was successfully
+     * added.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
+     * the key in the data structure. It represents the value that you want to add or update in the data
+     * structure.
+     * @returns The method is returning a boolean value. If a new node is successfully added to the tree,
+     * the method returns true. If the node already exists and its value is updated, the method also
+     * returns true. If the node cannot be added or updated, the method returns false.
      */
-    add(keyOrNodeOrEntry, value) {
-      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
+    add(keyOrNodeOrEntryOrRawElement, value) {
+      const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value);
       if (!this.isRealNode(newNode))
         return false;
       const insertStatus = this._insert(newNode);
@@ -11326,16 +11373,16 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `delete` in a binary tree class deletes a node from the tree and fixes the tree if
-     * necessary.
-     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the
-     * identifier of the node that needs to be deleted from the binary tree. It can be of any type that
-     * is returned by the callback function `C`. It can also be `null` or `undefined` if the node to be
-     * deleted is not found.
-     * @param {C} callback - The `callback` parameter is a function that is used to retrieve a node from
-     * the binary tree based on its identifier. It is an optional parameter and if not provided, the
-     * `_DEFAULT_CALLBACK` function is used as the default callback. The callback function should
-     * return the identifier of the node to
+     * The function overrides the delete method of a binary tree data structure, allowing for the
+     * deletion of a node and maintaining the balance of the tree.
+     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
+     * that identifies the node to be deleted from the binary tree. It can be of any type that is
+     * returned by the callback function `C`. It can also be `null` or `undefined` if there is no node to
+     * delete.
+     * @param {C} callback - The `callback` parameter is a function that is used to determine the
+     * equality of nodes in the binary tree. It is optional and has a default value of
+     * `this._DEFAULT_CALLBACK`. The type of the `callback` parameter is `C`, which is a generic type
+     * that extends the `BTNCallback
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */
     delete(identifier, callback = this._DEFAULT_CALLBACK) {
@@ -11387,6 +11434,13 @@ var dataStructureTyped = (() => {
       return results;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
      * @param {NODE | undefined} v - v is a parameter of type NODE or undefined.
@@ -11408,8 +11462,8 @@ var dataStructureTyped = (() => {
      * The function replaces an old node with a new node while preserving the color of the old node.
      * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
      * the data structure.
-     * @param {NODE} newNode - The `newNode` parameter is the new node that will replace the old node in
-     * the data structure.
+     * @param {NODE} newNode - The `newNode` parameter is of type `NODE`, which represents a node in a
+     * data structure.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
      * superclass, with the `oldNode` and `newNode` parameters.
      */
@@ -11425,12 +11479,13 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `_insert` function inserts or updates a node in a binary search tree and performs necessary
-     * fix-ups to maintain the red-black tree properties.
-     * @param {NODE} node - The `node` parameter represents the node that needs to be inserted into a
-     * binary search tree. It contains a `key` property that is used to determine the position of the
-     * node in the tree.
-     * @returns {'inserted' | 'updated'} - The result of the insertion.
+     * The `_insert` function inserts a node into a binary search tree and performs necessary fix-ups to
+     * maintain the red-black tree properties.
+     * @param {NODE} node - The `node` parameter represents the node that needs to be inserted into the
+     * binary search tree.
+     * @returns a string value indicating the result of the insertion operation. It can return either
+     * 'UPDATED' if the node with the same key already exists and was updated, or 'CREATED' if a new node
+     * was created and inserted into the tree.
      */
     _insert(node) {
       var _a, _b;
@@ -11438,9 +11493,10 @@ var dataStructureTyped = (() => {
       let parent = void 0;
       while (this.isRealNode(current)) {
         parent = current;
-        if (node.key < current.key) {
+        const compared = this.comparator(node.key, current.key);
+        if (compared < 0) {
           current = (_a = current.left) != null ? _a : this.NIL;
-        } else if (node.key > current.key) {
+        } else if (compared > 0) {
           current = (_b = current.right) != null ? _b : this.NIL;
         } else {
           this._replaceNode(current, node);
@@ -11495,8 +11551,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `_insertFixup` function is used to fix the Red-Black Tree after inserting a new node.
-     * @param {NODE | undefined} z - The parameter `z` represents a node in the Red-Black Tree. It can
-     * either be a valid node object or `undefined`.
+     * @param {NODE | undefined} z - The parameter `z` represents a node in the Red-Black Tree data
+     * structure. It can either be a valid node or `undefined`.
      */
     _insertFixup(z) {
       var _a, _b, _c, _d;
@@ -11552,9 +11608,10 @@ var dataStructureTyped = (() => {
      *
      * The `_deleteFixup` function is used to fix the red-black tree after a node deletion by adjusting
      * the colors and performing rotations.
-     * @param {NODE | undefined} node - The `node` parameter represents a node in a Red-Black Tree data
-     * structure. It can be either a valid node object or `undefined`.
-     * @returns The function does not return any value. It has a return type of `void`.
+     * @param {NODE | undefined} node - The `node` parameter represents a node in a binary tree. It can
+     * be either a valid node object or `undefined`.
+     * @returns The function does not return any value. It has a return type of `void`, which means it
+     * does not return anything.
      */
     _deleteFixup(node) {
       var _a, _b, _c, _d;
@@ -11686,24 +11743,6 @@ var dataStructureTyped = (() => {
       x.right = y;
       y.parent = x;
     }
-    /**
-     * The function compares two values using a comparator function and returns whether the first value
-     * is greater than, less than, or equal to the second value.
-     * @param {K} a - The parameter "a" is of type K.
-     * @param {K} b - The parameter "b" in the above code represents a K.
-     * @returns a value of type CP (ComparisonResult). The possible return values are 'GT' (greater
-     * than), 'LT' (less than), or 'EQ' (equal).
-     */
-    _compare(a, b) {
-      const extractedA = this.extractor(a);
-      const extractedB = this.extractor(b);
-      const compared = extractedA - extractedB;
-      if (compared > 0)
-        return "GT";
-      if (compared < 0)
-        return "LT";
-      return "EQ";
-    }
   };
 
   // src/data-structures/binary-tree/avl-tree-multi-map.ts
@@ -11740,13 +11779,20 @@ var dataStructureTyped = (() => {
     }
   };
   var AVLTreeMultiMap = class _AVLTreeMultiMap extends AVLTree {
-    constructor(keysOrNodesOrEntries = [], options) {
+    /**
+     * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
+     * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+     * iterable object that can contain either keys, nodes, entries, or raw elements.
+     * @param [options] - The `options` parameter is an optional object that can be used to customize the
+     * behavior of the AVLTreeMultiMap. It can include properties such as `compareKeys` and
+     * `compareValues` functions to define custom comparison logic for keys and values, respectively.
+     */
+    constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
-      if (keysOrNodesOrEntries)
-        this.addMany(keysOrNodesOrEntries);
+      if (keysOrNodesOrEntriesOrRawElements)
+        this.addMany(keysOrNodesOrEntriesOrRawElements);
     }
-    // TODO the _count is not accurate after nodes count modified
     /**
      * The function calculates the sum of the count property of all nodes in a tree using depth-first
      * search.
@@ -11773,13 +11819,15 @@ var dataStructureTyped = (() => {
       return sum;
     }
     /**
-     * The function creates a new BSTNode with the given key, value, and count.
-     * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
-     * distinguish one node from another in the tree.
-     * @param {NODE} value - The `value` parameter represents the value that will be stored in the binary search tree node.
-     * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
-     * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
-     * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
+     * The function creates a new AVLTreeMultiMapNode with the specified key, value, and count.
+     * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
+     * which is a generic type that can be replaced with any specific type when using the function.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the node. It is of type `V`, which can be any data type.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of a
+     * key-value pair in the AVLTreeMultiMapNode. It is an optional parameter, so it can be omitted when
+     * calling the `createNode` method. If provided, it specifies the initial count for the node.
+     * @returns a new instance of the AVLTreeMultiMapNode class, casted as NODE.
      */
     createNode(key, value, count) {
       return new AVLTreeMultiMapNode(key, value, count);
@@ -11787,57 +11835,58 @@ var dataStructureTyped = (() => {
     /**
      * The function creates a new AVLTreeMultiMap object with the specified options and returns it.
      * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the `AVLTreeMultiMap` object. It can include properties such as
-     * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
-     * the tree, respectively. These properties can be
-     * @returns a new instance of the `AVLTreeMultiMap` class, with the provided options merged with the
-     * default options. The returned value is casted as `TREE`.
+     * configuration options for creating the AVLTreeMultiMap. It can have the following properties:
+     * @returns a new instance of the AVLTreeMultiMap class, with the specified options, as a TREE
+     * object.
      */
     createTree(options) {
       return new _AVLTreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
-        variant: this.variant
+        comparator: this.comparator
       }, options));
     }
     /**
-     * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, which means it
-     * can be one of the following:
-     * @param {V} [value] - The `value` parameter is an optional argument that represents the value
-     * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
-     * it defaults to `undefined`.
+     * The function checks if the input is an instance of AVLTreeMultiMapNode.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * an instance of the `AVLTreeMultiMapNode` class.
+     */
+    isNode(keyOrNodeOrEntryOrRawElement) {
+      return keyOrNodeOrEntryOrRawElement instanceof AVLTreeMultiMapNode;
+    }
+    /**
+     * The function `keyValueOrEntryOrRawElementToNode` converts a key, value, entry, or raw element into
+     * a node object.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * `keyOrNodeOrEntryOrRawElement` parameter can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {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 value should be added to the node. If not provided, it defaults to 1.
-     * @returns a node of type `NODE` or `undefined`.
+     * 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.
      */
-    keyValueOrEntryToNode(keyOrNodeOrEntry, value, count = 1) {
-      let node;
-      if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value, count = 1) {
+      if (keyOrNodeOrEntryOrRawElement === void 0 || keyOrNodeOrEntryOrRawElement === null)
         return;
-      } else if (this.isNode(keyOrNodeOrEntry)) {
-        node = keyOrNodeOrEntry;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value2] = keyOrNodeOrEntry;
-        if (key === void 0 || key === null) {
+      if (this.isNode(keyOrNodeOrEntryOrRawElement))
+        return keyOrNodeOrEntryOrRawElement;
+      if (this.toEntryFn) {
+        const [key, entryValue] = this.toEntryFn(keyOrNodeOrEntryOrRawElement);
+        if (key)
+          return this.createNode(key, entryValue != null ? entryValue : value, count);
+      }
+      if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
+        const [key, value2] = keyOrNodeOrEntryOrRawElement;
+        if (key === void 0 || key === null)
           return;
-        } else {
-          node = this.createNode(key, value2, count);
-        }
-      } else if (!this.isNode(keyOrNodeOrEntry)) {
-        node = this.createNode(keyOrNodeOrEntry, value, count);
-      } else {
-        return;
+        else
+          return this.createNode(key, value2, count);
       }
-      return node;
-    }
-    /**
-     * The function checks if an keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode
-     * class.
-     */
-    isNode(keyOrNodeOrEntry) {
-      return keyOrNodeOrEntry instanceof AVLTreeMultiMapNode;
+      if (this.isKey(keyOrNodeOrEntryOrRawElement))
+        return this.createNode(keyOrNodeOrEntryOrRawElement, value, count);
+      return;
     }
     /**
      * Time Complexity: O(log n)
@@ -11847,20 +11896,21 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function overrides the add method of a binary tree node and adds a new node to the tree.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
-     * entry. It represents the key, node, or entry that you want to add to the binary tree.
+     * The function overrides the add method of a TypeScript class to add a new node to a data structure
+     * and update the count.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * `keyOrNodeOrEntryOrRawElement` parameter can accept a value of type `R`, which can be any type. It
+     * can also accept a value of type `KeyOrNodeOrEntry<K, V, NODE>`, which represents a key, node,
+     * entry, or raw element
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
-     * binary tree node. It is an optional parameter, meaning it can be omitted when calling the `add`
-     * method.
+     * data structure. It is an optional parameter, so it can be omitted if not needed.
      * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
-     * be added to the binary tree. By default, it is set to 1, meaning that the key-value pair will be
-     * added once. However, you can specify a different value for `count` if you want to add
-     * @returns The method is returning either the newly inserted node or `undefined` if the insertion
-     * was not successful.
+     * be added to the data structure. By default, it is set to 1, meaning that the key-value pair will
+     * be added once. However, you can specify a different value for `count` if you want to add
+     * @returns a boolean value.
      */
-    add(keyOrNodeOrEntry, value, count = 1) {
-      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
+    add(keyOrNodeOrEntryOrRawElement, value, count = 1) {
+      const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value, count);
       if (newNode === void 0)
         return false;
       const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
@@ -11878,19 +11928,19 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
-     * account the count of the node and balancing the tree if necessary.
-     * @param identifier - The identifier is the value or key that is used to identify the node that
-     * needs to be deleted from the binary tree. It can be of any type that is returned by the callback
+     * The `delete` function in a binary tree data structure deletes a node based on its identifier and
+     * returns the deleted node along with the parent node that needs to be balanced.
+     * @param identifier - The identifier parameter is the value used to identify the node that needs to
+     * be deleted from the binary tree. It can be of any type and is the return type of the callback
      * function.
-     * @param {C} callback - The `callback` parameter is a function that is used to determine if a node
-     * should be deleted. It is optional and defaults to a default callback function. The `callback`
-     * function takes one parameter, which is the identifier of the node, and returns a value that is
-     * used to identify the node to
+     * @param {C} callback - The `callback` parameter is a function that is used to determine the
+     * equality of nodes in the binary tree. It is optional and has a default value of
+     * `this._DEFAULT_CALLBACK`. The `callback` function takes a single argument, which is the identifier
+     * of a node, and returns a value that
      * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
      * being deleted. If set to true, the count of the node will not be considered and the node will be
-     * deleted regardless of its count. If set to false (default), the count of the node will be
-     * decremented by 1 and
+     * deleted regardless of its count. If set to false (default), the count of the node will be taken
+     * into account and the node
      * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
     delete(identifier, callback = this._DEFAULT_CALLBACK, ignoreCount = false) {
@@ -11954,7 +12004,8 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The clear() function clears the contents of a data structure and sets the count to zero.
+     * The "clear" function overrides the parent class's "clear" function and also resets the count to
+     * zero.
      */
     clear() {
       super.clear();
@@ -11967,13 +12018,14 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(log n)
-     *
      * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
      * tree using either a recursive or iterative approach.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when building the balanced binary search tree. It can have two possible
-     * values:
-     * @returns a boolean value.
+     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
+     * specifies the type of iteration to use when building the balanced binary search tree. It has a
+     * default value of `this.iterationType`, which means it will use the iteration type currently set in
+     * the object.
+     * @returns The function `perfectlyBalance` returns a boolean value. It returns `true` if the
+     * balancing operation is successful, and `false` if there are no nodes to balance.
      */
     perfectlyBalance(iterationType = this.iterationType) {
       const sorted = this.dfs((node) => node, "IN"), n = sorted.length;
@@ -12018,7 +12070,7 @@ var dataStructureTyped = (() => {
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
-     * The `clone` function creates a deep copy of a tree object.
+     * 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.
      */
     clone() {
@@ -12027,13 +12079,21 @@ var dataStructureTyped = (() => {
       return cloned;
     }
     /**
-     * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-     * @param {K | NODE | undefined} srcNode - The `srcNode` parameter represents the source node from
-     * which the values will be swapped. It can be of type `K`, `NODE`, or `undefined`.
-     * @param {K | NODE | undefined} destNode - The `destNode` parameter represents the destination
-     * node where the values from the source node will be swapped to.
-     * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
-     * if either `srcNode` or `destNode` is undefined.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `_swapProperties` function swaps the properties (key, value, count, height) between two nodes
+     * in a binary search tree.
+     * @param {R | BSTNKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
+     * that will be swapped with the `destNode`.
+     * @param {R | BSTNKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+     * node where the properties will be swapped with the source node.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     * If either `srcNode` or `destNode` is undefined, it returns `undefined`.
      */
     _swapProperties(srcNode, destNode) {
       srcNode = this.ensureNode(srcNode);
@@ -12057,12 +12117,19 @@ var dataStructureTyped = (() => {
       return void 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function replaces an old node with a new node and updates the count property of the new node.
-     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
-     * needs to be replaced in a data structure.
-     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @param {NODE} oldNode - The oldNode parameter represents the node that needs to be replaced in the
+     * data structure. It is of type NODE.
+     * @param {NODE} newNode - The `newNode` parameter is an instance of the `NODE` class.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
-     * superclass, after updating the `count` property of the `newNode` object.
+     * superclass, which is of type `NODE`.
      */
     _replaceNode(oldNode, newNode) {
       newNode.count = oldNode.count + newNode.count;
@@ -12107,19 +12174,19 @@ var dataStructureTyped = (() => {
   };
   var TreeMultiMap = class _TreeMultiMap extends RedBlackTree {
     /**
-     * The constructor function initializes a new instance of the TreeMultiMap class with optional
-     * initial keys, nodes, or entries.
-     * @param keysOrNodesOrEntries - The `keysOrNodesOrEntries` parameter is an iterable object that can
-     * contain keys, nodes, or entries. It is used to initialize the TreeMultiMap with the provided keys,
-     * nodes, or entries.
-     * @param [options] - The `options` parameter is an optional object that can be passed to the
-     * constructor. It allows you to customize the behavior of the `TreeMultiMap` instance.
+     * The constructor function initializes a TreeMultiMap object with optional initial data.
+     * @param keysOrNodesOrEntriesOrRawElements - The parameter `keysOrNodesOrEntriesOrRawElements` is an
+     * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
+     * TreeMultiMap with initial data.
+     * @param [options] - The `options` parameter is an optional object that can be used to customize the
+     * behavior of the `TreeMultiMap` constructor. It can include properties such as `compareKeys` and
+     * `compareValues`, which are functions used to compare keys and values respectively.
      */
-    constructor(keysOrNodesOrEntries = [], options) {
+    constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
-      if (keysOrNodesOrEntries)
-        this.addMany(keysOrNodesOrEntries);
+      if (keysOrNodesOrEntriesOrRawElements)
+        this.addMany(keysOrNodesOrEntriesOrRawElements);
     }
     // TODO the _count is not accurate after nodes count modified
     /**
@@ -12149,16 +12216,15 @@ var dataStructureTyped = (() => {
     /**
      * The function creates a new TreeMultiMapNode with the specified key, value, color, and count.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
-     * which is a generic type representing the key type of the node.
-     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
-     * node. It is an optional parameter, which means it can be omitted when calling the `createNode`
-     * function. If provided, it should be of type `V`.
+     * which is a generic type representing the type of keys in the tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the node. It is of type `V`, which can be any data type.
      * @param {RBTNColor} [color=BLACK] - The color parameter is used to specify the color of the node in
      * a Red-Black Tree. It can have two possible values: 'RED' or 'BLACK'. The default value is 'BLACK'.
      * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
      * the tree. It is an optional parameter and is used to keep track of the number of values associated
      * with a key in the tree.
-     * @returns A new instance of the TreeMultiMapNode class is being returned.
+     * @returns A new instance of the TreeMultiMapNode class, casted as NODE.
      */
     createNode(key, value, color = "BLACK", count) {
       return new TreeMultiMapNode(key, value, count, color);
@@ -12166,10 +12232,10 @@ var dataStructureTyped = (() => {
     /**
      * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
      * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the `TreeMultiMap`. It can include properties such as
-     * `keyComparator`, `valueComparator`, `allowDuplicates`, etc.
+     * configuration options for creating the `TreeMultiMap`. It is of type `TreeMultiMapOptions<K, V,
+     * R>`.
      * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
-     * existing `iterationType` option. The returned value is casted as `TREE`.
+     * existing `iterationType` property. The returned value is casted as `TREE`.
      */
     createTree(options) {
       return new _TreeMultiMap([], __spreadValues({
@@ -12177,46 +12243,47 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function `keyValueOrEntryToNode` takes a key, value, and count and returns a node if the input
-     * is valid.
-     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
-     * NODE>`. It can accept three types of values:
-     * @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.
-     * @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 node. If not provided, it defaults to 1.
-     * @returns a NODE object or undefined.
+     * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
+     * node based on the input.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {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.
      */
-    keyValueOrEntryToNode(keyOrNodeOrEntry, value, count = 1) {
-      let node;
-      if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value, count = 1) {
+      if (keyOrNodeOrEntryOrRawElement === void 0 || keyOrNodeOrEntryOrRawElement === null)
         return;
-      } else if (this.isNode(keyOrNodeOrEntry)) {
-        node = keyOrNodeOrEntry;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value2] = keyOrNodeOrEntry;
-        if (key === void 0 || key === null) {
+      if (this.isNode(keyOrNodeOrEntryOrRawElement))
+        return keyOrNodeOrEntryOrRawElement;
+      if (this.toEntryFn) {
+        const [key] = this.toEntryFn(keyOrNodeOrEntryOrRawElement);
+        if (key)
+          return this.getNodeByKey(key);
+      }
+      if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
+        const [key, value2] = keyOrNodeOrEntryOrRawElement;
+        if (key === void 0 || key === null)
           return;
-        } else {
-          node = this.createNode(key, value2, "BLACK", count);
-        }
-      } else if (!this.isNode(keyOrNodeOrEntry)) {
-        node = this.createNode(keyOrNodeOrEntry, value, "BLACK", count);
-      } else {
-        return;
+        else
+          return this.createNode(key, value2, "BLACK", count);
       }
-      return node;
+      if (this.isKey(keyOrNodeOrEntryOrRawElement))
+        return this.createNode(keyOrNodeOrEntryOrRawElement, value, "BLACK", count);
+      return;
     }
     /**
-     * The function "isNode" checks if a given key, node, or entry is an instance of the TreeMultiMapNode
-     * class.
-     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
-     * NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntry` is an instance
-     * of the `TreeMultiMapNode` class.
+     * The function checks if the input is an instance of the TreeMultiMapNode class.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * an instance of the `TreeMultiMapNode` class.
      */
-    isNode(keyOrNodeOrEntry) {
-      return keyOrNodeOrEntry instanceof TreeMultiMapNode;
+    isNode(keyOrNodeOrEntryOrRawElement) {
+      return keyOrNodeOrEntryOrRawElement instanceof TreeMultiMapNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -12226,17 +12293,20 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function overrides the add method in TypeScript and adds a new node to the data structure.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
+     * The function overrides the add method of a class and adds a new node to a data structure, updating
+     * the count and returning a boolean indicating success.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * `keyOrNodeOrEntryOrRawElement` parameter can accept one of the following types:
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
-     * data structure.
+     * data structure. It is an optional parameter, so it can be omitted if not needed.
      * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
-     * be added to the data structure. By default, it is set to 1, meaning that the key-value pair will
-     * be added once. However, you can specify a different value for `count` if you want to add
-     * @returns a boolean value.
+     * be added to the data structure. By default, it is set to 1, meaning that if no value is provided
+     * for `count`, the key-value pair will be added once.
+     * @returns The method is returning a boolean value. It returns true if the addition of the new node
+     * was successful, and false otherwise.
      */
-    add(keyOrNodeOrEntry, value, count = 1) {
-      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
+    add(keyOrNodeOrEntryOrRawElement, value, count = 1) {
+      const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value, count);
       const orgCount = (newNode == null ? void 0 : newNode.count) || 0;
       const isSuccessAdded = super.add(newNode);
       if (isSuccessAdded) {
@@ -12254,20 +12324,18 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `delete` function in a TypeScript class is used to delete nodes from a binary tree based on a
-     * given identifier, and it returns an array of results containing information about the deleted
-     * nodes.
-     * @param {ReturnType<C> | null | undefined} identifier - The identifier parameter is the value used
-     * to identify the node to be deleted. It can be of any type that is returned by the callback
-     * function. It can also be null or undefined if no node needs to be deleted.
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
-     * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
-     * identifier for deletion. If no callback is provided, the `_DEFAULT_CALLBACK` function is
-     * used
-     * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
-     * node when performing deletion. If set to true, the count of the target node will not be considered
-     * and the node will be deleted regardless of its count. If set to false (default), the count of the
-     * target node will be decremented
+     * The function `delete` is used to remove a node from a binary tree and fix the tree if necessary.
+     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value or
+     * key that is used to identify the node that needs to be deleted from the binary tree. It can be of
+     * any type that is returned by the callback function `C`. It can also be `null` or `undefined` if
+     * the node to be deleted
+     * @param {C} callback - The `callback` parameter is a function that is used to determine the
+     * equality of nodes in the binary tree. It is optional and has a default value of
+     * `this._DEFAULT_CALLBACK`. The `callback` function is used to compare nodes when searching for a
+     * specific node or when performing other operations on the
+     * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
+     * being deleted. If set to true, the count of the node will not be taken into account when deleting
+     * it. If set to false, the count of the node will be decremented by 1 before deleting it.
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */
     delete(identifier, callback = this._DEFAULT_CALLBACK, ignoreCount = false) {
@@ -12375,10 +12443,12 @@ var dataStructureTyped = (() => {
      *
      * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
      * tree using either a recursive or iterative approach.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when building the balanced binary search tree. It can have two possible
-     * values:
-     * @returns a boolean value.
+     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
+     * specifies the type of iteration to use when building the balanced binary search tree. It has a
+     * default value of `this.iterationType`, which means it will use the iteration type specified by the
+     * `iterationType` property of the current object.
+     * @returns The function `perfectlyBalance` returns a boolean value. It returns `true` if the
+     * balancing operation is successful, and `false` if there are no nodes to balance.
      */
     perfectlyBalance(iterationType = this.iterationType) {
       const sorted = this.dfs((node) => node, "IN"), n = sorted.length;
@@ -12432,15 +12502,22 @@ var dataStructureTyped = (() => {
       return cloned;
     }
     /**
-     * The function swaps the properties of two nodes in a binary search tree.
-     * @param srcNode - The source node that needs to be swapped with the destination node. It can be
-     * either a key or a node object.
-     * @param destNode - The `destNode` parameter is the node in the binary search tree where the
-     * properties will be swapped with the `srcNode`.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `_swapProperties` function swaps the properties (key, value, count, color) between two nodes
+     * in a binary search tree.
+     * @param {R | BSTNKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
+     * that will be swapped with the `destNode`. It can be either an instance of the `R` class or an
+     * instance of the `BSTNKeyOrNode<K, NODE>` class.
+     * @param {R | BSTNKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+     * node where the properties will be swapped with the source node.
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-     * If both `srcNode` and `destNode` are valid nodes, the method swaps their `key`, `value`, `count`,
-     * and `color` properties. If the swapping is successful, the method returns the modified `destNode`.
-     * If either `srcNode` or `destNode` is
+     * If either `srcNode` or `destNode` is undefined, it returns undefined.
      */
     _swapProperties(srcNode, destNode) {
       srcNode = this.ensureNode(srcNode);
@@ -12464,12 +12541,19 @@ var dataStructureTyped = (() => {
       return void 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function replaces an old node with a new node and updates the count property of the new node.
-     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
-     * needs to be replaced in the data structure.
-     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @param {NODE} oldNode - The `oldNode` parameter is the node that you want to replace in the data
+     * structure.
+     * @param {NODE} newNode - The `newNode` parameter is an instance of the `NODE` class.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
-     * superclass, after updating the `count` property of the `newNode` object.
+     * superclass, which is of type `NODE`.
      */
     _replaceNode(oldNode, newNode) {
       newNode.count = oldNode.count + newNode.count;