heap-typed 1.52.8 → 1.53.0

package/dist/data-structures/binary-tree/binary-tree.js

@@ -66,29 +66,39 @@ class BinaryTree extends base_1.IterableEntryBase {
     /**
      * The constructor initializes a binary tree with optional options and adds keys, nodes, entries, or
      * raw data if provided.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter in the constructor
-     * is an iterable that can contain elements of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`. It is
+     * @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:
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
         super();
         this.iterationType = 'ITERATIVE';
+        this._isMapMode = false;
+        this._store = new Map();
         this._size = 0;
         this._NIL = new BinaryTreeNode(NaN);
-        this._DEFAULT_BTN_CALLBACK = (node) => (node ? node.key : undefined);
+        this._DEFAULT_NODE_CALLBACK = (node) => (node ? node.key : undefined);
         if (options) {
-            const { iterationType, toEntryFn } = options;
+            const { iterationType, toEntryFn, isMapMode } = options;
             if (iterationType)
                 this.iterationType = iterationType;
+            if (isMapMode !== undefined)
+                this._isMapMode = isMapMode;
             if (typeof toEntryFn === 'function')
                 this._toEntryFn = toEntryFn;
             else if (toEntryFn)
                 throw TypeError('toEntryFn must be a function type');
         }
-        if (keysOrNodesOrEntriesOrRaws)
-            this.addMany(keysOrNodesOrEntriesOrRaws);
+        if (keysNodesEntriesOrRaws)
+            this.addMany(keysNodesEntriesOrRaws);
+    }
+    get isMapMode() {
+        return this._isMapMode;
+    }
+    get store() {
+        return this._store;
     }
     get root() {
         return this._root;
@@ -123,49 +133,51 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns A new instance of a binary tree with the specified options is being returned.
      */
     createTree(options) {
-        return new BinaryTree([], Object.assign({ iterationType: this.iterationType, toEntryFn: this._toEntryFn }, options));
+        return new BinaryTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, toEntryFn: this._toEntryFn }, options));
     }
     /**
-     * The function `keyValueOrEntryOrRawElementToNode` converts various input types into a node object
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
      * or returns null.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
-     * `keyValueOrEntryOrRawElementToNode` function takes in a parameter `keyOrNodeOrEntryOrRaw`, which
-     * can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`. This parameter represents either a key, a
+     * @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 `keyValueOrEntryOrRawElementToNode` function is
+     * @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 `keyValueOrEntryOrRawElementToNode` function returns an optional node
-     * (`OptBTNOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
-     * input parameter (`keyOrNodeOrEntryOrRaw`) and processes it accordingly to return a node or null
+     * @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.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value) {
-        if (keyOrNodeOrEntryOrRaw === undefined)
-            return;
-        if (keyOrNodeOrEntryOrRaw === null)
-            return null;
-        if (this.isNode(keyOrNodeOrEntryOrRaw))
-            return keyOrNodeOrEntryOrRaw;
-        if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
-            const [key, entryValue] = keyOrNodeOrEntryOrRaw;
+    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;
+                return [undefined, undefined];
             else if (key === null)
-                return null;
-            if (this.isKey(key))
-                return this.createNode(key, value !== null && value !== void 0 ? value : entryValue);
+                return [null, undefined];
+            const finalValue = value !== null && value !== void 0 ? value : entryValue;
+            return [this.createNode(key, finalValue), finalValue];
         }
-        if (this._toEntryFn) {
-            const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw);
-            if (this.isKey(key))
-                return this.createNode(key, value !== null && value !== void 0 ? value : entryValue);
-            else
-                return;
+        if (this.isKey(keyNodeEntryOrRaw))
+            return [this.createNode(keyNodeEntryOrRaw, value), value];
+        if (this.isRaw(keyNodeEntryOrRaw)) {
+            if (this._toEntryFn) {
+                const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+                const finalValue = value !== null && value !== void 0 ? value : entryValue;
+                if (this.isKey(key))
+                    return [this.createNode(key, finalValue), finalValue];
+            }
+            return [undefined, undefined];
         }
-        if (this.isKey(keyOrNodeOrEntryOrRaw))
-            return this.createNode(keyOrNodeOrEntryOrRaw, value);
-        return;
+        return [undefined, undefined];
     }
     /**
      * Time Complexity: O(n)
@@ -173,8 +185,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * 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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `keyOrNodeOrEntryOrRaw`
-     * parameter in the `ensureNode` function can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`. It
+     * @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
      * 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
@@ -182,17 +194,17 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns The `ensureNode` function returns either a node, `null`, or `undefined` based on the
      * conditions specified in the code snippet.
      */
