data-structure-typed 1.54.0 → 1.54.2

package/dist/{mjs → esm}/data-structures/binary-tree/binary-tree.js

@@ -12,17 +12,25 @@ import { DFSOperation, Range } from '../../common';
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
- * @template NODE - The type of the family relationship in the binary tree.
+ * @template BinaryTreeNode<K, V> - The type of the family relationship in the binary tree.
  */
 export class BinaryTreeNode {
-    key;
-    value;
-    parent;
+    /**
+     * 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) {
         this.key = key;
         this.value = value;
     }
-    _left;
+    key;
+    value;
+    parent = undefined;
+    _left = undefined;
     get left() {
         return this._left;
     }
@@ -32,7 +40,7 @@ export class BinaryTreeNode {
         }
         this._left = v;
     }
-    _right;
+    _right = undefined;
     get right() {
         return this._right;
     }
@@ -64,14 +72,13 @@ export class BinaryTreeNode {
         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';
@@ -85,15 +92,14 @@ export class BinaryTreeNode {
  * 5. Leaf Nodes: Nodes without children are leaves.
  */
 export class BinaryTree extends IterableEntryBase {
-    iterationType = 'ITERATIVE';
     /**
-     * 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();
@@ -111,6 +117,7 @@ export class BinaryTree extends IterableEntryBase {
         if (keysNodesEntriesOrRaws)
             this.addMany(keysNodesEntriesOrRaws);
     }
+    iterationType = 'ITERATIVE';
     _isMapMode = true;
     get isMapMode() {
         return this._isMapMode;
@@ -145,12 +152,15 @@ export class BinaryTree extends IterableEntryBase {
      * 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 ? undefined : 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
@@ -166,55 +176,14 @@ export class BinaryTree extends IterableEntryBase {
             ...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 === undefined)
-            return [undefined, undefined];
-        if (keyNodeEntryOrRaw === null)
-            return [null, undefined];
-        if (this.isNode(keyNodeEntryOrRaw))
-            return [keyNodeEntryOrRaw, value];
-        if (this.isEntry(keyNodeEntryOrRaw)) {
-            const [key, entryValue] = keyNodeEntryOrRaw;
-            if (key === undefined)
-                return [undefined, undefined];
-            else if (key === null)
-                return [null, undefined];
-            const finalValue = value ?? entryValue;
-            return [this.createNode(key, finalValue), finalValue];
-        }
-        if (this.isRaw(keyNodeEntryOrRaw)) {
-            const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-            const finalValue = value ?? entryValue;
-            if (this.isKey(key))
-                return [this.createNode(key, finalValue), finalValue];
-        }
-        if (this.isKey(keyNodeEntryOrRaw))
-            return [this.createNode(keyNodeEntryOrRaw, value), value];
-        return [undefined, undefined];
-    }
     /**
      * 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
@@ -222,49 +191,48 @@ export class BinaryTree extends IterableEntryBase {
      * @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)
+    ensureNode(keyNodeOrEntry, iterationType = this.iterationType) {
+        if (keyNodeOrEntry === null)
             return null;
-        if (keyNodeEntryOrRaw === undefined)
+        if (keyNodeOrEntry === undefined)
             return;
-        if (keyNodeEntryOrRaw === this._NIL)
+        if (keyNodeOrEntry === this._NIL)
             return;
-        if (this.isNode(keyNodeEntryOrRaw))
-            return keyNodeEntryOrRaw;
-        if (this.isEntry(keyNodeEntryOrRaw)) {
-            const key = keyNodeEntryOrRaw[0];
+        if (this.isNode(keyNodeOrEntry))
+            return keyNodeOrEntry;
+        if (this.isEntry(keyNodeOrEntry)) {
+            const key = keyNodeOrEntry[0];
             if (key === null)
                 return null;
             if (key === undefined)
                 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`.
@@ -273,88 +241,117 @@ export class BinaryTree extends IterableEntryBase {
         return this._toEntryFn !== undefined && 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 === undefined)
+    isRealNode(keyNodeOrEntry) {
+        if (keyNodeOrEntry === this._NIL || keyNodeOrEntry === null || keyNodeOrEntry === undefined)
             return false;
-        return this.isNode(keyNodeEntryOrRaw);
+        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 === undefined)
+    isLeaf(keyNodeOrEntry) {
+        keyNodeOrEntry = this.ensureNode(keyNodeOrEntry);
+        if (keyNodeOrEntry === undefined)
             return false;
-        if (keyNodeEntryOrRaw === null)
+        if (keyNodeOrEntry === null)
             return true;
-        return !this.isRealNode(keyNodeEntryOrRaw.left) && !this.isRealNode(keyNodeEntryOrRaw.right);
+        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);
@@ -365,8 +362,8 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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
@@ -376,8 +373,8 @@ export class BinaryTree extends IterableEntryBase {
      * 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 === undefined)
             return false;
         // If the tree is empty, directly set the new node as the root node
@@ -432,14 +429,14 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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
@@ -455,7 +452,7 @@ export class BinaryTree extends IterableEntryBase {
         if (values) {
             valuesIterator = values[Symbol.iterator]();
         }
-        for (const keyNodeEntryOrRaw of keysNodesEntriesOrRaws) {
+        for (let keyNodeEntryOrRaw of keysNodesEntriesOrRaws) {
             let value = undefined;
             if (valuesIterator) {
                 const valueResult = valuesIterator.next();
@@ -463,6 +460,8 @@ export class BinaryTree extends IterableEntryBase {
                     value = valueResult.value;
                 }
             }
+            if (this.isRaw(keyNodeEntryOrRaw))
+                keyNodeEntryOrRaw = this._toEntryFn(keyNodeEntryOrRaw);
             inserted.push(this.add(keyNodeEntryOrRaw, value));
         }
         return inserted;
@@ -473,7 +472,7 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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, []);
@@ -485,7 +484,7 @@ export class BinaryTree extends IterableEntryBase {
      * 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`.
@@ -500,7 +499,7 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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
@@ -509,11 +508,11 @@ export class BinaryTree extends IterableEntryBase {
      * 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?.parent;
@@ -562,15 +561,15 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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
@@ -580,15 +579,15 @@ export class BinaryTree extends IterableEntryBase {
      * @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 === undefined)
+    search(keyNodeEntryOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        if (keyNodeEntryOrPredicate === undefined)
             return [];
-        if (keyNodeEntryRawOrPredicate === null)
+        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) => {
@@ -631,12 +630,12 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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
@@ -646,19 +645,19 @@ export class BinaryTree extends IterableEntryBase {
      * @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.
@@ -669,8 +668,8 @@ export class BinaryTree extends IterableEntryBase {
      * @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) {
-        return this.search(keyNodeEntryRawOrPredicate, true, node => node, startNode, iterationType)[0] ?? null;
+    getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+        return this.search(keyNodeEntryOrPredicate, true, node => node, startNode, iterationType)[0];
     }
     /**
      * Time Complexity: O(n)
@@ -678,10 +677,10 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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`).
@@ -694,14 +693,14 @@ export class BinaryTree extends IterableEntryBase {
      * 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) {
         if (this._isMapMode) {
-            const key = this._extractKey(keyNodeEntryRawOrPredicate);
+            const key = this._extractKey(keyNodeEntryOrPredicate);
             if (key === null || key === undefined)
                 return;
             return this._store.get(key);
         }
-        return this.getNode(keyNodeEntryRawOrPredicate, startNode, iterationType)?.value;
+        return this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)?.value;
     }
     /**
      * Time Complexity: O(n)
@@ -709,10 +708,10 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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
@@ -724,14 +723,14 @@ export class BinaryTree extends IterableEntryBase {
      * 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();
@@ -756,7 +755,7 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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
@@ -770,11 +769,11 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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
@@ -830,13 +829,13 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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
@@ -859,11 +858,11 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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.
@@ -908,7 +907,7 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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
@@ -974,7 +973,7 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -999,14 +998,14 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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
@@ -1044,15 +1043,15 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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
@@ -1090,14 +1089,14 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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.
      */
@@ -1117,12 +1116,12 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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
@@ -1149,12 +1148,12 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -1182,8 +1181,8 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -1203,7 +1202,9 @@ export class BinaryTree extends IterableEntryBase {
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
-            const queue = new Queue([startNode]);
+            const queue = new Queue([
+                startNode
+            ]);
             const dfs = (level) => {
                 if (queue.size === 0)
                     return;
@@ -1257,7 +1258,7 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -1312,7 +1313,7 @@ export class BinaryTree extends IterableEntryBase {
      * @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.
@@ -1384,11 +1385,11 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -1494,6 +1495,10 @@ export class BinaryTree extends IterableEntryBase {
      */
     clone() {
         const cloned = this.createTree();
+        this._clone(cloned);
+        return cloned;
+    }
+    _clone(cloned) {
         this.bfs(node => {
             if (node === null)
                 cloned.add(null);
@@ -1506,7 +1511,6 @@ export class BinaryTree extends IterableEntryBase {
         }, this._root, this.iterationType, true);
         if (this._isMapMode)
             cloned._store = this._store;
-        return cloned;
     }
     /**
      * Time Complexity: O(n)
@@ -1567,7 +1571,7 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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
@@ -1592,7 +1596,7 @@ export class BinaryTree extends IterableEntryBase {
         if (opts.isShowRedBlackNIL)
             output += `S for Sentinel Node(NIL)\n`;
         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';
@@ -1612,7 +1616,7 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -1620,6 +1624,42 @@ export class BinaryTree extends IterableEntryBase {
     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 === undefined)
+            return [undefined, undefined];
+        if (keyNodeOrEntry === null)
+            return [null, undefined];
+        if (this.isNode(keyNodeOrEntry))
+            return [keyNodeOrEntry, value];
+        if (this.isEntry(keyNodeOrEntry)) {
+            const [key, entryValue] = keyNodeOrEntry;
+            if (key === undefined)
+                return [undefined, undefined];
+            else if (key === null)
+                return [null, undefined];
+            const finalValue = value ?? entryValue;
+            return [this.createNode(key, finalValue), finalValue];
+        }
+        return [this.createNode(keyNodeOrEntry, value), value];
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1628,11 +1668,11 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -1875,12 +1915,12 @@ export class BinaryTree extends IterableEntryBase {
      * 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.
@@ -1908,9 +1948,9 @@ export class BinaryTree extends IterableEntryBase {
      * 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.
@@ -1940,8 +1980,8 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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) {
@@ -1955,30 +1995,24 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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 === undefined)
+    _ensurePredicate(keyNodeEntryOrPredicate) {
+        if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === undefined)
             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)
@@ -1987,7 +2021,7 @@ export class BinaryTree extends IterableEntryBase {
      * 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`.
@@ -2001,32 +2035,25 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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)
+    _extractKey(keyNodeOrEntry) {
+        if (keyNodeOrEntry === null)
             return null;
-        if (keyNodeEntryOrRaw === undefined)
+        if (keyNodeOrEntry === undefined)
             return;
-        if (keyNodeEntryOrRaw === this._NIL)
+        if (keyNodeOrEntry === 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;
+        if (this.isNode(keyNodeOrEntry))
+            return keyNodeOrEntry.key;
+        if (this.isEntry(keyNodeOrEntry))
+            return keyNodeOrEntry[0];
+        return keyNodeOrEntry;
     }
     /**
      * Time Complexity: O(1)