data-structure-typed 1.54.0 → 1.54.2

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

@@ -1,7 +1,9 @@
 "use strict";
 var dataStructureTyped = (() => {
   var __defProp = Object.defineProperty;
+  var __defProps = Object.defineProperties;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getOwnPropSymbols = Object.getOwnPropertySymbols;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
@@ -22,6 +24,7 @@ var dataStructureTyped = (() => {
       }
     return a;
   };
+  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -93,6 +96,8 @@ var dataStructureTyped = (() => {
   var src_exports = {};
   __export(src_exports, {
     AVLTree: () => AVLTree,
+    AVLTreeCounter: () => AVLTreeCounter,
+    AVLTreeCounterNode: () => AVLTreeCounterNode,
     AVLTreeMultiMap: () => AVLTreeMultiMap,
     AVLTreeMultiMapNode: () => AVLTreeMultiMapNode,
     AVLTreeNode: () => AVLTreeNode,
@@ -142,6 +147,8 @@ var dataStructureTyped = (() => {
     SkipListNode: () => SkipListNode,
     Stack: () => Stack,
     THUNK_SYMBOL: () => THUNK_SYMBOL,
+    TreeCounter: () => TreeCounter,
+    TreeCounterNode: () => TreeCounterNode,
     TreeMultiMap: () => TreeMultiMap,
     TreeMultiMapNode: () => TreeMultiMapNode,
     TreeNode: () => TreeNode,
@@ -7383,6 +7390,14 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/binary-tree/binary-tree.ts
   var BinaryTreeNode = class {
+    /**
+     * The constructor function initializes an object with a key and an optional value in TypeScript.
+     * @param {K} key - The `key` parameter in the constructor function is used to store the key value
+     * for the key-value pair.
+     * @param {V} [value] - The `value` parameter in the constructor is optional, meaning it does not
+     * have to be provided when creating an instance of the class. If a `value` is not provided, it will
+     * default to `undefined`.
+     */
     constructor(key, value) {
       __publicField(this, "key");
       __publicField(this, "value");
@@ -7432,13 +7447,12 @@ var dataStructureTyped = (() => {
       this._count = value;
     }
     get familyPosition() {
-      const that = this;
       if (!this.parent) {
         return this.left || this.right ? "ROOT" : "ISOLATED";
       }
-      if (this.parent.left === that) {
+      if (this.parent.left === this) {
         return this.left || this.right ? "ROOT_LEFT" : "LEFT";
-      } else if (this.parent.right === that) {
+      } else if (this.parent.right === this) {
         return this.left || this.right ? "ROOT_RIGHT" : "RIGHT";
       }
       return "MAL_NODE";
@@ -7446,13 +7460,13 @@ var dataStructureTyped = (() => {
   };
   var BinaryTree = class _BinaryTree extends IterableEntryBase {
     /**
-     * The constructor initializes a binary tree with optional options and adds keys, nodes, entries, or
-     * raw data if provided.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor
-     * is an iterable that can contain elements of type `BTNRep<K, V, NODE>` or `R`. It is
-     * initialized with an empty array `[]` by default.
-     * @param [options] - The `options` parameter in the constructor is an object that can contain the
-     * following properties:
+     * This TypeScript constructor function initializes a binary tree with optional options and adds
+     * elements based on the provided input.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain either objects of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It
+     * is used to initialize the binary tree with keys, nodes, entries, or raw data.
+     * @param [options] - The `options` parameter in the constructor is an optional object that can
+     * contain the following properties:
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
       super();
@@ -7501,12 +7515,15 @@ var dataStructureTyped = (() => {
      * not required to be provided when calling the function. If a `value` is provided, it should be of
      * type `V`, which is the type of the value associated with the node.
      * @returns A new BinaryTreeNode instance with the provided key and value is being returned, casted
-     * as NODE.
+     * as BinaryTreeNode<K, V>.
      */
     createNode(key, value) {
       return new BinaryTreeNode(key, this._isMapMode ? void 0 : value);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a binary tree with the specified options.
      * @param [options] - The `options` parameter in the `createTree` function is an optional parameter
      * that allows you to provide partial configuration options for creating a binary tree. It is of type
@@ -7521,48 +7538,14 @@ var dataStructureTyped = (() => {
         toEntryFn: this._toEntryFn
       }, options));
     }
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
-     * or returns null.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
-     * can be of type `BTNRep<K, V, NODE>` or `R`. This parameter represents either a key, a
-     * node, an entry
-     * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
-     * an optional parameter of type `V`. It represents the value associated with the key in the node
-     * being created. If a `value` is provided, it will be used when creating the node. If
-     * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
-     * (`OptNodeOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
-     * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
-     * value.
-     */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
-      if (keyNodeEntryOrRaw === void 0) return [void 0, void 0];
-      if (keyNodeEntryOrRaw === null) return [null, void 0];
-      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
-      if (this.isEntry(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = keyNodeEntryOrRaw;
-        if (key === void 0) return [void 0, void 0];
-        else if (key === null) return [null, void 0];
-        const finalValue = value != null ? value : entryValue;
-        return [this.createNode(key, finalValue), finalValue];
-      }
-      if (this.isRaw(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-        const finalValue = value != null ? value : entryValue;
-        if (this.isKey(key)) return [this.createNode(key, finalValue), finalValue];
-      }
-      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
-      return [void 0, void 0];
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
      *
      * The function `ensureNode` in TypeScript checks if a given input is a node, entry, key, or raw
      * value and returns the corresponding node or null.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
-     * parameter in the `ensureNode` function can be of type `BTNRep<K, V, NODE>` or `R`. It
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `ensureNode` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It
      * is used to determine whether the input is a key, node, entry, or raw data. The
      * @param {IterationType} iterationType - The `iterationType` parameter in the `ensureNode` function
      * is used to specify the type of iteration to be performed. It has a default value of
@@ -7570,41 +7553,42 @@ var dataStructureTyped = (() => {
      * @returns The `ensureNode` function returns either a node, `null`, or `undefined` based on the
      * conditions specified in the code snippet.
      */
-    ensureNode(keyNodeEntryOrRaw, iterationType = this.iterationType) {
-      if (keyNodeEntryOrRaw === null) return null;
-      if (keyNodeEntryOrRaw === void 0) return;
-      if (keyNodeEntryOrRaw === this._NIL) return;
-      if (this.isNode(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw;
-      if (this.isEntry(keyNodeEntryOrRaw)) {
-        const key = keyNodeEntryOrRaw[0];
+    ensureNode(keyNodeOrEntry, iterationType = this.iterationType) {
+      if (keyNodeOrEntry === null) return null;
+      if (keyNodeOrEntry === void 0) return;
+      if (keyNodeOrEntry === this._NIL) return;
+      if (this.isNode(keyNodeOrEntry)) return keyNodeOrEntry;
+      if (this.isEntry(keyNodeOrEntry)) {
+        const key = keyNodeOrEntry[0];
         if (key === null) return null;
         if (key === void 0) return;
         return this.getNode(key, this._root, iterationType);
       }
-      if (this._toEntryFn) {
-        const [key] = this._toEntryFn(keyNodeEntryOrRaw);
-        if (this.isKey(key)) return this.getNode(key);
-      }
-      if (this.isKey(keyNodeEntryOrRaw)) return this.getNode(keyNodeEntryOrRaw, this._root, iterationType);
-      return;
+      return this.getNode(keyNodeOrEntry, this._root, iterationType);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function isNode checks if the input is an instance of BinaryTreeNode.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be either a key, a node, an entry, or raw data. The function is
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be either a key, a node, an entry, or raw data. The function is
      * checking if the input is an instance of a `BinaryTreeNode` and returning a boolean value
      * accordingly.
-     * @returns The function `isNode` is checking if the input `keyNodeEntryOrRaw` is an instance of
+     * @returns The function `isNode` is checking if the input `keyNodeOrEntry` is an instance of
      * `BinaryTreeNode`. If it is, the function returns `true`, indicating that the input is a node. If
      * it is not an instance of `BinaryTreeNode`, the function returns `false`, indicating that the input
      * is not a node.
      */
-    isNode(keyNodeEntryOrRaw) {
-      return keyNodeEntryOrRaw instanceof BinaryTreeNode;
+    isNode(keyNodeOrEntry) {
+      return keyNodeOrEntry instanceof BinaryTreeNode;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function `isRaw` checks if the input parameter is of type `R` by verifying if it is an object.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - BTNRep<K, V, NODE> | R
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | R} keyNodeEntryOrRaw - BTNRep<K, V, BinaryTreeNode<K, V>>
      * @returns The function `isRaw` is checking if the `keyNodeEntryOrRaw` parameter is of type `R` by
      * checking if it is an object. If the parameter is an object, the function will return `true`,
      * indicating that it is of type `R`.
@@ -7613,85 +7597,114 @@ var dataStructureTyped = (() => {
       return this._toEntryFn !== void 0 && typeof keyNodeEntryOrRaw === "object";
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function `isRealNode` checks if a given input is a valid node in a binary tree.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
-     * parameter in the `isRealNode` function can be of type `BTNRep<K, V, NODE>` or `R`.
-     * The function checks if the input parameter is a `NODE` type by verifying if it is not equal
-     * @returns The function `isRealNode` is checking if the input `keyNodeEntryOrRaw` is a valid
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `isRealNode` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`.
+     * The function checks if the input parameter is a `BinaryTreeNode<K, V>` type by verifying if it is not equal
+     * @returns The function `isRealNode` is checking if the input `keyNodeOrEntry` is a valid
      * node by comparing it to `this._NIL`, `null`, and `undefined`. If the input is not one of these
      * values, it then calls the `isNode` method to further determine if the input is a node. The
      * function will return a boolean value indicating whether the
      */
-    isRealNode(keyNodeEntryOrRaw) {
-      if (keyNodeEntryOrRaw === this._NIL || keyNodeEntryOrRaw === null || keyNodeEntryOrRaw === void 0) return false;
-      return this.isNode(keyNodeEntryOrRaw);
+    isRealNode(keyNodeOrEntry) {
+      if (keyNodeOrEntry === this._NIL || keyNodeOrEntry === null || keyNodeOrEntry === void 0) return false;
+      return this.isNode(keyNodeOrEntry);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given input is a valid node or null.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` in the `isRealNodeOrNull` function can be of type `BTNRep<K,
-     * V, NODE>` or `R`. It is a union type that can either be a key, a node, an entry, or
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` in the `isRealNodeOrNull` function can be of type `BTNRep<K,
+     * V, BinaryTreeNode<K, V>>` or `R`. It is a union type that can either be a key, a node, an entry, or
      * @returns The function `isRealNodeOrNull` is returning a boolean value. It checks if the input
-     * `keyNodeEntryOrRaw` is either `null` or a real node, and returns `true` if it is a node or
+     * `keyNodeOrEntry` is either `null` or a real node, and returns `true` if it is a node or
      * `null`, and `false` otherwise.
      */
-    isRealNodeOrNull(keyNodeEntryOrRaw) {
-      return keyNodeEntryOrRaw === null || this.isRealNode(keyNodeEntryOrRaw);
+    isRealNodeOrNull(keyNodeOrEntry) {
+      return keyNodeOrEntry === null || this.isRealNode(keyNodeOrEntry);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function isNIL checks if a given key, node, entry, or raw value is equal to the _NIL value.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - BTNRep<K, V,
-     * NODE> | R
-     * @returns The function is checking if the `keyNodeEntryOrRaw` parameter is equal to the `_NIL`
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - BTNRep<K, V,
+     * BinaryTreeNode<K, V>>
+     * @returns The function is checking if the `keyNodeOrEntry` parameter is equal to the `_NIL`
      * property of the current object and returning a boolean value based on that comparison.
      */
-    isNIL(keyNodeEntryOrRaw) {
-      return keyNodeEntryOrRaw === this._NIL;
+    isNIL(keyNodeOrEntry) {
+      return keyNodeOrEntry === this._NIL;
     }
-    isRange(keyNodeEntryRawOrPredicate) {
-      return keyNodeEntryRawOrPredicate instanceof Range;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `isRange` checks if the input parameter is an instance of the `Range` class.
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>> | Range<K>}
+     * keyNodeEntryOrPredicate - The `keyNodeEntryOrPredicate` parameter in the `isRange` function can be
+     * of type `BTNRep<K, V, BinaryTreeNode<K, V>>`, `NodePredicate<BinaryTreeNode<K, V>>`, or
+     * `Range<K>`. The function checks if the `keyNodeEntry
+     * @returns The `isRange` function is checking if the `keyNodeEntryOrPredicate` parameter is an
+     * instance of the `Range` class. If it is an instance of `Range`, the function will return `true`,
+     * indicating that the parameter is a `Range<K>`. If it is not an instance of `Range`, the function
+     * will return `false`.
+     */
+    isRange(keyNodeEntryOrPredicate) {
+      return keyNodeEntryOrPredicate instanceof Range;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
      * tree.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `BTNRep<K, V, NODE>` or `R`. It represents a
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It represents a
      * key, node, entry, or raw data in a binary tree structure. The function `isLeaf` checks whether the
      * provided
      * @returns The function `isLeaf` returns a boolean value indicating whether the input
-     * `keyNodeEntryOrRaw` is a leaf node in a binary tree.
+     * `keyNodeOrEntry` is a leaf node in a binary tree.
      */
-    isLeaf(keyNodeEntryOrRaw) {
-      keyNodeEntryOrRaw = this.ensureNode(keyNodeEntryOrRaw);
-      if (keyNodeEntryOrRaw === void 0) return false;
-      if (keyNodeEntryOrRaw === null) return true;
-      return !this.isRealNode(keyNodeEntryOrRaw.left) && !this.isRealNode(keyNodeEntryOrRaw.right);
+    isLeaf(keyNodeOrEntry) {
+      keyNodeOrEntry = this.ensureNode(keyNodeOrEntry);
+      if (keyNodeOrEntry === void 0) return false;
+      if (keyNodeOrEntry === null) return true;
+      return !this.isRealNode(keyNodeOrEntry.left) && !this.isRealNode(keyNodeOrEntry.right);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function `isEntry` checks if the input is a BTNEntry object by verifying if it is an array
      * with a length of 2.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
-     * parameter in the `isEntry` function can be of type `BTNRep<K, V, NODE>` or type `R`.
-     * The function checks if the provided `keyNodeEntryOrRaw` is of type `BTN
-     * @returns The `isEntry` function is checking if the `keyNodeEntryOrRaw` parameter is an array
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `isEntry` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or type `R`.
+     * The function checks if the provided `keyNodeOrEntry` is of type `BTN
+     * @returns The `isEntry` function is checking if the `keyNodeOrEntry` parameter is an array
      * with a length of 2. If it is, then it returns `true`, indicating that the parameter is of type
      * `BTNEntry<K, V>`. If the condition is not met, it returns `false`.
      */
-    isEntry(keyNodeEntryOrRaw) {
-      return Array.isArray(keyNodeEntryOrRaw) && keyNodeEntryOrRaw.length === 2;
+    isEntry(keyNodeOrEntry) {
+      return Array.isArray(keyNodeOrEntry) && keyNodeOrEntry.length === 2;
     }
     /**
      * Time Complexity O(1)
      * Space Complexity O(1)
      *
-     * The function `isKey` checks if a given key is comparable.
+     * The function `isValidKey` checks if a given key is comparable.
      * @param {any} key - The `key` parameter is of type `any`, which means it can be any data type in
      * TypeScript.
-     * @returns The function `isKey` is checking if the `key` parameter is `null` or if it is comparable.
+     * @returns The function `isValidKey` is checking if the `key` parameter is `null` or if it is comparable.
      * If the `key` is `null`, the function returns `true`. Otherwise, it returns the result of the
      * `isComparable` function, which is not provided in the code snippet.
      */
-    isKey(key) {
+    isValidKey(key) {
       if (key === null) return true;
       return isComparable(key);
     }
@@ -7701,8 +7714,8 @@ var dataStructureTyped = (() => {
      *
      * The `add` function in TypeScript adds a new node to a binary tree while handling duplicate keys
      * and finding the correct insertion position.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `add` method you provided
-     * seems to be for adding a new node to a binary tree structure. The `keyNodeEntryOrRaw`
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `add` method you provided
+     * seems to be for adding a new node to a binary tree structure. The `keyNodeOrEntry`
      * parameter in the method can accept different types of values:
      * @param {V} [value] - The `value` parameter in the `add` method represents the value associated
      * with the key that you want to add to the binary tree. When adding a key-value pair to the binary
@@ -7712,8 +7725,8 @@ var dataStructureTyped = (() => {
      * node was successful, and `false` if the insertion position could not be found or if a duplicate
      * key was found and the node was replaced instead of inserted.
      */
-    add(keyNodeEntryOrRaw, value) {
-      const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    add(keyNodeOrEntry, value) {
+      const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
       if (newNode === void 0) return false;
       if (!this._root) {
         this._setRoot(newNode);
@@ -7755,14 +7768,14 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(k * n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(k)
      *
      * The `addMany` function takes in multiple keys or nodes or entries or raw values along with
      * optional values, and adds them to a data structure while returning an array indicating whether
      * each insertion was successful.
      * @param keysNodesEntriesOrRaws - `keysNodesEntriesOrRaws` is an iterable that can contain a
      * mix of keys, nodes, entries, or raw values. Each element in this iterable can be of type
-     * `BTNRep<K, V, NODE>` or `R`.
+     * `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`.
      * @param [values] - The `values` parameter in the `addMany` function is an optional parameter that
      * accepts an iterable of values. These values correspond to the keys or nodes being added in the
      * `keysNodesEntriesOrRaws` parameter. If provided, the function will iterate over the values and
@@ -7777,7 +7790,7 @@ var dataStructureTyped = (() => {
       if (values) {
         valuesIterator = values[Symbol.iterator]();
       }
-      for (const keyNodeEntryOrRaw of keysNodesEntriesOrRaws) {
+      for (let keyNodeEntryOrRaw of keysNodesEntriesOrRaws) {
         let value = void 0;
         if (valuesIterator) {
           const valueResult = valuesIterator.next();
@@ -7785,6 +7798,7 @@ var dataStructureTyped = (() => {
             value = valueResult.value;
           }
         }
+        if (this.isRaw(keyNodeEntryOrRaw)) keyNodeEntryOrRaw = this._toEntryFn(keyNodeEntryOrRaw);
         inserted.push(this.add(keyNodeEntryOrRaw, value));
       }
       return inserted;
@@ -7795,7 +7809,7 @@ var dataStructureTyped = (() => {
      *
      * The `merge` function in TypeScript merges another binary tree into the current tree by adding all
      * elements from the other tree.
-     * @param anotherTree - `BinaryTree<K, V, R, NODE, TREE>`
+     * @param anotherTree - BinaryTree<K, V, R, MK, MV, MR>
      */
     merge(anotherTree) {
       this.addMany(anotherTree, []);
@@ -7807,7 +7821,7 @@ var dataStructureTyped = (() => {
      * The `refill` function clears the existing data structure and then adds new key-value pairs based
      * on the provided input.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the `refill`
-     * method can accept an iterable containing a mix of `BTNRep<K, V, NODE>` objects or `R`
+     * method can accept an iterable containing a mix of `BTNRep<K, V, BinaryTreeNode<K, V>>` objects or `R`
      * objects.
      * @param [values] - The `values` parameter in the `refill` method is an optional parameter that
      * accepts an iterable of values of type `V` or `undefined`.
@@ -7822,7 +7836,7 @@ var dataStructureTyped = (() => {
      *
      * The function `delete` in TypeScript implements the deletion of a node in a binary tree and returns
      * the deleted node along with information for tree balancing.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry
      * - The `delete` method you provided is used to delete a node from a binary tree based on the key,
      * node, entry or raw data. The method returns an array of
      * `BinaryTreeDeleteResult` objects containing information about the deleted node and whether
@@ -7831,10 +7845,10 @@ var dataStructureTyped = (() => {
      * the array contains information about the node that was deleted (`deleted`) and the node that may
      * need to be balanced (`needBalanced`).
      */
-    delete(keyNodeEntryOrRaw) {
+    delete(keyNodeOrEntry) {
       const deletedResult = [];
       if (!this._root) return deletedResult;
-      const curr = this.getNode(keyNodeEntryOrRaw);
+      const curr = this.getNode(keyNodeOrEntry);
       if (!curr) return deletedResult;
       const parent = curr == null ? void 0 : curr.parent;
       let needBalanced;
@@ -7876,15 +7890,15 @@ var dataStructureTyped = (() => {
      *
      * The `search` function in TypeScript performs a depth-first or breadth-first search on a tree
      * structure based on a given predicate or key, with options to return multiple results or just one.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
-     * `keyNodeEntryRawOrPredicate` parameter in the `search` function can accept three types of values:
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
+     * `keyNodeEntryOrPredicate` parameter in the `search` function can accept three types of values:
      * @param [onlyOne=false] - The `onlyOne` parameter in the `search` function is a boolean flag that
      * determines whether the search should stop after finding the first matching node. If `onlyOne` is
      * set to `true`, the search will return as soon as a matching node is found. If `onlyOne` is
      * @param {C} callback - The `callback` parameter in the `search` function is a callback function
      * that will be called on each node that matches the search criteria. It is of type `C`, which
-     * extends `NodeCallback<NODE>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `search` function is
+     * extends `NodeCallback<BinaryTreeNode<K, V>>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `search` function is
      * used to specify the node from which the search operation should begin. It represents the starting
      * point in the binary tree where the search will be performed. If no specific `startNode` is
      * provided, the search operation will start from the root
@@ -7894,12 +7908,12 @@ var dataStructureTyped = (() => {
      * @returns The `search` function returns an array of values that match the provided criteria based
      * on the search algorithm implemented within the function.
      */
-    search(keyNodeEntryRawOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-      if (keyNodeEntryRawOrPredicate === void 0) return [];
-      if (keyNodeEntryRawOrPredicate === null) return [];
+    search(keyNodeEntryOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+      if (keyNodeEntryOrPredicate === void 0) return [];
+      if (keyNodeEntryOrPredicate === null) return [];
       startNode = this.ensureNode(startNode);
       if (!startNode) return [];
-      const predicate = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+      const predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
       const ans = [];
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
@@ -7934,12 +7948,12 @@ var dataStructureTyped = (() => {
      *
      * The function `getNodes` retrieves nodes from a binary tree based on a key, node, entry, raw data,
      * or predicate, with options for recursive or iterative traversal.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
      * - The `getNodes` function you provided takes several parameters:
      * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` function is a boolean flag that
      * determines whether to return only the first node that matches the criteria specified by the
-     * `keyNodeEntryRawOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * `keyNodeEntryOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
      * `getNodes` function is used to specify the starting point for traversing the binary tree. It
      * represents the root node of the binary tree or the node from which the traversal should begin. If
      * not provided, the default value is set to `this._root
@@ -7949,19 +7963,19 @@ var dataStructureTyped = (() => {
      * @returns The `getNodes` function returns an array of nodes that satisfy the provided condition
      * based on the input parameters and the iteration type specified.
      */
-    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
-      return this.search(keyNodeEntryRawOrPredicate, onlyOne, (node) => node, startNode, iterationType);
+    getNodes(keyNodeEntryOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+      return this.search(keyNodeEntryOrPredicate, onlyOne, (node) => node, startNode, iterationType);
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n).
+     * Space Complexity: O(log n)
      *
      * The `getNode` function retrieves a node based on the provided key, node, entry, raw data, or
      * predicate.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
-     * - The `keyNodeEntryRawOrPredicate` parameter in the `getNode` function can accept a key,
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+     * - The `keyNodeEntryOrPredicate` parameter in the `getNode` function can accept a key,
      * node, entry, raw data, or a predicate function.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
      * `getNode` function is used to specify the starting point for searching for a node in a binary
      * tree. If no specific starting point is provided, the default value is set to `this._root`, which
      * is typically the root node of the binary tree.
@@ -7972,9 +7986,8 @@ var dataStructureTyped = (() => {
      * @returns The `getNode` function is returning the first node that matches the specified criteria,
      * or `null` if no matching node is found.
      */
-    getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-      var _a;
-      return (_a = this.search(keyNodeEntryRawOrPredicate, true, (node) => node, startNode, iterationType)[0]) != null ? _a : null;
+    getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+      return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType)[0];
     }
     /**
      * Time Complexity: O(n)
@@ -7982,10 +7995,10 @@ var dataStructureTyped = (() => {
      *
      * This function overrides the `get` method to retrieve the value associated with a specified key,
      * node, entry, raw data, or predicate in a data structure.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
-     * - The `keyNodeEntryRawOrPredicate` parameter in the `get` method can accept one of the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+     * - The `keyNodeEntryOrPredicate` parameter in the `get` method can accept one of the
      * following types:
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `get`
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `get`
      * method is used to specify the starting point for searching for a key or node in the binary tree.
      * If no specific starting point is provided, the default starting point is the root of the binary
      * tree (`this._root`).
@@ -7998,14 +8011,14 @@ var dataStructureTyped = (() => {
      * the method returns the corresponding value. If the key or node is not found, it returns
      * `undefined`.
      */
-    get(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+    get(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
       var _a;
       if (this._isMapMode) {
-        const key = this._extractKey(keyNodeEntryRawOrPredicate);
+        const key = this._extractKey(keyNodeEntryOrPredicate);
         if (key === null || key === void 0) return;
         return this._store.get(key);
       }
-      return (_a = this.getNode(keyNodeEntryRawOrPredicate, startNode, iterationType)) == null ? void 0 : _a.value;
+      return (_a = this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)) == null ? void 0 : _a.value;
     }
     /**
      * Time Complexity: O(n)
@@ -8013,10 +8026,10 @@ var dataStructureTyped = (() => {
      *
      * The `has` function in TypeScript checks if a specified key, node, entry, raw data, or predicate
      * exists in the data structure.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
-     * - The `keyNodeEntryRawOrPredicate` parameter in the `override has` method can accept one of
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+     * - The `keyNodeEntryOrPredicate` parameter in the `override has` method can accept one of
      * the following types:
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
      * `override` method is used to specify the starting point for the search operation within the data
      * structure. It defaults to `this._root` if not provided explicitly.
      * @param {IterationType} iterationType - The `iterationType` parameter in the `override has` method
@@ -8028,14 +8041,14 @@ var dataStructureTyped = (() => {
      * are matching nodes, it returns `true`, indicating that the tree contains the specified element.
      * Otherwise, it returns `false`.
      */
-    has(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-      return this.search(keyNodeEntryRawOrPredicate, true, (node) => node, startNode, iterationType).length > 0;
+    has(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+      return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType).length > 0;
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `clear` function resets the root node and size of a data structure to empty.
+     * The clear function removes nodes and values in map mode.
      */
     clear() {
       this._clearNodes();
@@ -8059,7 +8072,7 @@ var dataStructureTyped = (() => {
      *
      * The function checks if a binary tree is perfectly balanced by comparing its minimum height with
      * its height.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter is the starting
      * point for checking if the binary tree is perfectly balanced. It represents the root node of the
      * binary tree or a specific node from which the balance check should begin.
      * @returns The method `isPerfectlyBalanced` is returning a boolean value, which indicates whether
@@ -8073,11 +8086,11 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function `isBST` in TypeScript checks if a binary search tree is valid using either recursive
      * or iterative methods.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `isBST`
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `isBST`
      * function represents the starting point for checking whether a binary search tree (BST) is valid.
      * It can be a node in the BST or a reference to the root of the BST. If no specific node is
      * provided, the function will default to
@@ -8126,13 +8139,13 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The `getDepth` function calculates the depth between two nodes in a binary tree.
-     * @param {BTNRep<K, V, NODE> | R} dist - The `dist` parameter in the `getDepth`
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} dist - The `dist` parameter in the `getDepth`
      * function represents the node or entry in a binary tree map, or a reference to a node in the tree.
      * It is the target node for which you want to calculate the depth from the `startNode` node.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
      * `getDepth` function represents the starting point from which you want to calculate the depth of a
      * given node or entry in a binary tree. If no specific starting point is provided, the default value
      * for `startNode` is set to the root of the binary
@@ -8155,11 +8168,11 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
      * or iterative approach in TypeScript.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter is the starting
      * point from which the height of the binary tree will be calculated. It can be a node in the binary
      * tree or a reference to the root of the tree. If not provided, it defaults to the root of the
      * binary tree data structure.
@@ -8199,7 +8212,7 @@ var dataStructureTyped = (() => {
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach in TypeScript.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
      * `getMinHeight` function represents the starting node from which the minimum height of the binary
      * tree will be calculated. It is either a node in the binary tree or a reference to the root of the
      * tree. If not provided, the default value is the root
@@ -8258,7 +8271,7 @@ var dataStructureTyped = (() => {
      * the path to the root. It is expected to be a function that takes a node as an argument and returns
      * a value based on that node. The return type of the callback function is determined by the generic
      * type `C
-     * @param {BTNRep<K, V, NODE> | R} beginNode - The `beginNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} beginNode - The `beginNode` parameter in the
      * `getPathToRoot` function can be either a key, a node, an entry, or any other value of type `R`.
      * @param [isReverse=true] - The `isReverse` parameter in the `getPathToRoot` function determines
      * whether the resulting path from the given `beginNode` to the root should be in reverse order or
@@ -8281,14 +8294,14 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function `getLeftMost` retrieves the leftmost node in a binary tree using either recursive or
      * tail-recursive iteration.
      * @param {C} callback - The `callback` parameter is a function that will be called with the leftmost
      * node of a binary tree or with `undefined` if the tree is empty. It is provided with a default
      * value of `_DEFAULT_NODE_CALLBACK` if not specified.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
      * `getLeftMost` function represents the starting point for finding the leftmost node in a binary
      * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
      * starting point is provided, the function will default
@@ -8320,15 +8333,15 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function `getRightMost` retrieves the rightmost node in a binary tree using either recursive
      * or iterative traversal methods.
      * @param {C} callback - The `callback` parameter is a function that will be called with the result
-     * of finding the rightmost node in a binary tree. It is of type `NodeCallback<OptNodeOrNull<NODE>>`,
+     * of finding the rightmost node in a binary tree. It is of type `NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>`,
      * which means it is a callback function that can accept either an optional binary tree node or null
      * as
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
      * `getRightMost` function represents the starting point for finding the rightmost node in a binary
      * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
      * starting point is provided, the function will default
@@ -8360,14 +8373,14 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function `getPredecessor` in TypeScript returns the predecessor node of a given node in a
      * binary tree.
-     * @param {NODE} node - The `getPredecessor` function you provided seems to be attempting to find the
+     * @param {BinaryTreeNode<K, V>} node - The `getPredecessor` function you provided seems to be attempting to find the
      * predecessor of a given node in a binary tree. However, there seems to be a logical issue in the
      * while loop condition that might cause an infinite loop.
-     * @returns The `getPredecessor` function returns the predecessor node of the input `NODE` parameter.
+     * @returns The `getPredecessor` function returns the predecessor node of the input `BinaryTreeNode<K, V>` parameter.
      * If the left child of the input node exists, it traverses to the rightmost node of the left subtree
      * to find the predecessor. If the left child does not exist, it returns the input node itself.
      */
@@ -8386,12 +8399,12 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function `getSuccessor` in TypeScript returns the next node in an in-order traversal of a
      * binary tree.
-     * @param {K | NODE | null} [x] - The `getSuccessor` function takes a parameter `x`, which can be of
-     * type `K`, `NODE`, or `null`.
+     * @param {K | BinaryTreeNode<K, V> | null} [x] - The `getSuccessor` function takes a parameter `x`, which can be of
+     * type `K`, `BinaryTreeNode<K, V>`, or `null`.
      * @returns The `getSuccessor` function returns the successor node of the input node `x`. If `x` has
      * a right child, the function returns the leftmost node in the right subtree of `x`. If `x` does not
      * have a right child, the function traverses up the parent nodes until it finds a node that is not
@@ -8417,12 +8430,12 @@ var dataStructureTyped = (() => {
      * The function `dfs` performs a depth-first search traversal on a binary tree structure based on the
      * specified parameters.
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends the
-     * `NodeCallback` interface with a type parameter of `OptNodeOrNull<NODE>`. It has a default value of
+     * `NodeCallback` interface with a type parameter of `OptNodeOrNull<BinaryTreeNode<K, V>>`. It has a default value of
      * `this._DEFAULT_NODE_CALLBACK as C`.
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `dfs` method specifies the
      * order in which the Depth-First Search (DFS) algorithm should traverse the nodes in the tree. The
      * possible values for the `pattern` parameter are:
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `dfs`
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `dfs`
      * method is used to specify the starting point for the Depth-First Search traversal. It can be
      * either a `BTNRep` object representing a key, node, or entry in the binary tree map,
      * or it can be a
@@ -8449,8 +8462,8 @@ var dataStructureTyped = (() => {
      * tree, executing a specified callback function on each node visited.
      * @param {C} callback - The `callback` parameter in the `bfs` function is a function that will be
      * called on each node visited during the breadth-first search traversal. It is a generic type `C`
-     * that extends the `NodeCallback` type, which takes a parameter of type `NODE` or `null`.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `bfs`
+     * that extends the `NodeCallback` type, which takes a parameter of type `BinaryTreeNode<K, V>` or `null`.
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `bfs`
      * function represents the starting point for the breadth-first search traversal in a binary tree. It
      * can be specified as a key, node, or entry in the binary tree structure. If not provided, the
      * default value is the root node of the binary
@@ -8469,7 +8482,9 @@ var dataStructureTyped = (() => {
       if (!startNode) return [];
       const ans = [];
       if (iterationType === "RECURSIVE") {
-        const queue = new Queue([startNode]);
+        const queue = new Queue([
+          startNode
+        ]);
         const dfs = (level) => {
           if (queue.size === 0) return;
           const current = queue.shift();
@@ -8511,7 +8526,7 @@ var dataStructureTyped = (() => {
      * structure based on a specified callback and iteration type.
      * @param {C} callback - The `callback` parameter is a function that will be called on each leaf node
      * in the binary tree. It is optional and defaults to a default callback function if not provided.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `leaves`
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `leaves`
      * method is used to specify the starting point for finding and processing the leaves of a binary
      * tree. It can be provided as either a key, a node, or an entry in the binary tree structure. If not
      * explicitly provided, the default value
@@ -8559,7 +8574,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be applied to each node in
      * the binary tree during the traversal. It is used to process each node and determine what
      * information to include in the output for each level of the tree.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
      * `listLevels` function represents the starting point for traversing the binary tree. It can be
      * either a key, a node, or an entry in the binary tree. If not provided, the default value is the
      * root of the binary tree.
@@ -8617,11 +8632,11 @@ var dataStructureTyped = (() => {
      * Morris Traversal algorithm with different order patterns.
      * @param {C} callback - The `callback` parameter in the `morris` function is a function that will be
      * called on each node in the binary tree during the traversal. It is of type `C`, which extends the
-     * `NodeCallback<NODE>` type. The default value for `callback` is `this._DEFAULT
+     * `NodeCallback<BinaryTreeNode<K, V>>` type. The default value for `callback` is `this._DEFAULT
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `morris` function specifies
      * the type of Depth-First Search (DFS) order pattern to traverse the binary tree. The possible
      * values for the `pattern` parameter are:
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `morris`
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `morris`
      * function is the starting point for the Morris traversal algorithm. It represents the root node of
      * the binary tree or the node from which the traversal should begin. It can be provided as either a
      * key, a node, an entry, or a reference
@@ -8722,6 +8737,10 @@ var dataStructureTyped = (() => {
      */
     clone() {
       const cloned = this.createTree();
+      this._clone(cloned);
+      return cloned;
+    }
+    _clone(cloned) {
       this.bfs(
         (node) => {
           if (node === null) cloned.add(null);
@@ -8735,7 +8754,6 @@ var dataStructureTyped = (() => {
         true
       );
       if (this._isMapMode) cloned._store = this._store;
-      return cloned;
     }
     /**
      * Time Complexity: O(n)
@@ -8796,7 +8814,7 @@ var dataStructureTyped = (() => {
      *
      * The function `toVisual` in TypeScript overrides the visual representation of a binary tree with
      * customizable options for displaying undefined, null, and sentinel nodes.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
      * `toVisual` method is used to specify the starting point for visualizing the binary tree structure.
      * It can be a node, key, entry, or the root of the tree. If no specific starting point is provided,
      * the default is set to the root
@@ -8820,7 +8838,7 @@ var dataStructureTyped = (() => {
       if (opts.isShowRedBlackNIL) output += `S for Sentinel Node(NIL)
 `;
       const display = (root) => {
-        const [lines, ,] = this._displayAux(root, opts);
+        const [lines] = this._displayAux(root, opts);
         let paragraph = "";
         for (const line of lines) {
           paragraph += line + "\n";
@@ -8840,7 +8858,7 @@ var dataStructureTyped = (() => {
      * printing options for the binary tree. It is an optional parameter that allows you to customize how
      * the binary tree is printed, such as choosing between different traversal orders or formatting
      * options.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
      * `override print` method is used to specify the starting point for printing the binary tree. It can
      * be either a key, a node, an entry, or the root of the tree. If no specific starting point is
      * provided, the default value is set to
@@ -8848,6 +8866,37 @@ var dataStructureTyped = (() => {
     print(options, startNode = this._root) {
       console.log(this.toVisual(startNode, options));
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
+     * or returns null.
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The
+     * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeOrEntry`, which
+     * can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. This parameter represents either a key, a
+     * node, an entry
+     * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
+     * an optional parameter of type `V`. It represents the value associated with the key in the node
+     * being created. If a `value` is provided, it will be used when creating the node. If
+     * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
+     * (`OptNodeOrNull<BinaryTreeNode<K, V>>`) based on the input parameters provided. The function checks the type of the
+     * input parameter (`keyNodeOrEntry`) and processes it accordingly to return a node or null
+     * value.
+     */
+    _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value) {
+      if (keyNodeOrEntry === void 0) return [void 0, void 0];
+      if (keyNodeOrEntry === null) return [null, void 0];
+      if (this.isNode(keyNodeOrEntry)) return [keyNodeOrEntry, value];
+      if (this.isEntry(keyNodeOrEntry)) {
+        const [key, entryValue] = keyNodeOrEntry;
+        if (key === void 0) return [void 0, void 0];
+        else if (key === null) return [null, void 0];
+        const finalValue = value != null ? value : entryValue;
+        return [this.createNode(key, finalValue), finalValue];
+      }
+      return [this.createNode(keyNodeOrEntry, value), value];
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -8856,11 +8905,11 @@ var dataStructureTyped = (() => {
      * the specified order pattern and callback function.
      * @param {C} callback - The `callback` parameter in the `_dfs` method is a function that will be
      * called on each node visited during the depth-first search traversal. It is of type `C`, which
-     * extends `NodeCallback<OptNodeOrNull<NODE>>`. The default value for this parameter is `this._DEFAULT
+     * extends `NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>`. The default value for this parameter is `this._DEFAULT
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `_dfs` method specifies the
      * order in which the nodes are visited during the Depth-First Search traversal. It can have one of
      * the following values:
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `_dfs`
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `_dfs`
      * method is used to specify the starting point for the depth-first search traversal in a binary
      * tree. It can be provided as either a `BTNRep` object or a reference to the root node
      * of the tree. If no specific
@@ -9070,12 +9119,12 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The _swapProperties function swaps key and value properties between two nodes in a binary tree.
-     * @param {BTNRep<K, V, NODE> | R} srcNode - The `srcNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} srcNode - The `srcNode` parameter in the
      * `_swapProperties` method can be either a BTNRep object containing key and value
      * properties, or it can be of type R.
-     * @param {BTNRep<K, V, NODE> | R} destNode - The `destNode` parameter in the
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} destNode - The `destNode` parameter in the
      * `_swapProperties` method represents the node or entry where the properties will be swapped with
-     * the `srcNode`. It can be of type `BTNRep<K, V, NODE>` or `R`. The method ensures that
+     * the `srcNode`. It can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. The method ensures that
      * both `srcNode
      * @returns The `_swapProperties` method returns either the `destNode` with its key and value swapped
      * with the `srcNode`, or `undefined` if either `srcNode` or `destNode` is falsy.
@@ -9101,9 +9150,9 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The _replaceNode function replaces an old node with a new node in a binary tree structure.
-     * @param {NODE} oldNode - The `oldNode` parameter represents the node that you want to replace in a
+     * @param {BinaryTreeNode<K, V>} oldNode - The `oldNode` parameter represents the node that you want to replace in a
      * tree data structure.
-     * @param {NODE} newNode - The `newNode` parameter in the `_replaceNode` function represents the node
+     * @param {BinaryTreeNode<K, V>} newNode - The `newNode` parameter in the `_replaceNode` function represents the node
      * that will replace the `oldNode` in a tree data structure. This function is responsible for
      * updating the parent, left child, right child, and root (if necessary) references when replacing a
      * node in the tree.
@@ -9132,8 +9181,8 @@ var dataStructureTyped = (() => {
      *
      * The function _setRoot sets the root node of a data structure while updating the parent reference
      * of the previous root node.
-     * @param v - The parameter `v` in the `_setRoot` method is of type `OptNodeOrNull<NODE>`, which means
-     * it can either be an optional `NODE` type or `null`.
+     * @param v - The parameter `v` in the `_setRoot` method is of type `OptNodeOrNull<BinaryTreeNode<K, V>>`, which means
+     * it can either be an optional `BinaryTreeNode<K, V>` type or `null`.
      */
     _setRoot(v) {
       if (v) {
@@ -9147,27 +9196,23 @@ var dataStructureTyped = (() => {
      *
      * The function `_ensurePredicate` in TypeScript ensures that the input is converted into a valid
      * predicate function for a binary tree node.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
      * `_ensurePredicate` method in the provided code snippet is responsible for ensuring that the input
-     * parameter `keyNodeEntryRawOrPredicate` is transformed into a valid predicate function that can be
+     * parameter `keyNodeEntryOrPredicate` is transformed into a valid predicate function that can be
      * used for filtering nodes in a binary tree.
-     * @returns A NodePredicate<NODE> function is being returned.
+     * @returns A NodePredicate<BinaryTreeNode<K, V>> function is being returned.
      */
-    _ensurePredicate(keyNodeEntryRawOrPredicate) {
-      if (keyNodeEntryRawOrPredicate === null || keyNodeEntryRawOrPredicate === void 0)
+    _ensurePredicate(keyNodeEntryOrPredicate) {
+      if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0)
         return (node) => node ? false : false;
-      if (this._isPredicate(keyNodeEntryRawOrPredicate)) return keyNodeEntryRawOrPredicate;
-      if (this.isRealNode(keyNodeEntryRawOrPredicate)) return (node) => node === keyNodeEntryRawOrPredicate;
-      if (this.isEntry(keyNodeEntryRawOrPredicate)) {
-        const [key] = keyNodeEntryRawOrPredicate;
-        return (node) => node.key === key;
-      }
-      if (this.isKey(keyNodeEntryRawOrPredicate)) return (node) => node.key === keyNodeEntryRawOrPredicate;
-      if (this._toEntryFn) {
-        const [key] = this._toEntryFn(keyNodeEntryRawOrPredicate);
+      if (this._isPredicate(keyNodeEntryOrPredicate)) return keyNodeEntryOrPredicate;
+      if (this.isRealNode(keyNodeEntryOrPredicate))
+        return (node) => node === keyNodeEntryOrPredicate;
+      if (this.isEntry(keyNodeEntryOrPredicate)) {
+        const [key] = keyNodeEntryOrPredicate;
         return (node) => node.key === key;
       }
-      return (node) => node.key === keyNodeEntryRawOrPredicate;
+      return (node) => node.key === keyNodeEntryOrPredicate;
     }
     /**
      * Time Complexity: O(1)
@@ -9176,7 +9221,7 @@ var dataStructureTyped = (() => {
      * The function `_isPredicate` checks if a given parameter is a function.
      * @param {any} p - The parameter `p` is a variable of type `any`, which means it can hold any type
      * of value. In this context, the function `_isPredicate` is checking if `p` is a function that
-     * satisfies the type `NodePredicate<NODE>`.
+     * satisfies the type `NodePredicate<BinaryTreeNode<K, V>>`.
      * @returns The function is checking if the input `p` is a function and returning a boolean value
      * based on that check. If `p` is a function, it will return `true`, indicating that `p` is a
      * predicate function for a binary tree node. If `p` is not a function, it will return `false`.
@@ -9190,27 +9235,20 @@ var dataStructureTyped = (() => {
      *
      * The function `_extractKey` in TypeScript returns the key from a given input, which can be a node,
      * entry, raw data, or null/undefined.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_extractKey` method you provided is a
-     * TypeScript method that takes in a parameter `keyNodeEntryOrRaw` of type `BTNRep<K, V, NODE> | R`,
-     * where `BTNRep` is a generic type with keys `K`, `V`, and `NODE`, and `
-     * @returns The `_extractKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
+     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `_extractKey` method you provided is a
+     * TypeScript method that takes in a parameter `keyNodeOrEntry` of type `BTNRep<K, V, BinaryTreeNode<K, V>>`,
+     * where `BTNRep` is a generic type with keys `K`, `V`, and `BinaryTreeNode<K, V>`, and `
+     * @returns The `_extractKey` method returns the key value extracted from the `keyNodeOrEntry`
      * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on
      * the conditions checked in the method.
      */
-    _extractKey(keyNodeEntryOrRaw) {
-      if (keyNodeEntryOrRaw === null) return null;
-      if (keyNodeEntryOrRaw === void 0) return;
-      if (keyNodeEntryOrRaw === this._NIL) return;
-      if (this.isNode(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw.key;
-      if (this.isEntry(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw[0];
-      if (this.isRaw(keyNodeEntryOrRaw)) {
-        if (this._toEntryFn) {
-          const [key] = this._toEntryFn(keyNodeEntryOrRaw);
-          return key;
-        }
-        return;
-      }
-      return keyNodeEntryOrRaw;
+    _extractKey(keyNodeOrEntry) {
+      if (keyNodeOrEntry === null) return null;
+      if (keyNodeOrEntry === void 0) return;
+      if (keyNodeOrEntry === this._NIL) return;
+      if (this.isNode(keyNodeOrEntry)) return keyNodeOrEntry.key;
+      if (this.isEntry(keyNodeOrEntry)) return keyNodeOrEntry[0];
+      return keyNodeOrEntry;
     }
     /**
      * Time Complexity: O(1)
@@ -9254,46 +9292,33 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/binary-tree/bst.ts
   var BSTNode = class extends BinaryTreeNode {
+    /**
+     * This TypeScript constructor function initializes an instance with a key and an optional value.
+     * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
+     * within a data structure. It serves as a reference or identifier for accessing or manipulating the
+     * associated value.
+     * @param {V} [value] - The `value` parameter in the constructor is optional, meaning it does not
+     * have to be provided when creating an instance of the class. If a value is not provided, it will
+     * default to `undefined`.
+     */
     constructor(key, value) {
       super(key, value);
       __publicField(this, "parent");
       __publicField(this, "_left");
       __publicField(this, "_right");
-      this.parent = void 0;
-      this._left = void 0;
-      this._right = void 0;
     }
-    /**
-     * The function returns the value of the `_left` property.
-     * @returns The `_left` property of the current object is being returned.
-     */
     get left() {
       return this._left;
     }
-    /**
-     * The function sets the left child of a node and updates the parent reference of the child.
-     * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be an
-     * instance of the `NODE` class or `undefined`.
-     */
     set left(v) {
       if (v) {
         v.parent = this;
       }
       this._left = v;
     }
-    /**
-     * The function returns the right node of a binary tree or undefined if there is no right node.
-     * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
-     * `undefined`.
-     */
     get right() {
       return this._right;
     }
-    /**
-     * The function sets the right child of a node and updates the parent reference of the child.
-     * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be a
-     * `NODE` object or `undefined`.
-     */
     set right(v) {
       if (v) {
         v.parent = this;
@@ -9303,12 +9328,13 @@ var dataStructureTyped = (() => {
   };
   var BST = class _BST extends BinaryTree {
     /**
-     * This is the constructor function for a Binary Search Tree class in TypeScript.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` 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.
+     * This TypeScript constructor initializes a binary search tree with optional options and adds
+     * elements if provided.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain elements of type `BTNRep<K, V, BSTNode<K, V>>` or `R`. It is used to
+     * initialize the binary search tree with keys, nodes, entries, or raw data.
+     * @param [options] - The `options` parameter is an optional object that can contain the following
+     * properties:
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
@@ -9340,33 +9366,36 @@ var dataStructureTyped = (() => {
       }
       if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
     }
-    /**
-     * The function returns the root node of a tree structure.
-     * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
-     */
     get root() {
       return this._root;
     }
-    /**
-     * The above function is a getter method in TypeScript that returns the value of the private property
-     * `_isReverse`.
-     * @returns The `isReverse` property of the object, which is a boolean value.
-     */
     get isReverse() {
       return this._isReverse;
     }
+    get comparator() {
+      return this._comparator;
+    }
+    get specifyComparable() {
+      return this._specifyComparable;
+    }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * 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
      * 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 BSTNode class, casted as the NODE type.
+     * @returns The method is returning a new instance of the BSTNode class, casted as the BSTNode<K, V> type.
      */
     createNode(key, value) {
       return new BSTNode(key, this._isMapMode ? void 0 : value);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new binary search tree with the specified options.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
      * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which has the
@@ -9382,28 +9411,14 @@ var dataStructureTyped = (() => {
         isReverse: this._isReverse
       }, options));
     }
-    /**
-     * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
-     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
-     * element.
-     * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
-     * value associated with a key in a key-value pair.
-     * @returns either a NODE object or undefined.
-     */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
-      const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
-      if (node === null) return [void 0, void 0];
-      return [node, value != null ? value : entryValue];
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can accept a value of type `R`, which represents the key, node,
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept a value of type `R`, which represents the key, node,
      * entry, or raw element that needs to be ensured in the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
      * parameter that specifies the type of iteration to be used when ensuring a node. It has a default
@@ -9411,44 +9426,50 @@ var dataStructureTyped = (() => {
      * @returns The method is returning either the node that was ensured or `undefined` if the node could
      * not be ensured.
      */
-    ensureNode(keyNodeEntryOrRaw, iterationType = this.iterationType) {
+    ensureNode(keyNodeOrEntry, iterationType = this.iterationType) {
       var _a;
-      return (_a = super.ensureNode(keyNodeEntryOrRaw, iterationType)) != null ? _a : void 0;
+      return (_a = super.ensureNode(keyNodeOrEntry, iterationType)) != null ? _a : void 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, BSTNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `BSTNode` class.
      */
-    isNode(keyNodeEntryOrRaw) {
-      return keyNodeEntryOrRaw instanceof BSTNode;
+    isNode(keyNodeOrEntry) {
+      return keyNodeOrEntry instanceof BSTNode;
     }
     /**
-     * The function "override isKey" checks if a key is comparable based on a given comparator.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function "override isValidKey" checks if a key is comparable based on a given comparator.
      * @param {any} key - The `key` parameter is a value that will be checked to determine if it is of
      * type `K`.
-     * @returns The `override isKey(key: any): key is K` function is returning a boolean value based on
+     * @returns The `override isValidKey(key: any): key is K` function is returning a boolean value based on
      * the result of the `isComparable` function with the condition `this._compare !==
      * this._DEFAULT_COMPARATOR`.
      */
-    isKey(key) {
+    isValidKey(key) {
       return isComparable(key, this._specifyComparable !== void 0);
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept a value of type `R` or `BTNRep<K, V, BSTNode<K, V>>`.
      * @param {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(keyNodeEntryOrRaw, value) {
-      const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    add(keyNodeOrEntry, value) {
+      const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
       if (newNode === void 0) return false;
       if (this._root === void 0) {
         this._setRoot(newNode);
@@ -9510,8 +9531,9 @@ var dataStructureTyped = (() => {
         valuesIterator = values[Symbol.iterator]();
       }
       if (!isBalanceAdd) {
-        for (const kve of keysNodesEntriesOrRaws) {
+        for (let kve of keysNodesEntriesOrRaws) {
           const value = valuesIterator == null ? void 0 : valuesIterator.next().value;
+          if (this.isRaw(kve)) kve = this._toEntryFn(kve);
           inserted.push(this.add(kve, value));
         }
         return inserted;
@@ -9525,18 +9547,16 @@ var dataStructureTyped = (() => {
       let sorted = [];
       sorted = realBTNExemplars.sort(({ key: a }, { key: b }) => {
         let keyA, keyB;
-        if (this.isEntry(a)) keyA = a[0];
+        if (this.isRaw(a)) keyA = this._toEntryFn(a)[0];
+        else if (this.isEntry(a)) keyA = a[0];
         else if (this.isRealNode(a)) keyA = a.key;
-        else if (this._toEntryFn) {
-          keyA = this._toEntryFn(a)[0];
-        } else {
+        else {
           keyA = a;
         }
-        if (this.isEntry(b)) keyB = b[0];
+        if (this.isRaw(b)) keyB = this._toEntryFn(b)[0];
+        else if (this.isEntry(b)) keyB = b[0];
         else if (this.isRealNode(b)) keyB = b.key;
-        else if (this._toEntryFn) {
-          keyB = this._toEntryFn(b)[0];
-        } else {
+        else {
           keyB = b;
         }
         if (keyA !== void 0 && keyA !== null && keyB !== void 0 && keyB !== null) {
@@ -9545,14 +9565,22 @@ var dataStructureTyped = (() => {
         return 0;
       });
       const _dfs = (arr) => {
+        var _a;
         if (arr.length === 0) return;
         const mid = Math.floor((arr.length - 1) / 2);
-        const { key, value, orgIndex } = arr[mid];
+        let { key, value } = arr[mid];
+        const { orgIndex } = arr[mid];
+        if (this.isRaw(key)) {
+          const entry = this._toEntryFn(key);
+          key = entry[0];
+          value = (_a = entry[1]) != null ? _a : value;
+        }
         inserted[orgIndex] = this.add(key, value);
         _dfs(arr.slice(0, mid));
         _dfs(arr.slice(mid + 1));
       };
       const _iterate = () => {
+        var _a;
         const n = sorted.length;
         const stack = [[0, n - 1]];
         while (stack.length > 0) {
@@ -9561,7 +9589,13 @@ var dataStructureTyped = (() => {
             const [l, r] = popped;
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
-              const { key, value, orgIndex } = sorted[m];
+              let { key, value } = sorted[m];
+              const { orgIndex } = sorted[m];
+              if (this.isRaw(key)) {
+                const entry = this._toEntryFn(key);
+                key = entry[0];
+                value = (_a = entry[1]) != null ? _a : value;
+              }
               inserted[orgIndex] = this.add(key, value);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
@@ -9582,17 +9616,17 @@ var dataStructureTyped = (() => {
      *
      * The function `search` in TypeScript overrides the search behavior in a binary tree structure based
      * on specified criteria.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
-     * `keyNodeEntryRawOrPredicate` parameter in the `override search` method can accept one of the
+     * @param {BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The
+     * `keyNodeEntryOrPredicate` parameter in the `override search` method can accept one of the
      * following types:
      * @param [onlyOne=false] - The `onlyOne` parameter is a boolean flag that determines whether the
      * search should stop after finding the first matching node. If `onlyOne` is set to `true`, the
      * search will return as soon as a matching node is found. If `onlyOne` is set to `false`, the
      * @param {C} callback - The `callback` parameter in the `override search` function is a function
      * that will be called on each node that matches the search criteria. It is of type `C`, which
-     * extends `NodeCallback<NODE>`. The callback function should accept a node of type `NODE` as its
+     * extends `NodeCallback<BSTNode<K, V>>`. The callback function should accept a node of type `BSTNode<K, V>` as its
      * argument and
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `override search`
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter in the `override search`
      * method represents the node from which the search operation will begin. It is the starting point
      * for searching within the tree data structure. The method ensures that the `startNode` is a valid
      * node before proceeding with the search operation. If the `
@@ -9604,21 +9638,21 @@ var dataStructureTyped = (() => {
      * structure based on the provided key, predicate, and other options. The search results are
      * collected in an array and returned as the output of the method.
      */
-    search(keyNodeEntryRawOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-      if (keyNodeEntryRawOrPredicate === void 0) return [];
-      if (keyNodeEntryRawOrPredicate === null) return [];
+    search(keyNodeEntryOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+      if (keyNodeEntryOrPredicate === void 0) return [];
+      if (keyNodeEntryOrPredicate === null) return [];
       startNode = this.ensureNode(startNode);
       if (!startNode) return [];
       let predicate;
-      const isRange = this.isRange(keyNodeEntryRawOrPredicate);
+      const isRange = this.isRange(keyNodeEntryOrPredicate);
       if (isRange) {
-        predicate = (node) => keyNodeEntryRawOrPredicate.isInRange(node.key, this._comparator);
+        predicate = (node) => keyNodeEntryOrPredicate.isInRange(node.key, this._comparator);
       } else {
-        predicate = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+        predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
       }
       const isToLeftByRange = (cur) => {
         if (isRange) {
-          const range = keyNodeEntryRawOrPredicate;
+          const range = keyNodeEntryOrPredicate;
           const leftS = this.isReverse ? range.high : range.low;
           const leftI = this.isReverse ? range.includeHigh : range.includeLow;
           return leftI && this._compare(cur.key, leftS) >= 0 || !leftI && this._compare(cur.key, leftS) > 0;
@@ -9627,7 +9661,7 @@ var dataStructureTyped = (() => {
       };
       const isToRightByRange = (cur) => {
         if (isRange) {
-          const range = keyNodeEntryRawOrPredicate;
+          const range = keyNodeEntryOrPredicate;
           const rightS = this.isReverse ? range.low : range.high;
           const rightI = this.isReverse ? range.includeLow : range.includeLow;
           return rightI && this._compare(cur.key, rightS) <= 0 || !rightI && this._compare(cur.key, rightS) < 0;
@@ -9645,8 +9679,8 @@ var dataStructureTyped = (() => {
           if (isRange) {
             if (this.isRealNode(cur.left) && isToLeftByRange(cur)) dfs(cur.left);
             if (this.isRealNode(cur.right) && isToRightByRange(cur)) dfs(cur.right);
-          } else if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-            const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
+          } else if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+            const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
             if (this.isRealNode(cur.left) && benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) > 0)
               dfs(cur.left);
             if (this.isRealNode(cur.right) && benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) < 0)
@@ -9668,8 +9702,8 @@ var dataStructureTyped = (() => {
           if (isRange) {
             if (this.isRealNode(cur.left) && isToLeftByRange(cur)) stack.push(cur.left);
             if (this.isRealNode(cur.right) && isToRightByRange(cur)) stack.push(cur.right);
-          } else if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-            const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
+          } else if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+            const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
             if (this.isRealNode(cur.right) && benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) < 0)
               stack.push(cur.right);
             if (this.isRealNode(cur.left) && benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) > 0)
@@ -9684,16 +9718,16 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(k + log n)
      *
      * The `rangeSearch` function searches for nodes within a specified range in a binary search tree.
      * @param {Range<K> | [K, K]} range - The `range` parameter in the `rangeSearch` function can be
      * either a `Range` object or an array of two elements representing the range boundaries.
      * @param {C} callback - The `callback` parameter in the `rangeSearch` function is a callback
      * function that is used to process each node that is found within the specified range during the
-     * search operation. It is of type `NodeCallback<NODE>`, where `NODE` is the type of nodes in the
+     * search operation. It is of type `NodeCallback<BSTNode<K, V>>`, where `BSTNode<K, V>` is the type of nodes in the
      * data structure.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `rangeSearch`
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter in the `rangeSearch`
      * function represents the node from which the search for nodes within the specified range will
      * begin. It is the starting point for the range search operation.
      * @param {IterationType} iterationType - The `iterationType` parameter in the `rangeSearch` function
@@ -9709,12 +9743,12 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
-     * This function retrieves a node based on a given keyNodeEntryRawOrPredicate within a binary search tree structure.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The `keyNodeEntryRawOrPredicate`
-     * parameter can be of type `BTNRep<K, V, NODE>`, `R`, or `NodePredicate<NODE>`.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} startNode - The `startNode` parameter in the `getNode` method
+     * This function retrieves a node based on a given keyNodeEntryOrPredicate within a binary search tree structure.
+     * @param {BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The `keyNodeEntryOrPredicate`
+     * parameter can be of type `BTNRep<K, V, BSTNode<K, V>>`, `R`, or `NodePredicate<BSTNode<K, V>>`.
+     * @param {BSTNOptKeyOrNode<K, BSTNode<K, V>>} startNode - The `startNode` parameter in the `getNode` method
      * is used to specify the starting point for searching nodes in the binary search tree. If no
      * specific starting point is provided, the default value is set to `this._root`, which is the root
      * node of the binary search tree.
@@ -9722,14 +9756,14 @@ var dataStructureTyped = (() => {
      * parameter that specifies the type of iteration to be used. It has a default value of
      * `this.iterationType`, which means it will use the iteration type defined in the class instance if
      * no value is provided when calling the method.
-     * @returns The `getNode` method is returning an optional binary search tree node (`OptNode<NODE>`).
-     * It is using the `getNodes` method to find the node based on the provided keyNodeEntryRawOrPredicate, beginning at
+     * @returns The `getNode` method is returning an optional binary search tree node (`OptNode<BSTNode<K, V>>`).
+     * It is using the `getNodes` method to find the node based on the provided keyNodeEntryOrPredicate, beginning at
      * the specified root node (`startNode`) and using the specified iteration type. The method then
      * returns the first node found or `undefined` if no node is found.
      */
-    getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+    getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
       var _a;
-      return (_a = this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0]) != null ? _a : void 0;
+      return (_a = this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0]) != null ? _a : void 0;
     }
     /**
      * Time complexity: O(n)
@@ -9743,7 +9777,7 @@ var dataStructureTyped = (() => {
      * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
      * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
      * take one of the following values:
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
      * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
      * node entry. If not specified, the default value is the root of the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
@@ -9763,7 +9797,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * visited during the breadth-first search. It should take a single argument, which is the current
      * node being visited, and it can return a value of any type.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
      * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
      * object. If no value is provided, the default value is the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -9781,9 +9815,9 @@ var dataStructureTyped = (() => {
      * The function overrides the listLevels method from the superclass and returns an array of arrays
      * containing the results of the callback function applied to each level of the tree.
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
-     * `NodeCallback<NODE>`. It represents a callback function that will be called for each node in the
+     * `NodeCallback<BSTNode<K, V>>`. It represents a callback function that will be called for each node in the
      * tree during the iteration process.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
      * point for listing the levels of the binary tree. It can be either a root node of the tree, a
      * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
      * value is provided, the root of
@@ -9807,7 +9841,7 @@ var dataStructureTyped = (() => {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
      * 0, or 1, where:
-     * @param {BTNRep<K, V, NODE> | R} targetNode - The `targetNode` parameter is the node in
+     * @param {BTNRep<K, V, BSTNode<K, V>>} 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,
@@ -9942,24 +9976,69 @@ var dataStructureTyped = (() => {
       return balanced;
     }
     /**
-     * The function returns the value of the _comparator property.
-     * @returns The `_comparator` property is being returned.
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default map behavior for a binary search tree by
+     * applying a callback function to each entry and creating a new tree with the results.
+     * @param callback - A function that will be called for each entry in the BST. It takes four
+     * arguments: the key, the value (which can be undefined), the index of the entry, and a reference to
+     * the BST itself.
+     * @param [options] - The `options` parameter in the `override map` method is of type `BSTOptions<MK,
+     * MV, MR>`. It is an optional parameter that allows you to specify additional options for the Binary
+     * Search Tree (BST) being created in the `map` method. These options could include configuration
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` method is used to specify
+     * the value of `this` that should be used when executing the `callback` function. It allows you to
+     * set the context or scope in which the callback function will be called. This can be useful when
+     * you want
+     * @returns The `map` method is returning a new Binary Search Tree (`BST`) instance with the entries
+     * transformed by the provided callback function.
      */
-    get comparator() {
-      return this._comparator;
+    map(callback, options, thisArg) {
+      const newTree = new _BST([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        newTree.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return newTree;
     }
     /**
-     * This function returns the value of the `_specifyComparable` property.
-     * @returns The method `specifyComparable()` is being returned, which is a getter method for the
-     * `_specifyComparable` property.
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+     * structure.
+     * @returns The `cloned` object is being returned.
      */
-    get specifyComparable() {
-      return this._specifyComparable;
+    clone() {
+      const cloned = this.createTree();
+      this._clone(cloned);
+      return cloned;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function overrides a method and converts a key, value pair or entry or raw element to a node.
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - A variable that can be of
+     * type R or BTNRep<K, V, BSTNode<K, V>>. It represents either a key, a node, an entry, or a raw
+     * 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 BSTNode<K, V> object or undefined.
+     */
+    _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value) {
+      const [node, entryValue] = super._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
+      if (node === null) return [void 0, void 0];
+      return [node, value != null ? value : entryValue];
     }
     /**
+     * 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 {OptNode<NODE>} v - v is a parameter of type NODE or undefined.
+     * @param {OptNode<BSTNode<K, V>>} v - v is a parameter of type BSTNode<K, V> or undefined.
      */
     _setRoot(v) {
       if (v) {
@@ -9967,17 +10046,23 @@ var dataStructureTyped = (() => {
       }
       this._root = v;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The _compare function compares two values using a specified comparator function and optionally
+     * reverses the result.
+     * @param {K} a - The parameter `a` is of type `K`, which is used as an input for comparison in the
+     * `_compare` method.
+     * @param {K} b - The parameter `b` in the `_compare` function is of type `K`.
+     * @returns The `_compare` method is returning the result of the ternary expression. If `_isReverse`
+     * is true, it returns the negation of the result of calling the `_comparator` function with
+     * arguments `a` and `b`. If `_isReverse` is false, it returns the result of calling the
+     * `_comparator` function with arguments `a` and `b`.
+     */
     _compare(a, b) {
       return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
     }
-    map(callback, options, thisArg) {
-      const newTree = new _BST([], options);
-      let index = 0;
-      for (const [key, value] of this) {
-        newTree.add(callback.call(thisArg, key, value, index++, this));
-      }
-      return newTree;
-    }
   };
 
   // src/data-structures/binary-tree/binary-indexed-tree.ts
@@ -10546,46 +10631,74 @@ var dataStructureTyped = (() => {
   // src/data-structures/binary-tree/avl-tree.ts
   var AVLTreeNode = class extends BSTNode {
     /**
-     * The constructor function initializes a new instance of a class with a key and an optional value,
-     * and sets the height property to 0.
-     * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
-     * constructor. It is used to initialize the key property of the object being created.
-     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
-     * value associated with the key in the constructor.
+     * This TypeScript constructor function initializes an instance with a key and an optional value.
+     * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
+     * within a data structure. It serves as a reference or identifier for accessing or manipulating the
+     * associated value or data.
+     * @param {V} [value] - The `value` parameter in the constructor is optional, meaning it does not
+     * have to be provided when creating an instance of the class. If a value is not provided, it will
+     * default to `undefined`.
      */
     constructor(key, value) {
       super(key, value);
+      __publicField(this, "parent");
+      __publicField(this, "_left");
+      __publicField(this, "_right");
+    }
+    get left() {
+      return this._left;
+    }
+    set left(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._left = v;
+    }
+    get right() {
+      return this._right;
+    }
+    set right(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._right = v;
     }
   };
   var AVLTree = class _AVLTree extends BST {
     /**
-     * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
-     * entries, or raw elements.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` 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` (
+     * This TypeScript constructor initializes an AVLTree with keys, nodes, entries, or raw data provided
+     * in an iterable format.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain either `BTNRep<K, V, AVLTreeNode<K, V>>` objects or `R` objects. It is
+     * used to initialize the AVLTree with key-value pairs or raw data entries. If provided
+     * @param [options] - The `options` parameter in the constructor is of type `AVLTreeOptions<K, V,
+     * R>`. It is an optional parameter that allows you to specify additional options for configuring the
+     * AVL tree. These options could include things like custom comparators, initial capacity, or any
+     * other configuration settings specific
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       if (keysNodesEntriesOrRaws) super.addMany(keysNodesEntriesOrRaws);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * 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.
+     * type AVLTreeNode<K, V>.
      */
     createNode(key, value) {
       return new AVLTreeNode(key, this._isMapMode ? void 0 : value);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new AVL tree with the specified options and returns it.
      * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
      * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
@@ -10602,49 +10715,51 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the input is an instance of AVLTreeNode.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `AVLTreeNode` class.
      */
-    isNode(keyNodeEntryOrRaw) {
-      return keyNodeEntryOrRaw instanceof AVLTreeNode;
+    isNode(keyNodeOrEntry) {
+      return keyNodeOrEntry instanceof AVLTreeNode;
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function overrides the add method of a class and inserts a key-value pair into a data
      * structure, then balances the path.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can accept values of type `R`, `BTNRep<K, V, NODE>`, or
-     * `RawElement`.
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept values of type `R`, `BTNRep<K, V, AVLTreeNode<K, V>>`
      * @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(keyNodeEntryOrRaw, value) {
-      if (keyNodeEntryOrRaw === null) return false;
-      const inserted = super.add(keyNodeEntryOrRaw, value);
-      if (inserted) this._balancePath(keyNodeEntryOrRaw);
+    add(keyNodeOrEntry, value) {
+      if (keyNodeOrEntry === null) return false;
+      const inserted = super.add(keyNodeOrEntry, value);
+      if (inserted) this._balancePath(keyNodeOrEntry);
       return inserted;
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function overrides the delete method in a TypeScript class, performs deletion, and then
      * balances the tree if necessary.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `override delete` method can be one of the following types:
      * @returns The `delete` method is being overridden in this code snippet. It first calls the `delete`
      * method from the superclass (presumably a parent class) with the provided `predicate`, which could
      * be a key, node, entry, or a custom predicate. The result of this deletion operation is stored in
      * `deletedResults`, which is an array of `BinaryTreeDeleteResult` objects.
      */
-    delete(keyNodeEntryOrRaw) {
-      const deletedResults = super.delete(keyNodeEntryOrRaw);
+    delete(keyNodeOrEntry) {
+      const deletedResults = super.delete(keyNodeOrEntry);
       for (const { needBalanced } of deletedResults) {
         if (needBalanced) {
           this._balancePath(needBalanced);
@@ -10652,6 +10767,26 @@ var dataStructureTyped = (() => {
       }
       return deletedResults;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default map behavior of an AVLTree data structure
+     * by applying a callback function to each entry and creating a new AVLTree with the results.
+     * @param callback - A function that will be called for each entry in the AVLTree. It takes four
+     * arguments: the key, the value (which can be undefined), the index of the entry, and a reference to
+     * the AVLTree itself.
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `AVLTreeOptions<MK, MV, MR>`. It is an optional parameter that allows you to specify additional
+     * options for the AVL tree being created during the mapping process. These options could include
+     * custom comparators, initial
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) within the callback function. This can be useful when you want to access
+     * properties or
+     * @returns The `map` method is returning a new AVLTree instance (`newTree`) with the entries
+     * modified by the provided callback function.
+     */
     map(callback, options, thisArg) {
       const newTree = new _AVLTree([], options);
       let index = 0;
@@ -10661,15 +10796,28 @@ var dataStructureTyped = (() => {
       return newTree;
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+     * structure.
+     * @returns A cloned tree object is being returned.
+     */
+    clone() {
+      const cloned = this.createTree();
+      this._clone(cloned);
+      return cloned;
+    }
+    /**
+     * 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 | BSTNOptKeyOrNode<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 | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter is either an instance of
-     * `R` or an instance of `BSTNOptKeyOrNode<K, NODE>`.
+     * @param {BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>} srcNode - The `srcNode` parameter represents either a node
+     * object (`AVLTreeNode<K, V>`) or a key-value pair (`R`) that is being swapped with another node.
+     * @param {BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>} destNode - The `destNode` parameter is either an instance of
+     * `R` or an instance of `BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>`.
      * @returns The method is returning the `destNodeEnsured` object if both `srcNodeEnsured` and
      * `destNodeEnsured` are truthy. Otherwise, it returns `undefined`.
      */
@@ -10697,7 +10845,7 @@ 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" is of type "NODE", which likely represents a node in a
+     * @param {AVLTreeNode<K, V>} node - The parameter "node" is of type "AVLTreeNode<K, V>", 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.
@@ -10715,7 +10863,7 @@ var dataStructureTyped = (() => {
      *
      * The function updates the height of a node in a binary tree based on the heights of its left and
      * right children.
-     * @param {NODE} node - The parameter "node" represents a node in a binary tree data structure.
+     * @param {AVLTreeNode<K, V>} node - The parameter "node" represents a node in a binary tree data structure.
      */
     _updateHeight(node) {
       if (!node.left && !node.right) node.height = 0;
@@ -10730,7 +10878,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * 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.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
     _balanceLL(A) {
       const parentOfA = A.parent;
@@ -10761,7 +10909,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
-     * @param {NODE} A - A is a node in a binary tree.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
     _balanceLR(A) {
       const parentOfA = A.parent;
@@ -10807,7 +10955,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
-     * @param {NODE} A - A is a node in a binary tree.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
     _balanceRR(A) {
       const parentOfA = A.parent;
@@ -10842,7 +10990,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
-     * @param {NODE} A - A is a node in a binary tree.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
     _balanceRL(A) {
       const parentOfA = A.parent;
@@ -10887,8 +11035,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 {BTNRep<K, V, NODE> | R} node - The `node` parameter can be of type `R` or
-     * `BTNRep<K, V, NODE>`.
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} node - The `node` parameter can be of type `R` or
+     * `BTNRep<K, V, AVLTreeNode<K, V>>`.
      */
     _balancePath(node) {
       node = this.ensureNode(node);
@@ -10925,9 +11073,9 @@ var dataStructureTyped = (() => {
      *
      * 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
+     * @param {AVLTreeNode<K, V>} 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
+     * @param {AVLTreeNode<K, V>} newNode - The `newNode` parameter is the new node that will replace the `oldNode` in
      * the data structure.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
      * superclass, with the `oldNode` and `newNode` as arguments.
@@ -10941,31 +11089,52 @@ var dataStructureTyped = (() => {
   // src/data-structures/binary-tree/red-black-tree.ts
   var RedBlackTreeNode = class extends BSTNode {
     /**
-     * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
-     * color.
-     * @param {K} key - The key parameter is of type K and represents the key of the node in the
-     * Red-Black Tree.
-     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the key in the Red-Black Tree Node. It is not required and can be omitted when
-     * creating a new instance of the Red-Black Tree Node.
-     * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
-     * Tree Node. It is an optional parameter with a default value of `'BLACK'`.
+     * The constructor initializes a node with a key, value, and color for a Red-Black Tree.
+     * @param {K} key - The `key` parameter is a key of type `K` that is used to identify the node in a
+     * Red-Black Tree data structure.
+     * @param {V} [value] - The `value` parameter in the constructor is an optional parameter of type
+     * `V`. It represents the value associated with the key in the data structure being constructed.
+     * @param {RBTNColor} [color=BLACK] - The `color` parameter in the constructor is used to specify the
+     * color of the node in a Red-Black Tree. It has a default value of 'BLACK' if not provided
+     * explicitly.
      */
     constructor(key, value, color = "BLACK") {
       super(key, value);
+      __publicField(this, "parent");
+      __publicField(this, "_left");
+      __publicField(this, "_right");
       this._color = color;
     }
+    get left() {
+      return this._left;
+    }
+    set left(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._left = v;
+    }
+    get right() {
+      return this._right;
+    }
+    set right(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._right = v;
+    }
   };
   var RedBlackTree = class _RedBlackTree extends BST {
     /**
-     * This is the constructor function for a Red-Black Tree data structure in TypeScript.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
-     * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
-     * initialize the RBTree with the provided elements.
-     * @param [options] - The `options` parameter is an optional object that can be passed to the
-     * constructor. It is of type `RedBlackTreeOptions<K, V, R>`. This object can contain various options for
-     * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
-     * depend on the implementation
+     * This TypeScript constructor initializes a Red-Black Tree with optional keys, nodes, entries, or
+     * raw data.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain either `BTNRep<K, V, RedBlackTreeNode<K, V>>` objects or `R` objects. It
+     * is used to initialize the Red-Black Tree with keys, nodes, entries, or
+     * @param [options] - The `options` parameter in the constructor is of type `RedBlackTreeOptions<K,
+     * V, R>`. It is an optional parameter that allows you to specify additional options for the
+     * RedBlackTree class. These options could include configuration settings, behavior customization, or
+     * any other parameters that are specific to
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
@@ -10975,14 +11144,13 @@ var dataStructureTyped = (() => {
         this.addMany(keysNodesEntriesOrRaws);
       }
     }
-    /**
-     * The function returns the root node of a tree or undefined if there is no root.
-     * @returns The root node of the tree structure, or undefined if there is no root node.
-     */
     get root() {
       return this._root;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * 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 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
@@ -11000,6 +11168,9 @@ var dataStructureTyped = (() => {
       return new RedBlackTreeNode(key, this._isMapMode ? void 0 : value, color);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * 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:
@@ -11018,13 +11189,13 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
+     * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `RedBlackTreeNode` class.
      */
-    isNode(keyNodeEntryOrRaw) {
-      return keyNodeEntryOrRaw instanceof RedBlackTreeNode;
+    isNode(keyNodeOrEntry) {
+      return keyNodeOrEntry instanceof RedBlackTreeNode;
     }
     /**
      * Time Complexity: O(1)
@@ -11039,12 +11210,12 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept a value of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
      * @param {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.
@@ -11052,8 +11223,8 @@ var dataStructureTyped = (() => {
      * 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(keyNodeEntryOrRaw, value) {
-      const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    add(keyNodeOrEntry, value) {
+      const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
       if (!this.isRealNode(newNode)) return false;
       const insertStatus = this._insert(newNode);
       if (insertStatus === "CREATED") {
@@ -11074,24 +11245,24 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function overrides the delete method in a binary tree data structure to remove a node based on
      * a given predicate and maintain the binary search tree properties.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
+     * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `override delete` method is used to specify the condition or key based on which a
      * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
      * function that determines which node(s) should be deleted.
-     * @returns The `override delete` method is returning an array of `BinaryTreeDeleteResult<NODE>`
+     * @returns The `override delete` method is returning an array of `BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>`
      * objects. Each object in the array contains information about the deleted node and whether
      * balancing is needed.
      */
-    delete(keyNodeEntryOrRaw) {
-      if (keyNodeEntryOrRaw === null) return [];
+    delete(keyNodeOrEntry) {
+      if (keyNodeOrEntry === null) return [];
       const results = [];
       let nodeToDelete;
-      if (this._isPredicate(keyNodeEntryOrRaw)) nodeToDelete = this.getNode(keyNodeEntryOrRaw);
-      else nodeToDelete = this.isRealNode(keyNodeEntryOrRaw) ? keyNodeEntryOrRaw : this.getNode(keyNodeEntryOrRaw);
+      if (this._isPredicate(keyNodeOrEntry)) nodeToDelete = this.getNode(keyNodeOrEntry);
+      else nodeToDelete = this.isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : this.getNode(keyNodeOrEntry);
       if (!nodeToDelete) {
         return results;
       }
@@ -11139,13 +11310,54 @@ var dataStructureTyped = (() => {
       results.push({ deleted: nodeToDelete, needBalanced: void 0 });
       return results;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
+     * applying a callback to each entry in the original tree.
+     * @param callback - A function that will be called for each entry in the tree, with parameters
+     * representing the key, value, index, and the tree itself. It should return an entry for the new
+     * tree.
+     * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
+     * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
+     * Tree that will be created during the mapping process. These options could include things like
+     * custom comparators
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function. This can be useful when you want to access properties
+     * or
+     * @returns A new Red-Black Tree is being returned, where each entry has been transformed using the
+     * provided callback function.
+     */
+    map(callback, options, thisArg) {
+      const newTree = new _RedBlackTree([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        newTree.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return newTree;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+     * structure.
+     * @returns The `cloned` object is being returned.
+     */
+    clone() {
+      const cloned = this.createTree();
+      this._clone(cloned);
+      return cloned;
+    }
     /**
      * 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.
+     * @param {RedBlackTreeNode<K, V> | undefined} v - v is a parameter of type RedBlackTreeNode<K, V> or undefined.
      */
     _setRoot(v) {
       if (v) {
@@ -11158,9 +11370,9 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * 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
+     * @param {RedBlackTreeNode<K, V>} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
      * the data structure.
-     * @param {NODE} newNode - The `newNode` parameter is of type `NODE`, which represents a node in a
+     * @param {RedBlackTreeNode<K, V>} newNode - The `newNode` parameter is of type `RedBlackTreeNode<K, V>`, 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.
@@ -11171,11 +11383,11 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * 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
+     * @param {RedBlackTreeNode<K, V>} 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
@@ -11216,9 +11428,9 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `_transplant` is used to replace a node `u` with another node `v` in a binary tree.
-     * @param {NODE} u - The parameter "u" represents a node in a binary tree.
-     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`, which means it can
-     * either be a `NODE` object or `undefined`.
+     * @param {RedBlackTreeNode<K, V>} u - The parameter "u" represents a node in a binary tree.
+     * @param {RedBlackTreeNode<K, V> | undefined} v - The parameter `v` is of type `RedBlackTreeNode<K, V> | undefined`, which means it can
+     * either be a `RedBlackTreeNode<K, V>` object or `undefined`.
      */
     _transplant(u, v) {
       if (!u.parent) {
@@ -11237,7 +11449,7 @@ 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 data
+     * @param {RedBlackTreeNode<K, V> | 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) {
@@ -11289,7 +11501,7 @@ 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 binary tree. It can
+     * @param {RedBlackTreeNode<K, V> | 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.
@@ -11354,7 +11566,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `_leftRotate` function performs a left rotation on a given node in a binary tree.
-     * @param {NODE | undefined} x - The parameter `x` is of type `NODE | undefined`. It represents a
+     * @param {RedBlackTreeNode<K, V> | undefined} x - The parameter `x` is of type `RedBlackTreeNode<K, V> | undefined`. It represents a
      * node in a binary tree or `undefined` if there is no node.
      * @returns void, which means it does not return any value.
      */
@@ -11383,7 +11595,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `_rightRotate` function performs a right rotation on a given node in a binary tree.
-     * @param {NODE | undefined} y - The parameter `y` is of type `NODE | undefined`. It represents a
+     * @param {RedBlackTreeNode<K, V> | undefined} y - The parameter `y` is of type `RedBlackTreeNode<K, V> | undefined`. It represents a
      * node in a binary tree or `undefined` if there is no node.
      * @returns void, which means it does not return any value.
      */
@@ -11407,221 +11619,606 @@ var dataStructureTyped = (() => {
       x.right = y;
       y.parent = x;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
-     * applying a callback to each entry in the original tree.
-     * @param callback - A function that will be called for each entry in the tree, with parameters
-     * representing the key, value, index, and the tree itself. It should return an entry for the new
-     * tree.
-     * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
-     * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
-     * Tree that will be created during the mapping process. These options could include things like
-     * custom comparators
-     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
-     * the value of `this` when executing the `callback` function. It allows you to set the context
-     * (value of `this`) for the callback function. This can be useful when you want to access properties
-     * or
-     * @returns A new Red-Black Tree is being returned, where each entry has been transformed using the
-     * provided callback function.
-     */
-    map(callback, options, thisArg) {
-      const newTree = new _RedBlackTree([], options);
-      let index = 0;
-      for (const [key, value] of this) {
-        newTree.add(callback.call(thisArg, key, value, index++, this));
-      }
-      return newTree;
-    }
   };
 
   // src/data-structures/binary-tree/avl-tree-multi-map.ts
   var AVLTreeMultiMapNode = class extends AVLTreeNode {
     /**
-     * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
-     * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
-     * of the binary tree node.
-     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
-     * tree node. If no value is provided, it will be `undefined`.
-     * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
-     * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
-     * parameter when creating a new instance of the `BinaryTreeNode` class.
+     * This TypeScript constructor initializes an object with a key of type K and an array of values of
+     * type V.
+     * @param {K} key - The `key` parameter is typically used to store a unique identifier or key for the
+     * data being stored in the data structure. It helps in quickly accessing or retrieving the
+     * associated value in the data structure.
+     * @param {V[]} value - The `value` parameter in the constructor represents an array of values of
+     * type `V`.
      */
-    constructor(key, value, count = 1) {
+    constructor(key, value) {
       super(key, value);
-      this.count = count;
+      __publicField(this, "parent");
+      __publicField(this, "_left");
+      __publicField(this, "_right");
+    }
+    get left() {
+      return this._left;
+    }
+    set left(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._left = v;
+    }
+    get right() {
+      return this._right;
+    }
+    set right(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._right = v;
     }
   };
   var AVLTreeMultiMap = class _AVLTreeMultiMap extends AVLTree {
     /**
-     * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` 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.
+     * The constructor initializes an AVLTreeMultiMap with the provided keys, nodes, entries, or raw data
+     * and options.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain either key-value pairs represented as `BTNRep<K, V[],
+     * AVLTreeMultiMapNode<K, V>>` or raw data represented as `R`. This parameter is used to initialize
+     * the AVLTreeMulti
+     * @param [options] - The `options` parameter in the constructor is of type
+     * `AVLTreeMultiMapOptions<K, V[], R>`. It is an optional parameter that allows you to specify
+     * additional options for configuring the AVLTreeMultiMap instance.
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
-      super([], options);
-      __publicField(this, "_count", 0);
-      if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
-    }
-    /**
-     * The function calculates the sum of the count property of all nodes in a tree using depth-first
-     * search.
-     * @returns the sum of the count property of all nodes in the tree.
-     */
-    get count() {
-      return this._count;
+      super([], __spreadProps(__spreadValues({}, options), { isMapMode: true }));
+      if (keysNodesEntriesOrRaws) {
+        this.addMany(keysNodesEntriesOrRaws);
+      }
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function calculates the sum of the count property of all nodes in a tree using depth-first
-     * search.
-     * @returns the sum of the count property of all nodes in the tree.
-     */
-    getComputedCount() {
-      let sum = 0;
-      this.dfs((node) => sum += node.count);
-      return sum;
-    }
-    /**
-     * 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, this._isMapMode ? void 0 : value, count);
-    }
-    /**
-     * 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. It can have the following properties:
-     * @returns a new instance of the AVLTreeMultiMap class, with the specified options, as a TREE
-     * object.
+     * The function `createTree` in TypeScript overrides the creation of an AVLTreeMultiMap with
+     * specified options.
+     * @param [options] - The `options` parameter in the `createTree` function is of type
+     * `AVLTreeMultiMapOptions<K, V[], R>`. This means it is an object that can have properties of type
+     * `K`, `V[]`, and `R`. The function creates a new `AVL
+     * @returns The `createTree` method is returning a new instance of `AVLTreeMultiMap` with the
+     * provided options.
      */
     createTree(options) {
       return new _AVLTreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
-        isMapMode: this._isMapMode,
         specifyComparable: this._specifyComparable,
         toEntryFn: this._toEntryFn,
         isReverse: this._isReverse
       }, options));
     }
     /**
-     * The function checks if the input is an instance of AVLTreeMultiMapNode.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
-     * an instance of the `AVLTreeMultiMapNode` class.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `createNode` overrides the method to create a new AVLTreeMultiMapNode with a
+     * specified key and an empty array of values.
+     * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
+     * that will be created in the AVLTreeMultiMap.
+     * @returns An AVLTreeMultiMapNode object is being returned, initialized with the provided key and an
+     * empty array.
      */
-    isNode(keyNodeEntryOrRaw) {
-      return keyNodeEntryOrRaw instanceof AVLTreeMultiMapNode;
+    createNode(key) {
+      return new AVLTreeMultiMapNode(key, []);
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
-     * The function overrides the add method of a TypeScript class to add a new node to a data structure
-     * and update the count.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyNodeEntryOrRaw` parameter can accept a value of type `R`, which can be any type. It
-     * can also accept a value of type `BTNRep<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
-     * 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.
-     */
-    add(keyNodeEntryOrRaw, value, count = 1) {
-      const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
-      if (newNode === void 0) return false;
-      const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
-      const inserted = super.add(newNode, newValue);
-      if (inserted) {
-        this._count += orgNodeCount;
+     * The function `add` in TypeScript overrides the superclass method to add key-value pairs to an AVL
+     * tree multi-map.
+     * @param {BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `override add` method can be either a key-value pair entry or just a key. If it
+     * is a key-value pair entry, it will be in the format `[key, values]`, where `key` is the key and
+     * `values`
+     * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
+     * you want to add to the AVLTreeMultiMap. It can be a single value or an array of values associated
+     * with a specific key.
+     * @returns The `override add` method is returning a boolean value, which indicates whether the
+     * addition operation was successful or not.
+     */
+    add(keyNodeOrEntry, value) {
+      if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
+      const _commonAdd = (key, values) => {
+        if (key === void 0 || key === null) return false;
+        const existingValues = this.get(key);
+        if (existingValues !== void 0 && values !== void 0) {
+          for (const value2 of values) existingValues.push(value2);
+          return true;
+        }
+        const existingNode = this.getNode(key);
+        if (this.isRealNode(existingNode)) {
+          if (existingValues === void 0) {
+            super.add(key, values);
+            return true;
+          }
+          if (values !== void 0) {
+            for (const value2 of values) existingValues.push(value2);
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return super.add(key, values);
+        }
+      };
+      if (this.isEntry(keyNodeOrEntry)) {
+        const [key, values] = keyNodeOrEntry;
+        return _commonAdd(key, value !== void 0 ? [value] : values);
       }
-      return true;
+      return _commonAdd(keyNodeOrEntry, value !== void 0 ? [value] : void 0);
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
-     * The function overrides the delete method in a binary tree data structure, handling deletion of
-     * nodes and maintaining balance in the tree.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `predicate`
-     * parameter in the `delete` method is used to specify the condition for deleting a node from the
-     * binary tree. It can be a key, node, or entry that determines which
-     * node(s) should be deleted.
-     * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
-     * boolean flag that determines whether to ignore the count of the node being deleted. If
-     * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
-     * `ignoreCount` is set to
-     * @returns The `delete` method overrides the default delete behavior in a binary tree data
-     * structure. It takes a predicate or node to be deleted and an optional flag to ignore count. The
-     * method returns an array of `BinaryTreeDeleteResult` objects, each containing information about the
-     * deleted node and whether balancing is needed in the tree.
+     * The function `deleteValue` removes a specific value from a key in an AVLTreeMultiMap data
+     * structure and deletes the entire node if no values are left for that key.
+     * @param {BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `deleteValue` function can be either a `BTNRep` object representing a key-value
+     * pair in the AVLTreeMultiMapNode, or just the key itself.
+     * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
+     * value that you want to delete from the multi-map data structure associated with a particular key.
+     * The function checks if the value exists in the array of values associated with the key, and if
+     * found, removes it from the array.
+     * @returns The `deleteValue` function returns a boolean value. It returns `true` if the specified
+     * `value` was successfully deleted from the array of values associated with the `keyNodeOrEntry`. If
+     * the value was not found in the array, it returns `false`.
+     */
+    deleteValue(keyNodeOrEntry, value) {
+      const values = this.get(keyNodeOrEntry);
+      if (Array.isArray(values)) {
+        const index = values.indexOf(value);
+        if (index === -1) return false;
+        values.splice(index, 1);
+        if (values.length === 0) this.delete(keyNodeOrEntry);
+        return true;
+      }
+      return false;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+     * structure.
+     * @returns A cloned tree object is being returned.
      */
-    delete(keyNodeEntryOrRaw, ignoreCount = false) {
-      var _a;
-      const deletedResult = [];
-      if (!this.root) return deletedResult;
-      const curr = (_a = this.getNode(keyNodeEntryOrRaw)) != null ? _a : void 0;
-      if (!curr) return deletedResult;
-      const parent = (curr == null ? void 0 : curr.parent) ? curr.parent : void 0;
-      let needBalanced = void 0, orgCurrent = curr;
-      if (curr.count > 1 && !ignoreCount) {
-        curr.count--;
-        this._count--;
-      } else {
-        if (!curr.left) {
-          if (!parent) {
-            if (curr.right !== void 0 && curr.right !== null) this._setRoot(curr.right);
+    clone() {
+      const cloned = this.createTree();
+      this._clone(cloned);
+      return cloned;
+    }
+  };
+
+  // src/data-structures/binary-tree/tree-multi-map.ts
+  var TreeMultiMapNode = class extends RedBlackTreeNode {
+    /**
+     * This TypeScript constructor initializes an object with a key of type K and an array of values of
+     * type V.
+     * @param {K} key - The `key` parameter is typically used to store a unique identifier or key for the
+     * data being stored in the data structure. It helps in quickly accessing or retrieving the
+     * associated value in the data structure.
+     * @param {V[]} value - The `value` parameter in the constructor represents an array of values of
+     * type `V`.
+     */
+    constructor(key, value) {
+      super(key, value);
+      __publicField(this, "parent");
+      __publicField(this, "_left");
+      __publicField(this, "_right");
+    }
+    get left() {
+      return this._left;
+    }
+    set left(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._left = v;
+    }
+    get right() {
+      return this._right;
+    }
+    set right(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._right = v;
+    }
+  };
+  var TreeMultiMap = class _TreeMultiMap extends RedBlackTree {
+    /**
+     * The constructor initializes an TreeMultiMap with the provided keys, nodes, entries, or raw data
+     * and options.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain either key-value pairs represented as `BTNRep<K, V[],
+     * TreeMultiMapNode<K, V>>` or raw data represented as `R`. This parameter is used to initialize
+     * the RedBlackTreeMulti
+     * @param [options] - The `options` parameter in the constructor is of type
+     * `TreeMultiMapOptions<K, V[], R>`. It is an optional parameter that allows you to specify
+     * additional options for configuring the TreeMultiMap instance.
+     */
+    constructor(keysNodesEntriesOrRaws = [], options) {
+      super([], __spreadProps(__spreadValues({}, options), { isMapMode: true }));
+      if (keysNodesEntriesOrRaws) {
+        this.addMany(keysNodesEntriesOrRaws);
+      }
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `createTree` function in TypeScript overrides the default implementation to create a new
+     * TreeMultiMap with specified options.
+     * @param [options] - The `options` parameter in the `createTree` method is of type
+     * `TreeMultiMapOptions<K, V[], R>`. This parameter allows you to pass additional configuration
+     * options when creating a new `TreeMultiMap` instance. It includes properties such as
+     * `iterationType`, `specifyComparable
+     * @returns A new instance of `TreeMultiMap` is being returned, with an empty array as the initial
+     * data and the provided options merged with the existing properties of the current object.
+     */
+    createTree(options) {
+      return new _TreeMultiMap([], __spreadValues({
+        iterationType: this.iterationType,
+        specifyComparable: this._specifyComparable,
+        toEntryFn: this._toEntryFn,
+        isReverse: this._isReverse
+      }, options));
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `createNode` overrides the method to create a new `TreeMultiMapNode` with a specified
+     * key and an empty array of values.
+     * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
+     * that will be created in the TreeMultiMap data structure.
+     * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned, with the specified key and
+     * an empty array as its value.
+     */
+    createNode(key) {
+      return new TreeMultiMapNode(key, []);
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     *
+     * The function `add` in TypeScript overrides the superclass method to add key-value pairs to a
+     * TreeMultiMapNode, handling different input types and scenarios.
+     * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `override add` method can be either a `BTNRep` object containing a key, an array
+     * of values, and a `TreeMultiMapNode`, or just a key.
+     * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
+     * you want to add to the TreeMultiMap. If the key is already present in the map, the new value will
+     * be added to the existing list of values associated with that key. If the key is not present,
+     * @returns The `add` method is returning a boolean value, which indicates whether the operation was
+     * successful or not.
+     */
+    add(keyNodeOrEntry, value) {
+      if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
+      const _commonAdd = (key, values) => {
+        if (key === void 0 || key === null) return false;
+        const existingValues = this.get(key);
+        if (existingValues !== void 0 && values !== void 0) {
+          for (const value2 of values) existingValues.push(value2);
+          return true;
+        }
+        const existingNode = this.getNode(key);
+        if (this.isRealNode(existingNode)) {
+          if (existingValues === void 0) {
+            super.add(key, values);
+            return true;
+          }
+          if (values !== void 0) {
+            for (const value2 of values) existingValues.push(value2);
+            return true;
           } else {
-            const { familyPosition: fp } = curr;
-            if (fp === "LEFT" || fp === "ROOT_LEFT") {
-              parent.left = curr.right;
-            } else if (fp === "RIGHT" || fp === "ROOT_RIGHT") {
-              parent.right = curr.right;
-            }
-            needBalanced = parent;
+            return false;
           }
         } else {
-          const leftSubTreeRightMost = curr.left ? this.getRightMost((node) => node, curr.left) : void 0;
-          if (leftSubTreeRightMost) {
-            const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-            orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
-            if (parentOfLeftSubTreeMax) {
-              if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
-                parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
-              } else {
-                parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+          return super.add(key, values);
+        }
+      };
+      if (this.isEntry(keyNodeOrEntry)) {
+        const [key, values] = keyNodeOrEntry;
+        return _commonAdd(key, value !== void 0 ? [value] : values);
+      }
+      return _commonAdd(keyNodeOrEntry, value !== void 0 ? [value] : void 0);
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     *
+     * The function `deleteValue` removes a specific value from a key in a TreeMultiMap data structure
+     * and deletes the entire node if no values are left for that key.
+     * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `deleteValue` function can be either a `BTNRep` object containing a key and an
+     * array of values, or just a key itself.
+     * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
+     * value that you want to remove from the multi-map data structure associated with a particular key.
+     * The function checks if the value exists in the array of values associated with the key, and if
+     * found, removes it from the array.
+     * @returns The `deleteValue` function returns a boolean value - `true` if the specified `value` was
+     * successfully deleted from the values associated with the `keyNodeOrEntry`, and `false` otherwise.
+     */
+    deleteValue(keyNodeOrEntry, value) {
+      const values = this.get(keyNodeOrEntry);
+      if (Array.isArray(values)) {
+        const index = values.indexOf(value);
+        if (index === -1) return false;
+        values.splice(index, 1);
+        if (values.length === 0) this.delete(keyNodeOrEntry);
+        return true;
+      }
+      return false;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+     * structure.
+     * @returns The `cloned` object is being returned.
+     */
+    clone() {
+      const cloned = this.createTree();
+      this._clone(cloned);
+      return cloned;
+    }
+  };
+
+  // src/data-structures/binary-tree/tree-counter.ts
+  var TreeCounterNode = class extends RedBlackTreeNode {
+    /**
+     * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
+     * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
+     * used to identify and locate the node within the tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
+     * creating a new node.
+     * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
+     * in the Red-Black Tree. It is an optional parameter with a default value of 1.
+     * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
+     * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
+     */
+    constructor(key, value, count = 1, color = "BLACK") {
+      super(key, value, color);
+      __publicField(this, "parent");
+      __publicField(this, "_left");
+      __publicField(this, "_right");
+      this.count = count;
+    }
+    get left() {
+      return this._left;
+    }
+    set left(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._left = v;
+    }
+    get right() {
+      return this._right;
+    }
+    set right(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._right = v;
+    }
+  };
+  var TreeCounter = class _TreeCounter extends RedBlackTree {
+    /**
+     * The constructor function initializes a TreeCounter object with optional initial data.
+     * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
+     * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
+     * TreeCounter with initial data.
+     * @param [options] - The `options` parameter is an optional object that can be used to customize the
+     * behavior of the `TreeCounter` constructor. It can include properties such as `compareKeys` and
+     * `compareValues`, which are functions used to compare keys and values respectively.
+     */
+    constructor(keysNodesEntriesOrRaws = [], options) {
+      super([], options);
+      __publicField(this, "_count", 0);
+      if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    }
+    // 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 structure.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    get count() {
+      return this._count;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    getComputedCount() {
+      let sum = 0;
+      this.dfs((node) => sum += node.count);
+      return sum;
+    }
+    /**
+     * The function creates a new TreeCounterNode 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 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 TreeCounterNode class, casted as TreeCounterNode<K, V>.
+     */
+    createNode(key, value, color = "BLACK", count) {
+      return new TreeCounterNode(key, this._isMapMode ? void 0 : value, count, color);
+    }
+    /**
+     * The function creates a new instance of a TreeCounter with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `TreeCounter`. It is of type `TreeCounterOptions<K, V,
+     * R>`.
+     * @returns a new instance of the `TreeCounter` class, with the provided options merged with the
+     * existing `iterationType` property. The returned value is casted as `TREE`.
+     */
+    createTree(options) {
+      return new _TreeCounter([], __spreadValues({
+        iterationType: this.iterationType,
+        specifyComparable: this._specifyComparable,
+        isMapMode: this._isMapMode,
+        toEntryFn: this._toEntryFn
+      }, options));
+    }
+    /**
+     * The function checks if the input is an instance of the TreeCounterNode class.
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
+     * an instance of the `TreeCounterNode` class.
+     */
+    isNode(keyNodeOrEntry) {
+      return keyNodeOrEntry instanceof TreeCounterNode;
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function overrides the add method of a class and adds a new node to a data structure, updating
+     * the count and returning a boolean indicating success.
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The
+     * `keyNodeOrEntry` parameter can accept one of the following types:
+     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+     * data structure. It is an optional parameter, so it can be omitted if not needed.
+     * @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 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(keyNodeOrEntry, value, count = 1) {
+      const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
+      const orgCount = (newNode == null ? void 0 : newNode.count) || 0;
+      const isSuccessAdded = super.add(newNode, newValue);
+      if (isSuccessAdded) {
+        this._count += orgCount;
+        return true;
+      } else {
+        return false;
+      }
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
+     * structure, handling cases where nodes have children and maintaining balance in the tree.
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
+     * parameter in the `delete` method is used to specify the condition or key based on which a node
+     * should be deleted from the binary tree. It can be a key, a node, or an entry.
+     * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
+     * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
+     * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
+     * `ignoreCount` is `false
+     * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<TreeCounterNode<K, V>>` objects.
+     */
+    delete(keyNodeOrEntry, ignoreCount = false) {
+      if (keyNodeOrEntry === null) return [];
+      const results = [];
+      let nodeToDelete;
+      if (this._isPredicate(keyNodeOrEntry)) nodeToDelete = this.getNode(keyNodeOrEntry);
+      else nodeToDelete = this.isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : this.getNode(keyNodeOrEntry);
+      if (!nodeToDelete) {
+        return results;
+      }
+      let originalColor = nodeToDelete.color;
+      let replacementNode;
+      if (!this.isRealNode(nodeToDelete.left)) {
+        if (nodeToDelete.right !== null) replacementNode = nodeToDelete.right;
+        if (ignoreCount || nodeToDelete.count <= 1) {
+          if (nodeToDelete.right !== null) {
+            this._transplant(nodeToDelete, nodeToDelete.right);
+            this._count -= nodeToDelete.count;
+          }
+        } else {
+          nodeToDelete.count--;
+          this._count--;
+          results.push({ deleted: nodeToDelete, needBalanced: void 0 });
+          return results;
+        }
+      } else if (!this.isRealNode(nodeToDelete.right)) {
+        replacementNode = nodeToDelete.left;
+        if (ignoreCount || nodeToDelete.count <= 1) {
+          this._transplant(nodeToDelete, nodeToDelete.left);
+          this._count -= nodeToDelete.count;
+        } else {
+          nodeToDelete.count--;
+          this._count--;
+          results.push({ deleted: nodeToDelete, needBalanced: void 0 });
+          return results;
+        }
+      } else {
+        const successor = this.getLeftMost((node) => node, nodeToDelete.right);
+        if (successor) {
+          originalColor = successor.color;
+          if (successor.right !== null) replacementNode = successor.right;
+          if (successor.parent === nodeToDelete) {
+            if (this.isRealNode(replacementNode)) {
+              replacementNode.parent = successor;
+            }
+          } else {
+            if (ignoreCount || nodeToDelete.count <= 1) {
+              if (successor.right !== null) {
+                this._transplant(successor, successor.right);
+                this._count -= nodeToDelete.count;
               }
-              needBalanced = parentOfLeftSubTreeMax;
+            } else {
+              nodeToDelete.count--;
+              this._count--;
+              results.push({ deleted: nodeToDelete, needBalanced: void 0 });
+              return results;
+            }
+            successor.right = nodeToDelete.right;
+            if (this.isRealNode(successor.right)) {
+              successor.right.parent = successor;
             }
           }
+          if (ignoreCount || nodeToDelete.count <= 1) {
+            this._transplant(nodeToDelete, successor);
+            this._count -= nodeToDelete.count;
+          } else {
+            nodeToDelete.count--;
+            this._count--;
+            results.push({ deleted: nodeToDelete, needBalanced: void 0 });
+            return results;
+          }
+          successor.left = nodeToDelete.left;
+          if (this.isRealNode(successor.left)) {
+            successor.left.parent = successor;
+          }
+          successor.color = nodeToDelete.color;
         }
-        this._size = this._size - 1;
-        if (orgCurrent) this._count -= orgCurrent.count;
       }
-      deletedResult.push({ deleted: orgCurrent, needBalanced });
-      if (needBalanced) {
-        this._balancePath(needBalanced);
+      this._size--;
+      if (originalColor === "BLACK") {
+        this._deleteFixup(replacementNode);
       }
-      return deletedResult;
+      results.push({ deleted: nodeToDelete, needBalanced: void 0 });
+      return results;
     }
     /**
      * Time Complexity: O(1)
@@ -11637,12 +12234,13 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(log n)
+     *
      * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
      * tree using either a recursive or iterative approach.
      * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
      * 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.
+     * 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.
      */
@@ -11690,31 +12288,27 @@ var dataStructureTyped = (() => {
      */
     clone() {
       const cloned = this.createTree();
-      if (this._isMapMode) this.bfs((node) => cloned.add(node.key, void 0, node.count));
-      else this.bfs((node) => cloned.add(node.key, node.value, node.count));
+      this.bfs((node) => cloned.add(node.key, void 0, node.count));
       if (this._isMapMode) cloned._store = this._store;
       return cloned;
     }
     /**
-     * The `map` function in TypeScript overrides the default behavior to create a new AVLTreeMultiMap
-     * with modified entries based on a provided callback.
+     * The `map` function in TypeScript overrides the default behavior to create a new TreeCounter with
+     * modified entries based on a provided callback.
      * @param callback - The `callback` parameter is a function that will be called for each entry in the
-     * AVLTreeMultiMap. It takes four arguments:
+     * map. It takes four arguments:
      * @param [options] - The `options` parameter in the `override map` function is of type
-     * `AVLTreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional
-     * configuration options when creating a new `AVLTreeMultiMap` instance within the `map` function.
-     * These options
+     * `TreeCounterOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
+     * options when creating a new `TreeCounter` instance within the `map` function. These options could
+     * include things like
      * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
      * the value of `this` when executing the `callback` function. It allows you to set the context
-     * (value of `this`) for the callback function. This can be useful when you want to access properties
-     * or
-     * @returns The `map` method is returning a new `AVLTreeMultiMap` instance with the entries
-     * transformed by the provided `callback` function. Each entry in the original tree is passed to the
-     * `callback` function along with the index and the original tree itself. The transformed entries are
-     * then added to the new `AVLTreeMultiMap` instance, which is returned at the end.
+     * (value of `this`) for the callback function when it is called within the `map` function. This
+     * @returns A new TreeCounter instance is being returned, which is populated with entries generated
+     * by the provided callback function.
      */
     map(callback, options, thisArg) {
-      const newTree = new _AVLTreeMultiMap([], options);
+      const newTree = new _TreeCounter([], options);
       let index = 0;
       for (const [key, value] of this) {
         newTree.add(callback.call(thisArg, key, value, index++, this));
@@ -11722,63 +12316,58 @@ var dataStructureTyped = (() => {
       return newTree;
     }
     /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
-     * a node object.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyNodeEntryOrRaw` parameter can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `override` function. It represents the value associated with the key in the data structure. If no
-     * value is provided, it will default to `undefined`.
+     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
+     * node based on the input.
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+     * @param {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.
+     * @returns either a TreeCounterNode<K, V> object or undefined.
      */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
-      if (keyNodeEntryOrRaw === void 0 || keyNodeEntryOrRaw === null) return [void 0, void 0];
-      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
-      if (this.isEntry(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = keyNodeEntryOrRaw;
+    _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count = 1) {
+      if (keyNodeOrEntry === void 0 || keyNodeOrEntry === null) return [void 0, void 0];
+      if (this.isNode(keyNodeOrEntry)) return [keyNodeOrEntry, value];
+      if (this.isEntry(keyNodeOrEntry)) {
+        const [key, entryValue] = keyNodeOrEntry;
         if (key === void 0 || key === null) return [void 0, void 0];
         const finalValue = value != null ? value : entryValue;
-        return [this.createNode(key, finalValue, count), finalValue];
-      }
-      if (this.isRaw(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-        const finalValue = value != null ? value : entryValue;
-        if (this.isKey(key)) return [this.createNode(key, finalValue, count), finalValue];
+        return [this.createNode(key, finalValue, "BLACK", count), finalValue];
       }
-      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, count), value];
-      return [void 0, void 0];
+      return [this.createNode(keyNodeOrEntry, value, "BLACK", count), value];
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `_swapProperties` function swaps the properties (key, value, count, height) between two nodes
+     * The `_swapProperties` function swaps the properties (key, value, count, color) between two nodes
      * in a binary search tree.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
-     * that will be swapped with the `destNode`.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+     * @param {R | BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>} 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 `BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>` class.
+     * @param {R | BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>} 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`.
+     * If either `srcNode` or `destNode` is undefined, it returns undefined.
      */
     _swapProperties(srcNode, destNode) {
       srcNode = this.ensureNode(srcNode);
       destNode = this.ensureNode(destNode);
       if (srcNode && destNode) {
-        const { key, value, count, height } = destNode;
-        const tempNode = this.createNode(key, value, count);
+        const { key, value, count, color } = destNode;
+        const tempNode = this.createNode(key, value, color, count);
         if (tempNode) {
-          tempNode.height = height;
+          tempNode.color = color;
           destNode.key = srcNode.key;
           if (!this._isMapMode) destNode.value = srcNode.value;
           destNode.count = srcNode.count;
-          destNode.height = srcNode.height;
+          destNode.color = srcNode.color;
           srcNode.key = tempNode.key;
           if (!this._isMapMode) srcNode.value = tempNode.value;
           srcNode.count = tempNode.count;
-          srcNode.height = tempNode.height;
+          srcNode.color = tempNode.color;
         }
         return destNode;
       }
@@ -11789,11 +12378,11 @@ var dataStructureTyped = (() => {
      * 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 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.
+     * @param {TreeCounterNode<K, V>} oldNode - The `oldNode` parameter is the node that you want to replace in the data
+     * structure.
+     * @param {TreeCounterNode<K, V>} newNode - The `newNode` parameter is an instance of the `TreeCounterNode<K, V>` class.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
-     * superclass, which is of type `NODE`.
+     * superclass, which is of type `TreeCounterNode<K, V>`.
      */
     _replaceNode(oldNode, newNode) {
       newNode.count = oldNode.count + newNode.count;
@@ -11801,43 +12390,61 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/data-structures/binary-tree/tree-multi-map.ts
-  var TreeMultiMapNode = class extends RedBlackTreeNode {
+  // src/data-structures/binary-tree/avl-tree-counter.ts
+  var AVLTreeCounterNode = class extends AVLTreeNode {
     /**
-     * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
-     * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
-     * used to identify and locate the node within the tree.
-     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
-     * creating a new node.
-     * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
-     * in the Red-Black Tree. It is an optional parameter with a default value of 1.
-     * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
-     * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
+     * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
+     * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
+     * of the binary tree node.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
+     * tree node. If no value is provided, it will be `undefined`.
+     * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
+     * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
+     * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
-    constructor(key, value, count = 1, color = "BLACK") {
-      super(key, value, color);
+    constructor(key, value, count = 1) {
+      super(key, value);
+      __publicField(this, "parent");
+      __publicField(this, "_left");
+      __publicField(this, "_right");
       this.count = count;
     }
+    get left() {
+      return this._left;
+    }
+    set left(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._left = v;
+    }
+    get right() {
+      return this._right;
+    }
+    set right(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._right = v;
+    }
   };
-  var TreeMultiMap = class _TreeMultiMap extends RedBlackTree {
+  var AVLTreeCounter = class _AVLTreeCounter extends AVLTree {
     /**
-     * The constructor function initializes a TreeMultiMap object with optional initial data.
-     * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
-     * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
-     * TreeMultiMap with initial data.
+     * The constructor initializes a new AVLTreeCounter object with optional initial elements.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` 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 `TreeMultiMap` constructor. It can include properties such as `compareKeys` and
-     * `compareValues`, which are functions used to compare keys and values respectively.
+     * behavior of the AVLTreeCounter. It can include properties such as `compareKeys` and
+     * `compareValues` functions to define custom comparison logic for keys and values, respectively.
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
       if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
     }
-    // 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 structure.
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count() {
@@ -11857,201 +12464,138 @@ var dataStructureTyped = (() => {
       return sum;
     }
     /**
-     * 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 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, casted as NODE.
+     * The function creates a new AVLTreeCounterNode 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 AVLTreeCounterNode. 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 AVLTreeCounterNode class, casted as AVLTreeCounterNode<K, V>.
      */
-    createNode(key, value, color = "BLACK", count) {
-      return new TreeMultiMapNode(key, this._isMapMode ? void 0 : value, count, color);
+    createNode(key, value, count) {
+      return new AVLTreeCounterNode(key, this._isMapMode ? void 0 : value, count);
     }
     /**
-     * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
+     * The function creates a new AVLTreeCounter 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 `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` property. The returned value is casted as `TREE`.
+     * configuration options for creating the AVLTreeCounter. It can have the following properties:
+     * @returns a new instance of the AVLTreeCounter class, with the specified options, as a TREE
+     * object.
      */
     createTree(options) {
-      return new _TreeMultiMap([], __spreadValues({
+      return new _AVLTreeCounter([], __spreadValues({
         iterationType: this.iterationType,
         isMapMode: this._isMapMode,
         specifyComparable: this._specifyComparable,
-        toEntryFn: this._toEntryFn
+        toEntryFn: this._toEntryFn,
+        isReverse: this._isReverse
       }, options));
     }
     /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
-     * node based on the input.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @param {V} [value] - The `value` parameter is an optional value that represents the value
-     * associated with the key in the node. It is used when creating a new node or updating the value of
-     * an existing node.
-     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
-     * @returns either a NODE object or undefined.
-     */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
-      if (keyNodeEntryOrRaw === void 0 || keyNodeEntryOrRaw === null) return [void 0, void 0];
-      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
-      if (this.isEntry(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = keyNodeEntryOrRaw;
-        if (key === void 0 || key === null) return [void 0, void 0];
-        const finalValue = value != null ? value : entryValue;
-        if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
-      }
-      if (this.isRaw(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-        const finalValue = value != null ? value : entryValue;
-        if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
-      }
-      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, "BLACK", count), value];
-      return [void 0, void 0];
-    }
-    /**
-     * The function checks if the input is an instance of the TreeMultiMapNode class.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
-     * an instance of the `TreeMultiMapNode` class.
+     * The function checks if the input is an instance of AVLTreeCounterNode.
+     * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeCounterNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
+     * an instance of the `AVLTreeCounterNode` class.
      */
-    isNode(keyNodeEntryOrRaw) {
-      return keyNodeEntryOrRaw instanceof TreeMultiMapNode;
+    isNode(keyNodeOrEntry) {
+      return keyNodeOrEntry instanceof AVLTreeCounterNode;
     }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function overrides the add method of a class and adds a new node to a data structure, updating
-     * the count and returning a boolean indicating success.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyNodeEntryOrRaw` parameter can accept one of the following types:
+     * The function overrides the add method of a TypeScript class to add a new node to a data structure
+     * and update the count.
+     * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The
+     * `keyNodeOrEntry` parameter can accept a value of type `R`, which can be any type. It
+     * can also accept a value of type `BTNRep<K, V, AVLTreeCounterNode<K, V>>`, which represents a key, node,
+     * entry, or raw element
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
      * @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 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.
+     * 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(keyNodeEntryOrRaw, value, count = 1) {
-      const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
-      const orgCount = (newNode == null ? void 0 : newNode.count) || 0;
-      const isSuccessAdded = super.add(newNode, newValue);
-      if (isSuccessAdded) {
-        this._count += orgCount;
-        return true;
-      } else {
-        return false;
+    add(keyNodeOrEntry, value, count = 1) {
+      const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
+      if (newNode === void 0) return false;
+      const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
+      const inserted = super.add(newNode, newValue);
+      if (inserted) {
+        this._count += orgNodeCount;
       }
+      return true;
     }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
-     * structure, handling cases where nodes have children and maintaining balance in the tree.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `predicate`
-     * parameter in the `delete` method is used to specify the condition or key based on which a node
-     * should be deleted from the binary tree. It can be a key, a node, or an entry.
+     * The function overrides the delete method in a binary tree data structure, handling deletion of
+     * nodes and maintaining balance in the tree.
+     * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
+     * parameter in the `delete` method is used to specify the condition for deleting a node from the
+     * binary tree. It can be a key, node, or entry that determines which
+     * node(s) should be deleted.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
-     * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
+     * boolean flag that determines whether to ignore the count of the node being deleted. If
      * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
-     * `ignoreCount` is `false
-     * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
+     * `ignoreCount` is set to
+     * @returns The `delete` method overrides the default delete behavior in a binary tree data
+     * structure. It takes a predicate or node to be deleted and an optional flag to ignore count. The
+     * method returns an array of `BinaryTreeDeleteResult` objects, each containing information about the
+     * deleted node and whether balancing is needed in the tree.
      */
-    delete(keyNodeEntryOrRaw, ignoreCount = false) {
-      if (keyNodeEntryOrRaw === null) return [];
-      const results = [];
-      let nodeToDelete;
-      if (this._isPredicate(keyNodeEntryOrRaw)) nodeToDelete = this.getNode(keyNodeEntryOrRaw);
-      else nodeToDelete = this.isRealNode(keyNodeEntryOrRaw) ? keyNodeEntryOrRaw : this.getNode(keyNodeEntryOrRaw);
-      if (!nodeToDelete) {
-        return results;
-      }
-      let originalColor = nodeToDelete.color;
-      let replacementNode;
-      if (!this.isRealNode(nodeToDelete.left)) {
-        if (nodeToDelete.right !== null) replacementNode = nodeToDelete.right;
-        if (ignoreCount || nodeToDelete.count <= 1) {
-          if (nodeToDelete.right !== null) {
-            this._transplant(nodeToDelete, nodeToDelete.right);
-            this._count -= nodeToDelete.count;
-          }
-        } else {
-          nodeToDelete.count--;
-          this._count--;
-          results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-          return results;
-        }
-      } else if (!this.isRealNode(nodeToDelete.right)) {
-        replacementNode = nodeToDelete.left;
-        if (ignoreCount || nodeToDelete.count <= 1) {
-          this._transplant(nodeToDelete, nodeToDelete.left);
-          this._count -= nodeToDelete.count;
-        } else {
-          nodeToDelete.count--;
-          this._count--;
-          results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-          return results;
-        }
+    delete(keyNodeOrEntry, ignoreCount = false) {
+      var _a;
+      const deletedResult = [];
+      if (!this.root) return deletedResult;
+      const curr = (_a = this.getNode(keyNodeOrEntry)) != null ? _a : void 0;
+      if (!curr) return deletedResult;
+      const parent = (curr == null ? void 0 : curr.parent) ? curr.parent : void 0;
+      let needBalanced = void 0, orgCurrent = curr;
+      if (curr.count > 1 && !ignoreCount) {
+        curr.count--;
+        this._count--;
       } else {
-        const successor = this.getLeftMost((node) => node, nodeToDelete.right);
-        if (successor) {
-          originalColor = successor.color;
-          if (successor.right !== null) replacementNode = successor.right;
-          if (successor.parent === nodeToDelete) {
-            if (this.isRealNode(replacementNode)) {
-              replacementNode.parent = successor;
-            }
+        if (!curr.left) {
+          if (!parent) {
+            if (curr.right !== void 0 && curr.right !== null) this._setRoot(curr.right);
           } else {
-            if (ignoreCount || nodeToDelete.count <= 1) {
-              if (successor.right !== null) {
-                this._transplant(successor, successor.right);
-                this._count -= nodeToDelete.count;
-              }
-            } else {
-              nodeToDelete.count--;
-              this._count--;
-              results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-              return results;
-            }
-            successor.right = nodeToDelete.right;
-            if (this.isRealNode(successor.right)) {
-              successor.right.parent = successor;
+            const { familyPosition: fp } = curr;
+            if (fp === "LEFT" || fp === "ROOT_LEFT") {
+              parent.left = curr.right;
+            } else if (fp === "RIGHT" || fp === "ROOT_RIGHT") {
+              parent.right = curr.right;
             }
+            needBalanced = parent;
           }
-          if (ignoreCount || nodeToDelete.count <= 1) {
-            this._transplant(nodeToDelete, successor);
-            this._count -= nodeToDelete.count;
-          } else {
-            nodeToDelete.count--;
-            this._count--;
-            results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-            return results;
-          }
-          successor.left = nodeToDelete.left;
-          if (this.isRealNode(successor.left)) {
-            successor.left.parent = successor;
+        } else {
+          const leftSubTreeRightMost = curr.left ? this.getRightMost((node) => node, curr.left) : void 0;
+          if (leftSubTreeRightMost) {
+            const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+            orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
+            if (parentOfLeftSubTreeMax) {
+              if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
+                parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+              } else {
+                parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+              }
+              needBalanced = parentOfLeftSubTreeMax;
+            }
           }
-          successor.color = nodeToDelete.color;
         }
+        this._size = this._size - 1;
+        if (orgCurrent) this._count -= orgCurrent.count;
       }
-      this._size--;
-      if (originalColor === "BLACK") {
-        this._deleteFixup(replacementNode);
+      deletedResult.push({ deleted: orgCurrent, needBalanced });
+      if (needBalanced) {
+        this._balancePath(needBalanced);
       }
-      results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-      return results;
+      return deletedResult;
     }
     /**
      * Time Complexity: O(1)
@@ -12067,13 +12611,12 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(log n)
-     *
      * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
      * tree using either a recursive or iterative approach.
      * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
      * 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.
+     * 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.
      */
@@ -12121,40 +12664,89 @@ var dataStructureTyped = (() => {
      */
     clone() {
       const cloned = this.createTree();
-      this.bfs((node) => cloned.add(node.key, void 0, node.count));
+      if (this._isMapMode) this.bfs((node) => cloned.add(node.key, void 0, node.count));
+      else this.bfs((node) => cloned.add(node.key, node.value, node.count));
       if (this._isMapMode) cloned._store = this._store;
       return cloned;
     }
+    /**
+     * The `map` function in TypeScript overrides the default behavior to create a new AVLTreeCounter
+     * with modified entries based on a provided callback.
+     * @param callback - The `callback` parameter is a function that will be called for each entry in the
+     * AVLTreeCounter. It takes four arguments:
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `AVLTreeCounterOptions<MK, MV, MR>`. This parameter allows you to provide additional
+     * configuration options when creating a new `AVLTreeCounter` instance within the `map` function.
+     * These options
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function. This can be useful when you want to access properties
+     * or
+     * @returns The `map` method is returning a new `AVLTreeCounter` instance with the entries
+     * transformed by the provided `callback` function. Each entry in the original tree is passed to the
+     * `callback` function along with the index and the original tree itself. The transformed entries are
+     * then added to the new `AVLTreeCounter` instance, which is returned at the end.
+     */
+    map(callback, options, thisArg) {
+      const newTree = new _AVLTreeCounter([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        newTree.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return newTree;
+    }
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
+     * a node object.
+     * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The
+     * `keyNodeOrEntry` parameter can be of type `R` or `BTNRep<K, V, AVLTreeCounterNode<K, V>>`.
+     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
+     * `override` function. It represents the value associated with the key in the data structure. If no
+     * value is provided, it will default to `undefined`.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
+     * @returns either a AVLTreeCounterNode<K, V> object or undefined.
+     */
+    _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count = 1) {
+      if (keyNodeOrEntry === void 0 || keyNodeOrEntry === null) return [void 0, void 0];
+      if (this.isNode(keyNodeOrEntry)) return [keyNodeOrEntry, value];
+      if (this.isEntry(keyNodeOrEntry)) {
+        const [key, entryValue] = keyNodeOrEntry;
+        if (key === void 0 || key === null) return [void 0, void 0];
+        const finalValue = value != null ? value : entryValue;
+        return [this.createNode(key, finalValue, count), finalValue];
+      }
+      return [this.createNode(keyNodeOrEntry, value, count), value];
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `_swapProperties` function swaps the properties (key, value, count, color) between two nodes
+     * The `_swapProperties` function swaps the properties (key, value, count, height) between two nodes
      * in a binary search tree.
-     * @param {R | BSTNOptKeyOrNode<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 `BSTNOptKeyOrNode<K, NODE>` class.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+     * @param {BSTNOptKeyOrNode<K, AVLTreeCounterNode<K, V>>} srcNode - The `srcNode` parameter represents the source node
+     * that will be swapped with the `destNode`.
+     * @param {BSTNOptKeyOrNode<K, AVLTreeCounterNode<K, V>>} 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.
+     * If either `srcNode` or `destNode` is undefined, it returns `undefined`.
      */
     _swapProperties(srcNode, destNode) {
       srcNode = this.ensureNode(srcNode);
       destNode = this.ensureNode(destNode);
       if (srcNode && destNode) {
-        const { key, value, count, color } = destNode;
-        const tempNode = this.createNode(key, value, color, count);
+        const { key, value, count, height } = destNode;
+        const tempNode = this.createNode(key, value, count);
         if (tempNode) {
-          tempNode.color = color;
+          tempNode.height = height;
           destNode.key = srcNode.key;
           if (!this._isMapMode) destNode.value = srcNode.value;
           destNode.count = srcNode.count;
-          destNode.color = srcNode.color;
+          destNode.height = srcNode.height;
           srcNode.key = tempNode.key;
           if (!this._isMapMode) srcNode.value = tempNode.value;
           srcNode.count = tempNode.count;
-          srcNode.color = tempNode.color;
+          srcNode.height = tempNode.height;
         }
         return destNode;
       }
@@ -12165,39 +12757,16 @@ var dataStructureTyped = (() => {
      * 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 the node that you want to replace in the data
-     * structure.
-     * @param {NODE} newNode - The `newNode` parameter is an instance of the `NODE` class.
+     * @param {AVLTreeCounterNode<K, V>} oldNode - The oldNode parameter represents the node that needs to be replaced in the
+     * data structure. It is of type AVLTreeCounterNode<K, V>.
+     * @param {AVLTreeCounterNode<K, V>} newNode - The `newNode` parameter is an instance of the `AVLTreeCounterNode<K, V>` class.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
-     * superclass, which is of type `NODE`.
+     * superclass, which is of type `AVLTreeCounterNode<K, V>`.
      */
     _replaceNode(oldNode, newNode) {
       newNode.count = oldNode.count + newNode.count;
       return super._replaceNode(oldNode, newNode);
     }
-    /**
-     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap with
-     * modified entries based on a provided callback.
-     * @param callback - The `callback` parameter is a function that will be called for each entry in the
-     * map. It takes four arguments:
-     * @param [options] - The `options` parameter in the `override map` function is of type
-     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
-     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
-     * include things like
-     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
-     * the value of `this` when executing the `callback` function. It allows you to set the context
-     * (value of `this`) for the callback function when it is called within the `map` function. This
-     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
-     * by the provided callback function.
-     */
-    map(callback, options, thisArg) {
-      const newTree = new _TreeMultiMap([], options);
-      let index = 0;
-      for (const [key, value] of this) {
-        newTree.add(callback.call(thisArg, key, value, index++, this));
-      }
-      return newTree;
-    }
   };
 
   // src/data-structures/priority-queue/priority-queue.ts