-    ensureNode(keyOrNodeOrEntryOrRaw, iterationType = this.iterationType) {
-        if (keyOrNodeOrEntryOrRaw === null)
+    ensureNode(keyNodeEntryOrRaw, iterationType = this.iterationType) {
+        if (keyNodeEntryOrRaw === null)
             return null;
-        if (keyOrNodeOrEntryOrRaw === undefined)
+        if (keyNodeEntryOrRaw === undefined)
             return;
-        if (keyOrNodeOrEntryOrRaw === this._NIL)
+        if (keyNodeEntryOrRaw === this._NIL)
             return;
-        if (this.isNode(keyOrNodeOrEntryOrRaw))
-            return keyOrNodeOrEntryOrRaw;
-        if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
-            const key = keyOrNodeOrEntryOrRaw[0];
+        if (this.isNode(keyNodeEntryOrRaw))
+            return keyNodeEntryOrRaw;
+        if (this.isEntry(keyNodeEntryOrRaw)) {
+            const key = keyNodeEntryOrRaw[0];
             if (key === null)
                 return null;
             if (key === undefined)
@@ -200,95 +212,98 @@ class BinaryTree extends base_1.IterableEntryBase {
             return this.getNodeByKey(key, iterationType);
         }
         if (this._toEntryFn) {
-            const [key] = this._toEntryFn(keyOrNodeOrEntryOrRaw);
+            const [key] = this._toEntryFn(keyNodeEntryOrRaw);
             if (this.isKey(key))
                 return this.getNodeByKey(key);
         }
-        if (this.isKey(keyOrNodeOrEntryOrRaw))
-            return this.getNodeByKey(keyOrNodeOrEntryOrRaw, iterationType);
+        if (this.isKey(keyNodeEntryOrRaw))
+            return this.getNodeByKey(keyNodeEntryOrRaw, iterationType);
         return;
     }
     /**
      * The function isNode checks if the input is an instance of BinaryTreeNode.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be either a key, a node, an entry, or raw data. The function is
+     * @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
      * 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 `keyOrNodeOrEntryOrRaw` is an instance of
+     * @returns The function `isNode` is checking if the input `keyNodeEntryOrRaw` 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(keyOrNodeOrEntryOrRaw) {
-        return keyOrNodeOrEntryOrRaw instanceof BinaryTreeNode;
+    isNode(keyNodeEntryOrRaw) {
+        return keyNodeEntryOrRaw instanceof BinaryTreeNode;
+    }
+    isRaw(keyNodeEntryOrRaw) {
+        return typeof keyNodeEntryOrRaw === 'object';
     }
     /**
      * The function `isRealNode` checks if a given input is a valid node in a binary tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `keyOrNodeOrEntryOrRaw`
-     * parameter in the `isRealNode` function can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`.
+     * @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 `keyOrNodeOrEntryOrRaw` is a valid
+     * @returns The function `isRealNode` is checking if the input `keyNodeEntryOrRaw` 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(keyOrNodeOrEntryOrRaw) {
-        if (keyOrNodeOrEntryOrRaw === this._NIL || keyOrNodeOrEntryOrRaw === null || keyOrNodeOrEntryOrRaw === undefined)
+    isRealNode(keyNodeEntryOrRaw) {
+        if (keyNodeEntryOrRaw === this._NIL || keyNodeEntryOrRaw === null || keyNodeEntryOrRaw === undefined)
             return false;
-        return this.isNode(keyOrNodeOrEntryOrRaw);
+        return this.isNode(keyNodeEntryOrRaw);
     }
     /**
      * The function checks if a given input is a valid node or null.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` in the `isRealNodeOrNull` function can be of type `BTNKeyOrNodeOrEntry<K,
+     * @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
      * @returns The function `isRealNodeOrNull` is returning a boolean value. It checks if the input
-     * `keyOrNodeOrEntryOrRaw` is either `null` or a real node, and returns `true` if it is a node or
+     * `keyNodeEntryOrRaw` is either `null` or a real node, and returns `true` if it is a node or
      * `null`, and `false` otherwise.
      */
-    isRealNodeOrNull(keyOrNodeOrEntryOrRaw) {
-        return keyOrNodeOrEntryOrRaw === null || this.isRealNode(keyOrNodeOrEntryOrRaw);
+    isRealNodeOrNull(keyNodeEntryOrRaw) {
+        return keyNodeEntryOrRaw === null || this.isRealNode(keyNodeEntryOrRaw);
     }
     /**
      * The function isNIL checks if a given key, node, entry, or raw value is equal to the _NIL value.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - BTNKeyOrNodeOrEntry<K, V,
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - BTNRep<K, V,
      * NODE> | R
-     * @returns The function is checking if the `keyOrNodeOrEntryOrRaw` parameter is equal to the `_NIL`
+     * @returns The function is checking if the `keyNodeEntryOrRaw` parameter is equal to the `_NIL`
      * property of the current object and returning a boolean value based on that comparison.
      */
-    isNIL(keyOrNodeOrEntryOrRaw) {
-        return keyOrNodeOrEntryOrRaw === this._NIL;
+    isNIL(keyNodeEntryOrRaw) {
+        return keyNodeEntryOrRaw === this._NIL;
     }
     /**
      * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
      * tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`. It represents a
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `BTNRep<K, V, NODE>` 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
-     * `keyOrNodeOrEntryOrRaw` is a leaf node in a binary tree.
+     * `keyNodeEntryOrRaw` is a leaf node in a binary tree.
      */
-    isLeaf(keyOrNodeOrEntryOrRaw) {
-        keyOrNodeOrEntryOrRaw = this.ensureNode(keyOrNodeOrEntryOrRaw);
-        if (keyOrNodeOrEntryOrRaw === undefined)
+    isLeaf(keyNodeEntryOrRaw) {
+        keyNodeEntryOrRaw = this.ensureNode(keyNodeEntryOrRaw);
+        if (keyNodeEntryOrRaw === undefined)
             return false;
-        if (keyOrNodeOrEntryOrRaw === null)
+        if (keyNodeEntryOrRaw === null)
             return true;
-        return !this.isRealNode(keyOrNodeOrEntryOrRaw.left) && !this.isRealNode(keyOrNodeOrEntryOrRaw.right);
+        return !this.isRealNode(keyNodeEntryOrRaw.left) && !this.isRealNode(keyNodeEntryOrRaw.right);
     }
     /**
      * The function `isEntry` checks if the input is a BTNEntry object by verifying if it is an array
      * with a length of 2.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `keyOrNodeOrEntryOrRaw`
-     * parameter in the `isEntry` function can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or type `R`.
-     * The function checks if the provided `keyOrNodeOrEntryOrRaw` is of type `BTN
-     * @returns The `isEntry` function is checking if the `keyOrNodeOrEntryOrRaw` parameter is an array
+     * @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
      * 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(keyOrNodeOrEntryOrRaw) {
-        return Array.isArray(keyOrNodeOrEntryOrRaw) && keyOrNodeOrEntryOrRaw.length === 2;
+    isEntry(keyNodeEntryOrRaw) {
+        return Array.isArray(keyNodeEntryOrRaw) && keyNodeEntryOrRaw.length === 2;
     }
     /**
      * Time Complexity O(1)
@@ -312,8 +327,8 @@ class BinaryTree extends base_1.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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `add` method you provided
-     * seems to be for adding a new node to a binary tree structure. The `keyOrNodeOrEntryOrRaw`
+     * @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`
      * 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
@@ -323,13 +338,15 @@ class BinaryTree extends base_1.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(keyOrNodeOrEntryOrRaw, value) {
-        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value);
+    add(keyNodeEntryOrRaw, value) {
+        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
         if (newNode === undefined)
             return false;
         // If the tree is empty, directly set the new node as the root node
         if (!this._root) {
             this._setRoot(newNode);
+            if (this._isMapMode)
+                this._setValue(newNode === null || newNode === void 0 ? void 0 : newNode.key, newValue);
             this._size = 1;
             return true;
         }
@@ -342,6 +359,8 @@ class BinaryTree extends base_1.IterableEntryBase {
             // Check for duplicate keys when newNode is not null
             if (newNode !== null && cur.key === newNode.key) {
                 this._replaceNode(cur, newNode);
+                if (this._isMapMode)
+                    this._setValue(cur.key, newValue);
                 return true; // If duplicate keys are found, no insertion is performed
             }
             // Record the first possible insertion location found
@@ -366,6 +385,8 @@ class BinaryTree extends base_1.IterableEntryBase {
             else if (potentialParent.right === undefined) {
                 potentialParent.right = newNode;
             }
+            if (this._isMapMode)
+                this._setValue(newNode === null || newNode === void 0 ? void 0 : newNode.key, newValue);
             this._size++;
             return true;
         }
@@ -378,25 +399,25 @@ class BinaryTree extends base_1.IterableEntryBase {
      * 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 keysOrNodesOrEntriesOrRaws - `keysOrNodesOrEntriesOrRaws` is an iterable that can contain a
+     * @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
-     * `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`.
+     * `BTNRep<K, V, NODE>` 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
-     * `keysOrNodesOrEntriesOrRaws` parameter. If provided, the function will iterate over the values and
+     * `keysNodesEntriesOrRaws` parameter. If provided, the function will iterate over the values and
      * assign them
      * @returns The `addMany` method returns an array of boolean values indicating whether each key,
      * node, entry, or raw value was successfully added to the data structure. Each boolean value
      * corresponds to the success of adding the corresponding key or value in the input iterable.
      */
-    addMany(keysOrNodesOrEntriesOrRaws, values) {
+    addMany(keysNodesEntriesOrRaws, values) {
         // TODO not sure addMany not be run multi times
         const inserted = [];
         let valuesIterator;
         if (values) {
             valuesIterator = values[Symbol.iterator]();
         }
-        for (const keyOrNodeOrEntryOrRaw of keysOrNodesOrEntriesOrRaws) {
+        for (const keyNodeEntryOrRaw of keysNodesEntriesOrRaws) {
             let value = undefined;
             if (valuesIterator) {
                 const valueResult = valuesIterator.next();
@@ -404,7 +425,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                     value = valueResult.value;
                 }
             }
-            inserted.push(this.add(keyOrNodeOrEntryOrRaw, value));
+            inserted.push(this.add(keyNodeEntryOrRaw, value));
         }
         return inserted;
     }
@@ -414,15 +435,15 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `refill` function clears the existing data structure and then adds new key-value pairs based
      * on the provided input.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter in the `refill`
-     * method can accept an iterable containing a mix of `BTNKeyOrNodeOrEntry<K, V, NODE>` objects or `R`
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the `refill`
+     * method can accept an iterable containing a mix of `BTNRep<K, V, NODE>` 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`.
      */
-    refill(keysOrNodesOrEntriesOrRaws, values) {
+    refill(keysNodesEntriesOrRaws, values) {
         this.clear();
-        this.addMany(keysOrNodesOrEntriesOrRaws, values);
+        this.addMany(keysNodesEntriesOrRaws, values);
     }
     /**
      * Time Complexity: O(n)
@@ -430,20 +451,20 @@ class BinaryTree extends base_1.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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrNodeOrEntryOrRawOrPredicate
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw
      * - The `delete` method you provided is used to delete a node from a binary tree based on the key,
-     * node, entry, raw data, or a custom predicate. The method returns an array of
+     * node, entry or raw data. The method returns an array of
      * `BinaryTreeDeleteResult` objects containing information about the deleted node and whether
      * balancing is needed.
      * @returns The `delete` method returns an array of `BinaryTreeDeleteResult` objects. Each object in
      * the array contains information about the node that was deleted (`deleted`) and the node that may
      * need to be balanced (`needBalanced`).
      */
-    delete(keyOrNodeOrEntryOrRawOrPredicate) {
+    delete(keyNodeEntryOrRaw) {
         const deletedResult = [];
         if (!this._root)
             return deletedResult;
-        const curr = this.getNode(keyOrNodeOrEntryOrRawOrPredicate);
+        const curr = this.getNode(keyNodeEntryOrRaw);
         if (!curr)
             return deletedResult;
         const parent = curr === null || curr === void 0 ? void 0 : curr.parent;
@@ -482,6 +503,8 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         this._size = this._size - 1;
         deletedResult.push({ deleted: orgCurrent, needBalanced });
+        if (this._isMapMode && orgCurrent)
+            this._store.delete(orgCurrent.key);
         return deletedResult;
     }
     /**
@@ -490,12 +513,12 @@ class BinaryTree extends base_1.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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrNodeOrEntryOrRawOrPredicate
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
      * - The `getNodes` function you provided takes several parameters:
      * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` function is a boolean flag that
      * determines whether to return only the first node that matches the criteria specified by the
-     * `keyOrNodeOrEntryOrRawOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * `keyNodeEntryRawOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `getNodes` function is used to specify the starting point for traversing the binary tree. It
      * represents the root node of the binary tree or the node from which the traversal should begin. If
      * not provided, the default value is set to `this._root
@@ -505,15 +528,15 @@ class BinaryTree extends base_1.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(keyOrNodeOrEntryOrRawOrPredicate, onlyOne = false, beginRoot = this._root, iterationType = this.iterationType) {
-        if (keyOrNodeOrEntryOrRawOrPredicate === undefined)
+    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+        if (keyNodeEntryRawOrPredicate === undefined)
             return [];
-        if (keyOrNodeOrEntryOrRawOrPredicate === null)
+        if (keyNodeEntryRawOrPredicate === null)
             return [];
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+        startNode = this.ensureNode(startNode);
+        if (!startNode)
             return [];
-        const callback = this._ensurePredicate(keyOrNodeOrEntryOrRawOrPredicate);
+        const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
@@ -529,10 +552,10 @@ class BinaryTree extends base_1.IterableEntryBase {
                 if (this.isRealNode(cur.right))
                     dfs(cur.right);
             };
-            dfs(beginRoot);
+            dfs(startNode);
         }
         else {
-            const stack = [beginRoot];
+            const stack = [startNode];
             while (stack.length > 0) {
                 const cur = stack.pop();
                 if (this.isRealNode(cur)) {
@@ -556,10 +579,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `getNode` function retrieves a node based on the provided key, node, entry, raw data, or
      * predicate.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrNodeOrEntryOrRawOrPredicate
-     * - The `keyOrNodeOrEntryOrRawOrPredicate` parameter in the `getNode` function can accept a key,
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
+     * - The `keyNodeEntryRawOrPredicate` parameter in the `getNode` function can accept a key,
      * node, entry, raw data, or a predicate function.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} 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.
@@ -570,9 +593,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns The `getNode` function is returning the first node that matches the specified criteria,
      * or `null` if no matching node is found.
      */
-    getNode(keyOrNodeOrEntryOrRawOrPredicate, beginRoot = this._root, iterationType = this.iterationType) {
+    getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
         var _a;
-        return (_a = this.getNodes(keyOrNodeOrEntryOrRawOrPredicate, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * Time Complexity: O(n)
@@ -585,7 +608,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * specifies how the tree nodes should be traversed when searching for a node with the given key. It
      * is an optional parameter with a default value of `this.iterationType`.
      * @returns The `getNodeByKey` function is returning an optional binary tree node
-     * (`OptBTNOrNull<NODE>`).
+     * (`OptNodeOrNull<NODE>`).
      */
     getNodeByKey(key, iterationType = this.iterationType) {
         return this.getNode(key, this._root, iterationType);
@@ -596,10 +619,10 @@ class BinaryTree extends base_1.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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrNodeOrEntryOrRawOrPredicate
-     * - The `keyOrNodeOrEntryOrRawOrPredicate` parameter in the `get` method can accept one of the
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
+     * - The `keyNodeEntryRawOrPredicate` parameter in the `get` method can accept one of the
      * following types:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `get`
+     * @param {BTNRep<K, V, NODE> | R} 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`).
@@ -612,9 +635,15 @@ class BinaryTree extends base_1.IterableEntryBase {
      * the method returns the corresponding value. If the key or node is not found, it returns
      * `undefined`.
      */
-    get(keyOrNodeOrEntryOrRawOrPredicate, beginRoot = this._root, iterationType = this.iterationType) {
+    get(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
         var _a;
-        return (_a = this.getNode(keyOrNodeOrEntryOrRawOrPredicate, beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.value;
+        if (this._isMapMode) {
+            const key = this._getKey(keyNodeEntryRawOrPredicate);
+            if (key === null || key === undefined)
+                return;
+            return this._store.get(key);
+        }
+        return (_a = this.getNode(keyNodeEntryRawOrPredicate, startNode, iterationType)) === null || _a === void 0 ? void 0 : _a.value;
     }
     /**
      * Time Complexity: O(n)
@@ -622,10 +651,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `has` function in TypeScript checks if a specified key, node, entry, raw data, or predicate
      * exists in the data structure.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrNodeOrEntryOrRawOrPredicate
-     * - The `keyOrNodeOrEntryOrRawOrPredicate` parameter in the `override has` method can accept one of
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
+     * - The `keyNodeEntryRawOrPredicate` parameter in the `override has` method can accept one of
      * the following types:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} 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
@@ -637,8 +666,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      * are matching nodes, it returns `true`, indicating that the tree contains the specified element.
      * Otherwise, it returns `false`.
      */
-    has(keyOrNodeOrEntryOrRawOrPredicate, beginRoot = this._root, iterationType = this.iterationType) {
-        return this.getNodes(keyOrNodeOrEntryOrRawOrPredicate, true, beginRoot, iterationType).length > 0;
+    has(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+        return this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType).length > 0;
     }
     /**
      * Time Complexity: O(1)
@@ -647,8 +676,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      * The `clear` function resets the root node and size of a data structure to empty.
      */
     clear() {
-        this._setRoot(undefined);
-        this._size = 0;
+        this._clearNodes();
+        if (this._isMapMode)
+            this._clearValues();
     }
     /**
      * Time Complexity: O(1)
@@ -668,17 +698,17 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function checks if a binary tree is perfectly balanced by comparing its minimum height with
      * its height.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNRep<K, V, NODE> | R} 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
-     * the tree starting from the `beginRoot` node is perfectly balanced or not. The return value is
+     * the tree starting from the `startNode` node is perfectly balanced or not. The return value is
      * determined by comparing the minimum height of the tree with the height of the tree. If the minimum
      * height plus 1 is greater than or equal to the height of the tree, then it is considered perfectly
      * balanced and
      */
-    isPerfectlyBalanced(beginRoot = this._root) {
-        return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
+    isPerfectlyBalanced(startNode = this._root) {
+        return this.getMinHeight(startNode) + 1 >= this.getHeight(startNode);
     }
     /**
      * Time Complexity: O(n)
@@ -686,7 +716,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `isBST` in TypeScript checks if a binary search tree is valid using either recursive
      * or iterative methods.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `isBST`
+     * @param {BTNRep<K, V, NODE> | R} 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
@@ -698,10 +728,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      * the tree satisfies the BST property, where for every node, all nodes in its left subtree have keys
      * less than the node's key, and all nodes in its right subtree have keys greater than the node's
      */
-    isBST(beginRoot = this._root, iterationType = this.iterationType) {
+    isBST(startNode = this._root, iterationType = this.iterationType) {
         // TODO there is a bug
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+        startNode = this.ensureNode(startNode);
+        if (!startNode)
             return true;
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur, min, max) => {
@@ -712,8 +742,8 @@ class BinaryTree extends base_1.IterableEntryBase {
                     return false;
                 return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
             };
-            const isStandardBST = dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-            const isInverseBST = dfs(beginRoot, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
+            const isStandardBST = dfs(startNode, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+            const isInverseBST = dfs(startNode, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
             return isStandardBST || isInverseBST;
         }
         else {
@@ -721,7 +751,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                 const stack = [];
                 let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
                 // @ts-ignore
-                let curr = beginRoot;
+                let curr = startNode;
                 while (this.isRealNode(curr) || stack.length > 0) {
                     while (this.isRealNode(curr)) {
                         stack.push(curr);
@@ -745,20 +775,20 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(1)
      *
      * The `getDepth` function calculates the depth between two nodes in a binary tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} dist - The `dist` parameter in the `getDepth`
+     * @param {BTNRep<K, V, NODE> | R} 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 `beginRoot` node.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * 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
      * `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 `beginRoot` is set to the root of the binary
+     * for `startNode` is set to the root of the binary
      * @returns The `getDepth` method returns the depth of a given node `dist` relative to the
-     * `beginRoot` node in a binary tree. If the `dist` node is not found in the path to the `beginRoot`
+     * `startNode` node in a binary tree. If the `dist` node is not found in the path to the `startNode`
      * node, it returns the depth of the `dist` node from the root of the tree.
      */
-    getDepth(dist, beginRoot = this._root) {
+    getDepth(dist, startNode = this._root) {
         let distEnsured = this.ensureNode(dist);
-        const beginRootEnsured = this.ensureNode(beginRoot);
+        const beginRootEnsured = this.ensureNode(startNode);
         let depth = 0;
         while (distEnsured === null || distEnsured === void 0 ? void 0 : distEnsured.parent) {
             if (distEnsured === beginRootEnsured) {
@@ -775,7 +805,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
      * or iterative approach in TypeScript.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNRep<K, V, NODE> | R} 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.
@@ -786,9 +816,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      * root node. The height is calculated based on the maximum depth of the tree, considering either a
      * recursive approach or an iterative approach depending on the `iterationType` parameter.
      */
-    getHeight(beginRoot = this._root, iterationType = this.iterationType) {
-        beginRoot = this.ensureNode(beginRoot);
-        if (!this.isRealNode(beginRoot))
+    getHeight(startNode = this._root, iterationType = this.iterationType) {
+        startNode = this.ensureNode(startNode);
+        if (!this.isRealNode(startNode))
             return -1;
         if (iterationType === 'RECURSIVE') {
             const _getMaxHeight = (cur) => {
@@ -798,10 +828,10 @@ class BinaryTree extends base_1.IterableEntryBase {
                 const rightHeight = _getMaxHeight(cur.right);
                 return Math.max(leftHeight, rightHeight) + 1;
             };
-            return _getMaxHeight(beginRoot);
+            return _getMaxHeight(startNode);
         }
         else {
-            const stack = [{ node: beginRoot, depth: 0 }];
+            const stack = [{ node: startNode, depth: 0 }];
             let maxHeight = 0;
             while (stack.length > 0) {
                 const { node, depth } = stack.pop();
@@ -820,7 +850,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach in TypeScript.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} 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
@@ -832,9 +862,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      * leaf node in the tree. The method uses either a recursive approach or an iterative approach (using
      * a stack) based on the `iterationType` parameter.
      */
-    getMinHeight(beginRoot = this._root, iterationType = this.iterationType) {
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+    getMinHeight(startNode = this._root, iterationType = this.iterationType) {
+        startNode = this.ensureNode(startNode);
+        if (!startNode)
             return -1;
         if (iterationType === 'RECURSIVE') {
             const _getMinHeight = (cur) => {
@@ -846,11 +876,11 @@ class BinaryTree extends base_1.IterableEntryBase {
                 const rightMinHeight = _getMinHeight(cur.right);
                 return Math.min(leftMinHeight, rightMinHeight) + 1;
             };
-            return _getMinHeight(beginRoot);
+            return _getMinHeight(startNode);
         }
         else {
             const stack = [];
-            let node = beginRoot, last = null;
+            let node = startNode, last = null;
             const depths = new Map();
             while (stack.length > 0 || node) {
                 if (this.isRealNode(node)) {
@@ -873,7 +903,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                         node = node.right;
                 }
             }
-            return depths.get(beginRoot);
+            return depths.get(startNode);
         }
     }
     /**
@@ -886,7 +916,7 @@ class BinaryTree extends base_1.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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginNode - The `beginNode` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} 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
@@ -896,7 +926,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * array is either in reverse order or in the original order based on the value of the `isReverse`
      * parameter.
      */
-    getPathToRoot(callback = this._DEFAULT_BTN_CALLBACK, beginNode, isReverse = true) {
+    getPathToRoot(callback = this._DEFAULT_NODE_CALLBACK, beginNode, isReverse = true) {
         const result = [];
         let beginNodeEnsured = this.ensureNode(beginNode);
         if (!beginNodeEnsured)
@@ -917,8 +947,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      * 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_BTN_CALLBACK` if not specified.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * value of `_DEFAULT_NODE_CALLBACK` if not specified.
+     * @param {BTNRep<K, V, NODE> | R} 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
@@ -926,23 +956,23 @@ class BinaryTree extends base_1.IterableEntryBase {
      * specifies the type of iteration to be used when traversing the binary tree nodes. It can have two
      * possible values:
      * @returns The `getLeftMost` function returns the result of the callback function `C` applied to the
-     * leftmost node in the binary tree starting from the `beginRoot` node. If the `beginRoot` node is
-     * `NIL`, it returns the result of the callback function applied to `undefined`. If the `beginRoot`
+     * leftmost node in the binary tree starting from the `startNode` node. If the `startNode` node is
+     * `NIL`, it returns the result of the callback function applied to `undefined`. If the `startNode`
      * node is not a real node, it returns the result of the callback
      */
-    getLeftMost(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-        if (this.isNIL(beginRoot))
+    getLeftMost(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        if (this.isNIL(startNode))
             return callback(undefined);
-        beginRoot = this.ensureNode(beginRoot);
-        if (!this.isRealNode(beginRoot))
-            return callback(beginRoot);
+        startNode = this.ensureNode(startNode);
+        if (!this.isRealNode(startNode))
+            return callback(startNode);
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
                 if (!this.isRealNode(cur.left))
                     return cur;
                 return dfs(cur.left);
             };
-            return callback(dfs(beginRoot));
+            return callback(dfs(startNode));
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
@@ -951,7 +981,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                     return cur;
                 return dfs.cont(cur.left);
             });
-            return callback(dfs(beginRoot));
+            return callback(dfs(startNode));
         }
     }
     /**
@@ -961,10 +991,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      * 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 `BTNCallback<OptBTNOrNull<NODE>>`,
+     * of finding the rightmost node in a binary tree. It is of type `NodeCallback<OptNodeOrNull<NODE>>`,
      * which means it is a callback function that can accept either an optional binary tree node or null
      * as
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} 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
@@ -976,20 +1006,20 @@ class BinaryTree extends base_1.IterableEntryBase {
      * the binary tree structure, determined based on the specified iteration type ('RECURSIVE' or
      * other).
      */
-    getRightMost(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-        if (this.isNIL(beginRoot))
+    getRightMost(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        if (this.isNIL(startNode))
             return callback(undefined);
         // TODO support get right most by passing key in
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
-            return callback(beginRoot);
+        startNode = this.ensureNode(startNode);
+        if (!startNode)
+            return callback(startNode);
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
                 if (!this.isRealNode(cur.right))
                     return cur;
                 return dfs(cur.right);
             };
-            return callback(dfs(beginRoot));
+            return callback(dfs(startNode));
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
@@ -998,7 +1028,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                     return cur;
                 return dfs.cont(cur.right);
             });
-            return callback(dfs(beginRoot));
+            return callback(dfs(startNode));
         }
     }
     /**
@@ -1062,14 +1092,14 @@ class BinaryTree extends base_1.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
-     * `BTNCallback` interface with a type parameter of `OptBTNOrNull<NODE>`. It has a default value of
-     * `this._DEFAULT_BTN_CALLBACK as C`.
+     * `NodeCallback` interface with a type parameter of `OptNodeOrNull<NODE>`. 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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `dfs`
+     * @param {BTNRep<K, V, NODE> | R} 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 `BTNKeyOrNodeOrEntry` object representing a key, node, or entry in the binary tree map,
+     * either a `BTNRep` object representing a key, node, or entry in the binary tree map,
      * or it can be a
      * @param {IterationType} iterationType - The `iterationType` parameter in the `dfs` method specifies
      * the type of iteration to be performed during the depth-first search traversal. It is used to
@@ -1081,11 +1111,11 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns The `dfs` method is returning an array of the return type specified by the generic type
      * parameter `C`. The return type is determined by the callback function provided to the method.
      */
-    dfs(callback = this._DEFAULT_BTN_CALLBACK, pattern = 'IN', beginRoot = this._root, iterationType = this.iterationType, includeNull = false) {
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = 'IN', startNode = this._root, iterationType = this.iterationType, includeNull = false) {
+        startNode = this.ensureNode(startNode);
+        if (!startNode)
             return [];
-        return this._dfs(callback, pattern, beginRoot, iterationType, includeNull);
+        return this._dfs(callback, pattern, startNode, iterationType, includeNull);
     }
     /**
      * Time complexity: O(n)
@@ -1095,8 +1125,8 @@ class BinaryTree extends base_1.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 `BTNCallback` type, which takes a parameter of type `NODE` or `null`.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `bfs`
+     * 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`
      * 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
@@ -1110,13 +1140,13 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns The `bfs` function returns an array of values that are the result of applying the
      * provided callback function to each node in the binary tree in a breadth-first search manner.
      */
-    bfs(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType, includeNull = false) {
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+    bfs(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
+        startNode = this.ensureNode(startNode);
+        if (!startNode)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
-            const queue = new queue_1.Queue([beginRoot]);
+            const queue = new queue_1.Queue([startNode]);
             const dfs = (level) => {
                 if (queue.size === 0)
                     return;
@@ -1139,7 +1169,7 @@ class BinaryTree extends base_1.IterableEntryBase {
             dfs(0);
         }
         else {
-            const queue = new queue_1.Queue([beginRoot]);
+            const queue = new queue_1.Queue([startNode]);
             while (queue.size > 0) {
                 const levelSize = queue.size;
                 for (let i = 0; i < levelSize; i++) {
@@ -1170,7 +1200,7 @@ class BinaryTree extends base_1.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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `leaves`
+     * @param {BTNRep<K, V, NODE> | R} 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
@@ -1180,10 +1210,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns The `leaves` method returns an array of values that are the result of applying the
      * provided callback function to each leaf node in the binary tree.
      */
-    leaves(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-        beginRoot = this.ensureNode(beginRoot);
+    leaves(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        startNode = this.ensureNode(startNode);
         const leaves = [];
-        if (!this.isRealNode(beginRoot))
+        if (!this.isRealNode(startNode))
             return [];
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
@@ -1197,10 +1227,10 @@ class BinaryTree extends base_1.IterableEntryBase {
                 if (this.isRealNode(cur.right))
                     dfs(cur.right);
             };
-            dfs(beginRoot);
+            dfs(startNode);
         }
         else {
-            const queue = new queue_1.Queue([beginRoot]);
+            const queue = new queue_1.Queue([startNode]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (this.isRealNode(cur)) {
@@ -1225,7 +1255,7 @@ class BinaryTree extends base_1.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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} 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.
@@ -1240,10 +1270,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      * level in a binary tree. Each inner array contains the return value of the provided callback
      * function applied to the nodes at that level.
      */
-    listLevels(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType, includeNull = false) {
-        beginRoot = this.ensureNode(beginRoot);
+    listLevels(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
+        startNode = this.ensureNode(startNode);
         const levelsNodes = [];
-        if (!beginRoot)
+        if (!startNode)
             return levelsNodes;
         if (iterationType === 'RECURSIVE') {
             const _recursive = (node, level) => {
@@ -1263,10 +1293,10 @@ class BinaryTree extends base_1.IterableEntryBase {
                         _recursive(node.right, level + 1);
                 }
             };
-            _recursive(beginRoot, 0);
+            _recursive(startNode, 0);
         }
         else {
-            const stack = [[beginRoot, 0]];
+            const stack = [[startNode, 0]];
             while (stack.length > 0) {
                 const head = stack.pop();
                 const [node, level] = head;
@@ -1297,11 +1327,11 @@ class BinaryTree extends base_1.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
-     * `BTNCallback<NODE>` type. The default value for `callback` is `this._DEFAULT
+     * `NodeCallback<NODE>` 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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `morris`
+     * @param {BTNRep<K, V, NODE> | R} 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
@@ -1309,12 +1339,12 @@ class BinaryTree extends base_1.IterableEntryBase {
      * provided callback function to each node in the binary tree in the specified order pattern (IN,
      * PRE, or POST).
      */
-    morris(callback = this._DEFAULT_BTN_CALLBACK, pattern = 'IN', beginRoot = this._root) {
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+    morris(callback = this._DEFAULT_NODE_CALLBACK, pattern = 'IN', startNode = this._root) {
+        startNode = this.ensureNode(startNode);
+        if (!startNode)
             return [];
         const ans = [];
-        let cur = beginRoot;
+        let cur = startNode;
         const _reverseEdge = (node) => {
             let pre = null;
             let next = null;
@@ -1389,7 +1419,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                     }
                     cur = cur.right;
                 }
-                _printEdge(beginRoot);
+                _printEdge(startNode);
                 break;
         }
         return ans;
@@ -1410,9 +1440,15 @@ class BinaryTree extends base_1.IterableEntryBase {
         this.bfs(node => {
             if (node === null)
                 cloned.add(null);
-            else
-                cloned.add([node.key, node.value]);
+            else {
+                if (this._isMapMode)
+                    cloned.add([node.key, this._store.get(node.key)]);
+                else
+                    cloned.add([node.key, node.value]);
+            }
         }, this._root, this.iterationType, true);
+        if (this._isMapMode)
+            cloned._store = this._store;
         return cloned;
     }
     /**
@@ -1479,7 +1515,7 @@ class BinaryTree extends base_1.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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} 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
@@ -1491,21 +1527,18 @@ class BinaryTree extends base_1.IterableEntryBase {
      * the lines to the output string. The final output string contains the visual representation of the
      * binary tree with the specified options.
      */
-    toVisual(beginRoot = this._root, options) {
-        const opts = Object.assign({ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false }, options);
-        beginRoot = this.ensureNode(beginRoot);
+    toVisual(startNode = this._root, options) {
+        const opts = Object.assign({ isShowUndefined: false, isShowNull: true, isShowRedBlackNIL: false }, options);
+        startNode = this.ensureNode(startNode);
         let output = '';
-        if (!beginRoot)
+        if (!startNode)
             return output;
         if (opts.isShowUndefined)
-            output += `U for undefined
-      `;
+            output += `U for undefined\n`;
         if (opts.isShowNull)
-            output += `N for null
-      `;
+            output += `N for null\n`;
         if (opts.isShowRedBlackNIL)
-            output += `S for Sentinel Node(NIL)
-      `;
+            output += `S for Sentinel Node(NIL)\n`;
         const display = (root) => {
             const [lines, , ,] = this._displayAux(root, opts);
             let paragraph = '';
@@ -1514,9 +1547,27 @@ class BinaryTree extends base_1.IterableEntryBase {
             }
             output += paragraph;
         };
-        display(beginRoot);
+        display(startNode);
         return output;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `print` in TypeScript overrides the default print behavior to log a visual
+     * representation of the binary tree to the console.
+     * @param {BinaryTreePrintOptions} [options] - The `options` parameter is used to specify the
+     * 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
+     * `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
+     */
+    print(options, startNode = this._root) {
+        console.log(this.toVisual(startNode, options));
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1525,13 +1576,13 @@ class BinaryTree extends base_1.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 `BTNCallback<OptBTNOrNull<NODE>>`. The default value for this parameter is `this._DEFAULT
+     * extends `NodeCallback<OptNodeOrNull<NODE>>`. 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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `_dfs`
+     * @param {BTNRep<K, V, NODE> | R} 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 `BTNKeyOrNodeOrEntry` object or a reference to the root node
+     * tree. It can be provided as either a `BTNRep` object or a reference to the root node
      * of the tree. If no specific
      * @param {IterationType} iterationType - The `iterationType` parameter in the `_dfs` method
      * specifies the type of iteration to be performed during the Depth-First Search (DFS) traversal of a
@@ -1559,13 +1610,13 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns The function `_dfs` returns an array of the return type of the callback function provided
      * as input.
      */
-    _dfs(callback = this._DEFAULT_BTN_CALLBACK, pattern = 'IN', beginRoot = this._root, iterationType = this.iterationType, includeNull = false, shouldVisitLeft = node => !!node, shouldVisitRight = node => !!node, shouldVisitRoot = node => {
+    _dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = 'IN', startNode = this._root, iterationType = this.iterationType, includeNull = false, shouldVisitLeft = node => !!node, shouldVisitRight = node => !!node, shouldVisitRoot = node => {
         if (includeNull)
             return this.isRealNodeOrNull(node);
         return this.isRealNode(node);
     }, shouldProcessRoot = node => this.isRealNodeOrNull(node)) {
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+        startNode = this.ensureNode(startNode);
+        if (!startNode)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
@@ -1601,10 +1652,10 @@ class BinaryTree extends base_1.IterableEntryBase {
                         break;
                 }
             };
-            dfs(beginRoot);
+            dfs(startNode);
         }
         else {
-            const stack = [{ opt: constants_1.DFSOperation.VISIT, node: beginRoot }];
+            const stack = [{ opt: constants_1.DFSOperation.VISIT, node: startNode }];
             const pushLeft = (cur) => {
                 var _a;
                 if (shouldVisitLeft(cur.node))
@@ -1680,7 +1731,10 @@ class BinaryTree extends base_1.IterableEntryBase {
                 }
                 current = stack.pop();
                 if (this.isRealNode(current)) {
-                    yield [current.key, current.value];
+                    if (this._isMapMode)
+                        yield [current.key, this._store.get(current.key)];
+                    else
+                        yield [current.key, current.value];
                     current = current.right;
                 }
             }
@@ -1689,7 +1743,10 @@ class BinaryTree extends base_1.IterableEntryBase {
             if (node.left && this.isRealNode(node)) {
                 yield* this[Symbol.iterator](node.left);
             }
-            yield [node.key, node.value];
+            if (this._isMapMode)
+                yield [node.key, this._store.get(node.key)];
+            else
+                yield [node.key, node.value];
             if (node.right && this.isRealNode(node)) {
                 yield* this[Symbol.iterator](node.right);
             }
@@ -1767,12 +1824,12 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(1)
      *
      * The _swapProperties function swaps key and value properties between two nodes in a binary tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} srcNode - The `srcNode` parameter in the
-     * `_swapProperties` method can be either a BTNKeyOrNodeOrEntry object containing key and value
+     * @param {BTNRep<K, V, NODE> | R} 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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} destNode - The `destNode` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} 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 `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`. The method ensures that
+     * the `srcNode`. It can be of type `BTNRep<K, V, NODE>` 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.
@@ -1785,9 +1842,11 @@ class BinaryTree extends base_1.IterableEntryBase {
             const tempNode = this.createNode(key, value);
             if (tempNode) {
                 destNode.key = srcNode.key;
-                destNode.value = srcNode.value;
+                if (!this._isMapMode)
+                    destNode.value = srcNode.value;
                 srcNode.key = tempNode.key;
-                srcNode.value = tempNode.value;
+                if (!this._isMapMode)
+                    srcNode.value = tempNode.value;
             }
             return destNode;
         }
@@ -1830,7 +1889,7 @@ class BinaryTree extends base_1.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 `OptBTNOrNull<NODE>`, which means
+     * @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`.
      */
     _setRoot(v) {
@@ -1845,45 +1904,112 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `_ensurePredicate` in TypeScript ensures that the input is converted into a valid
      * predicate function for a binary tree node.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrEntryOrRawOrPredicate - The
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
      * `_ensurePredicate` method in the provided code snippet is responsible for ensuring that the input
-     * parameter `keyOrEntryOrRawOrPredicate` is transformed into a valid predicate function that can be
+     * parameter `keyNodeEntryRawOrPredicate` is transformed into a valid predicate function that can be
      * used for filtering nodes in a binary tree.
-     * @returns A BTNPredicate<NODE> function is being returned.
+     * @returns A NodePredicate<NODE> function is being returned.
      */
-    _ensurePredicate(keyOrEntryOrRawOrPredicate) {
-        if (keyOrEntryOrRawOrPredicate === null || keyOrEntryOrRawOrPredicate === undefined)
+    _ensurePredicate(keyNodeEntryRawOrPredicate) {
+        if (keyNodeEntryRawOrPredicate === null || keyNodeEntryRawOrPredicate === undefined)
             return (node) => (node ? false : false);
-        if (this._isPredicated(keyOrEntryOrRawOrPredicate))
-            return keyOrEntryOrRawOrPredicate;
-        if (this.isRealNode(keyOrEntryOrRawOrPredicate))
-            return (node) => node === keyOrEntryOrRawOrPredicate;
-        if (this.isEntry(keyOrEntryOrRawOrPredicate)) {
-            const [key] = keyOrEntryOrRawOrPredicate;
+        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(keyOrEntryOrRawOrPredicate))
-            return (node) => node.key === keyOrEntryOrRawOrPredicate;
+        if (this.isKey(keyNodeEntryRawOrPredicate))
+            return (node) => node.key === keyNodeEntryRawOrPredicate;
         if (this._toEntryFn) {
-            const [key] = this._toEntryFn(keyOrEntryOrRawOrPredicate);
+            const [key] = this._toEntryFn(keyNodeEntryRawOrPredicate);
             return (node) => node.key === key;
         }
-        return (node) => node.key === keyOrEntryOrRawOrPredicate;
+        return (node) => node.key === keyNodeEntryRawOrPredicate;
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_isPredicated` checks if a given parameter is a function.
+     * 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 `_isPredicated` is checking if `p` is a function that
-     * satisfies the type `BTNPredicate<NODE>`.
+     * of value. In this context, the function `_isPredicate` is checking if `p` is a function that
+     * satisfies the type `NodePredicate<NODE>`.
      * @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`.
      */
-    _isPredicated(p) {
+    _isPredicate(p) {
         return typeof p === 'function';
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `_getKey` in TypeScript returns the key from a given input, which can be a node,
+     * entry, raw data, or null/undefined.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_getKey` method you provided is a
+     * TypeScript method that takes in a parameter `keyNodeEntryOrRaw` of type `BTNRep<K, V, NODE> | R`,
+     * where `BTNRep` is a generic type with keys `K`, `V`, and `NODE`, and `
+     * @returns The `_getKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
+     * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on
+     * the conditions checked in the method.
+     */
+    _getKey(keyNodeEntryOrRaw) {
+        if (keyNodeEntryOrRaw === null)
+            return null;
+        if (keyNodeEntryOrRaw === undefined)
+            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;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `_setValue` sets a value in a store based on a key, handling cases where the key or
+     * value is null or undefined.
+     * @param {K | null | undefined} key - The `key` parameter can be of type `K`, `null`, or
+     * `undefined`.
+     * @param {V | undefined} value - The `value` parameter in the `_setValue` method can be of type `V`
+     * or `undefined`.
+     * @returns The method `_setValue` returns `false` if either the `key` is `null` or `undefined`, or
+     * if the `value` is `undefined`. Otherwise, it returns the result of calling the `set` method on the
+     * `_store` object with the `key` and `value` arguments.
+     */
+    _setValue(key, value) {
+        if (key === null || key === undefined)
+            return false;
+        if (value === undefined)
+            return false;
+        return this._store.set(key, value);
+    }
+    /**
+     * The _clearNodes function sets the root node to undefined and resets the size to 0.
+     */
+    _clearNodes() {
+        this._setRoot(undefined);
+        this._size = 0;
+    }
+    /**
+     * The _clearValues function clears all values stored in the _store object.
+     */
+    _clearValues() {
+        this._store.clear();
+    }
 }
 exports.BinaryTree = BinaryTree;