data-structure-typed 1.52.9 → 1.53.1

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

@@ -19,7 +19,7 @@ export class BSTNode extends BinaryTreeNode {
     }
     /**
      * The function sets the left child of a node and updates the parent reference of the child.
-     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be an
+     * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be an
      * instance of the `NODE` class or `undefined`.
      */
     set left(v) {
@@ -39,7 +39,7 @@ export class BSTNode extends BinaryTreeNode {
     }
     /**
      * The function sets the right child of a node and updates the parent reference of the child.
-     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be a
+     * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be a
      * `NODE` object or `undefined`.
      */
     set right(v) {
@@ -61,21 +61,21 @@ export class BSTNode extends BinaryTreeNode {
 export class BST extends BinaryTree {
     /**
      * This is the constructor function for a Binary Search Tree class in TypeScript.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable that can contain either keys, nodes, entries, or raw elements. These elements will be
      * added to the binary search tree during the construction of the object.
      * @param [options] - An optional object that contains additional options for the Binary Search Tree.
      * It can include a comparator function that defines the order of the elements in the tree.
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
         super([], options);
         if (options) {
             const { comparator } = options;
             if (comparator)
                 this._comparator = comparator;
         }
-        if (keysOrNodesOrEntriesOrRaws)
-            this.addMany(keysOrNodesOrEntriesOrRaws);
+        if (keysNodesEntriesOrRaws)
+            this.addMany(keysNodesEntriesOrRaws);
     }
     _root = undefined;
     /**
@@ -94,7 +94,7 @@ export class BST extends BinaryTree {
      * @returns The method is returning a new instance of the BSTNode class, casted as the NODE type.
      */
     createNode(key, value) {
-        return new BSTNode(key, value);
+        return new BSTNode(key, this._isMapMode ? undefined : value);
     }
     /**
      * The function creates a new binary search tree with the specified options.
@@ -106,6 +106,7 @@ export class BST extends BinaryTree {
     createTree(options) {
         return new BST([], {
             iterationType: this.iterationType,
+            isMapMode: this._isMapMode,
             comparator: this._comparator,
             toEntryFn: this._toEntryFn,
             ...options
@@ -113,15 +114,18 @@ export class BST extends BinaryTree {
     }
     /**
      * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - A variable that can be of
-     * type R or BTNKeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
+     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
      * element.
      * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
      * value associated with a key in a key-value pair.
      * @returns either a NODE object or undefined.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value) {
-        return super.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value) ?? undefined;
+    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
+        const [node, entryValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+        if (node === null)
+            return [undefined, undefined];
+        return [node, value ?? entryValue];
     }
     /**
      * Time Complexity: O(log n)
@@ -129,8 +133,8 @@ export class BST extends BinaryTree {
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R`, which represents the key, node,
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept a value of type `R`, which represents the key, node,
      * entry, or raw element that needs to be ensured in the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
      * parameter that specifies the type of iteration to be used when ensuring a node. It has a default
@@ -138,18 +142,18 @@ export class BST extends BinaryTree {
      * @returns The method is returning either the node that was ensured or `undefined` if the node could
      * not be ensured.
      */
-    ensureNode(keyOrNodeOrEntryOrRaw, iterationType = this.iterationType) {
-        return super.ensureNode(keyOrNodeOrEntryOrRaw, iterationType) ?? undefined;
+    ensureNode(keyNodeEntryOrRaw, iterationType = this.iterationType) {
+        return super.ensureNode(keyNodeEntryOrRaw, iterationType) ?? undefined;
     }
     /**
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `BSTNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw) {
-        return keyOrNodeOrEntryOrRaw instanceof BSTNode;
+    isNode(keyNodeEntryOrRaw) {
+        return keyNodeEntryOrRaw instanceof BSTNode;
     }
     /**
      * The function "override isKey" checks if a key is comparable based on a given comparator.
@@ -167,18 +171,20 @@ export class BST extends BinaryTree {
      * Space Complexity: O(1)
      *
      * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key in the binary search tree. If provided, it will be stored in the node along with the key.
      * @returns a boolean value.
      */
-    add(keyOrNodeOrEntryOrRaw, value) {
-        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value);
+    add(keyNodeEntryOrRaw, value) {
+        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
         if (newNode === undefined)
             return false;
         if (this._root === undefined) {
             this._setRoot(newNode);
+            if (this._isMapMode)
+                this._setValue(newNode?.key, newValue);
             this._size++;
             return true;
         }
@@ -186,11 +192,15 @@ export class BST extends BinaryTree {
         while (current !== undefined) {
             if (this.comparator(current.key, newNode.key) === 0) {
                 this._replaceNode(current, newNode);
+                if (this._isMapMode)
+                    this._setValue(current.key, newValue);
                 return true;
             }
             else if (this.comparator(current.key, newNode.key) > 0) {
                 if (current.left === undefined) {
                     current.left = newNode;
+                    if (this._isMapMode)
+                        this._setValue(newNode?.key, newValue);
                     this._size++;
                     return true;
                 }
@@ -199,6 +209,8 @@ export class BST extends BinaryTree {
             else {
                 if (current.right === undefined) {
                     current.right = newNode;
+                    if (this._isMapMode)
+                        this._setValue(newNode?.key, newValue);
                     this._size++;
                     return true;
                 }
@@ -213,7 +225,7 @@ export class BST extends BinaryTree {
      *
      * The `addMany` function in TypeScript adds multiple keys or nodes to a data structure and returns
      * an array indicating whether each key or node was successfully inserted.
-     * @param keysOrNodesOrEntriesOrRaws - An iterable containing keys, nodes, entries, or raw
+     * @param keysNodesEntriesOrRaws - An iterable containing keys, nodes, entries, or raw
      * elements to be added to the data structure.
      * @param [values] - An optional iterable of values to be associated with the keys or nodes being
      * added. If provided, the values will be assigned to the corresponding keys or nodes in the same
@@ -228,14 +240,14 @@ export class BST extends BinaryTree {
      * @returns The function `addMany` returns an array of booleans indicating whether each element was
      * successfully inserted into the data structure.
      */
-    addMany(keysOrNodesOrEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
+    addMany(keysNodesEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
         const inserted = [];
         let valuesIterator;
         if (values) {
             valuesIterator = values[Symbol.iterator]();
         }
         if (!isBalanceAdd) {
-            for (const kve of keysOrNodesOrEntriesOrRaws) {
+            for (const kve of keysNodesEntriesOrRaws) {
                 const value = valuesIterator?.next().value;
                 inserted.push(this.add(kve, value));
             }
@@ -243,7 +255,7 @@ export class BST extends BinaryTree {
         }
         const realBTNExemplars = [];
         let i = 0;
-        for (const kve of keysOrNodesOrEntriesOrRaws) {
+        for (const kve of keysNodesEntriesOrRaws) {
             realBTNExemplars.push({ key: kve, value: valuesIterator?.next().value, orgIndex: i });
             i++;
         }
@@ -314,33 +326,33 @@ export class BST extends BinaryTree {
      * Space Complexity: O(k + log n)
      *
      * The function `getNodes` in TypeScript overrides the base class method to retrieve nodes based on a
-     * given predicate and iteration type.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * given keyNodeEntryRawOrPredicate and iteration type.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The `keyNodeEntryRawOrPredicate`
      * parameter in the `getNodes` method is used to filter the nodes that will be returned. It can be a
-     * key, a node, an entry, or a custom predicate function that determines whether a node should be
+     * key, a node, an entry, or a custom keyNodeEntryRawOrPredicate function that determines whether a node should be
      * included in the result.
      * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` method is a boolean flag that
-     * determines whether to return only the first node that matches the predicate (`true`) or all nodes
-     * that match the predicate (`false`). If `onlyOne` is set to `true`, the method will stop iterating
+     * determines whether to return only the first node that matches the keyNodeEntryRawOrPredicate (`true`) or all nodes
+     * that match the keyNodeEntryRawOrPredicate (`false`). If `onlyOne` is set to `true`, the method will stop iterating
      * and
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `getNodes` method is used to specify the starting point for traversing the tree when searching for
-     * nodes that match a given predicate. It represents the root node of the subtree where the search
+     * nodes that match a given keyNodeEntryRawOrPredicate. It represents the root node of the subtree where the search
      * should begin. If not explicitly provided, the default value for `begin
      * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` method
      * specifies the type of iteration to be performed when traversing the nodes of a binary tree. It can
      * have two possible values:
-     * @returns The `getNodes` method returns an array of nodes that satisfy the given predicate.
+     * @returns The `getNodes` method returns an array of nodes that satisfy the given keyNodeEntryRawOrPredicate.
      */
-    getNodes(predicate, onlyOne = false, beginRoot = this._root, iterationType = this.iterationType) {
-        if (predicate === undefined)
+    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+        if (keyNodeEntryRawOrPredicate === undefined)
             return [];
-        if (predicate === null)
+        if (keyNodeEntryRawOrPredicate === null)
             return [];
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+        startNode = this.ensureNode(startNode);
+        if (!startNode)
             return [];
-        const callback = this._ensurePredicate(predicate);
+        const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
@@ -351,10 +363,17 @@ export class BST extends BinaryTree {
                 }
                 if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                if (this.isKey(predicate)) {
-                    if (this.isRealNode(cur.left) && this.comparator(cur.key, predicate) > 0)
+                if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
+                    const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
+                    if (this.isRealNode(cur.left) &&
+                        benchmarkKey !== null &&
+                        benchmarkKey !== undefined &&
+                        this.comparator(cur.key, benchmarkKey) > 0)
                         dfs(cur.left);
-                    if (this.isRealNode(cur.right) && this.comparator(cur.key, predicate) < 0)
+                    if (this.isRealNode(cur.right) &&
+                        benchmarkKey !== null &&
+                        benchmarkKey !== undefined &&
+                        this.comparator(cur.key, benchmarkKey) < 0)
                         dfs(cur.right);
                 }
                 else {
@@ -364,10 +383,10 @@ export class BST extends BinaryTree {
                         dfs(cur.right);
                 }
             };
-            dfs(beginRoot);
+            dfs(startNode);
         }
         else {
-            const stack = [beginRoot];
+            const stack = [startNode];
             while (stack.length > 0) {
                 const cur = stack.pop();
                 if (callback(cur)) {
@@ -375,10 +394,17 @@ export class BST extends BinaryTree {
                     if (onlyOne)
                         return ans;
                 }
-                if (this.isKey(predicate)) {
-                    if (this.isRealNode(cur.right) && this.comparator(cur.key, predicate) < 0)
+                if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
+                    const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
+                    if (this.isRealNode(cur.right) &&
+                        benchmarkKey !== null &&
+                        benchmarkKey !== undefined &&
+                        this.comparator(cur.key, benchmarkKey) < 0)
                         stack.push(cur.right);
-                    if (this.isRealNode(cur.left) && this.comparator(cur.key, predicate) > 0)
+                    if (this.isRealNode(cur.left) &&
+                        benchmarkKey !== null &&
+                        benchmarkKey !== undefined &&
+                        this.comparator(cur.key, benchmarkKey) > 0)
                         stack.push(cur.left);
                 }
                 else {
@@ -395,10 +421,10 @@ export class BST extends BinaryTree {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * This function retrieves a node based on a given predicate within a binary search tree structure.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
-     * parameter can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>`, `R`, or `BTNPredicate<NODE>`.
-     * @param {R | BSTNKeyOrNode<K, NODE>} beginRoot - The `beginRoot` parameter in the `getNode` method
+     * This function retrieves a node based on a given keyNodeEntryRawOrPredicate within a binary search tree structure.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The `keyNodeEntryRawOrPredicate`
+     * parameter can be of type `BTNRep<K, V, NODE>`, `R`, or `NodePredicate<NODE>`.
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} startNode - The `startNode` parameter in the `getNode` method
      * is used to specify the starting point for searching nodes in the binary search tree. If no
      * specific starting point is provided, the default value is set to `this._root`, which is the root
      * node of the binary search tree.
@@ -406,13 +432,13 @@ export class BST extends BinaryTree {
      * parameter that specifies the type of iteration to be used. It has a default value of
      * `this.iterationType`, which means it will use the iteration type defined in the class instance if
      * no value is provided when calling the method.
-     * @returns The `getNode` method is returning an optional binary search tree node (`OptBSTN<NODE>`).
-     * It is using the `getNodes` method to find the node based on the provided predicate, beginning at
-     * the specified root node (`beginRoot`) and using the specified iteration type. The method then
+     * @returns The `getNode` method is returning an optional binary search tree node (`OptNode<NODE>`).
+     * It is using the `getNodes` method to find the node based on the provided keyNodeEntryRawOrPredicate, beginning at
+     * the specified root node (`startNode`) and using the specified iteration type. The method then
      * returns the first node found or `undefined` if no node is found.
      */
-    getNode(predicate, beginRoot = this._root, iterationType = this.iterationType) {
-        return this.getNodes(predicate, true, beginRoot, iterationType)[0] ?? undefined;
+    getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+        return this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0] ?? undefined;
     }
     /**
      * Time Complexity: O(log n)
@@ -438,11 +464,11 @@ export class BST extends BinaryTree {
      * the callback function.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * during the depth-first search traversal. It is an optional parameter and defaults to
-     * `this._DEFAULT_BTN_CALLBACK`. The type `C` represents the type of the callback function.
+     * `this._DEFAULT_NODE_CALLBACK`. The type `C` represents the type of the callback function.
      * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
      * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
      * take one of the following values:
-     * @param {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 the depth-first search traversal. It can be either a root node, a key-value pair, or a
      * node entry. If not specified, the default value is the root of the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
@@ -450,8 +476,8 @@ export class BST extends BinaryTree {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._DEFAULT_BTN_CALLBACK, pattern = 'IN', beginRoot = this._root, iterationType = this.iterationType) {
-        return super.dfs(callback, pattern, beginRoot, iterationType);
+    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = 'IN', startNode = this._root, iterationType = this.iterationType) {
+        return super.dfs(callback, pattern, startNode, iterationType);
     }
     /**
      * Time complexity: O(n)
@@ -462,7 +488,7 @@ export class BST extends BinaryTree {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * visited during the breadth-first search. It should take a single argument, which is the current
      * node being visited, and it can return a value of any type.
-     * @param {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 the breadth-first search. It can be either a root node, a key-value pair, or an entry
      * object. If no value is provided, the default value is the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -470,8 +496,8 @@ export class BST extends BinaryTree {
      * the following values:
      * @returns an array of the return type of the callback function.
      */
-    bfs(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-        return super.bfs(callback, beginRoot, iterationType, false);
+    bfs(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        return super.bfs(callback, startNode, iterationType, false);
     }
     /**
      * Time complexity: O(n)
@@ -480,9 +506,9 @@ export class BST extends BinaryTree {
      * The function overrides the listLevels method from the superclass and returns an array of arrays
      * containing the results of the callback function applied to each level of the tree.
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
-     * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the
+     * `NodeCallback<NODE>`. It represents a callback function that will be called for each node in the
      * tree during the iteration process.
-     * @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 listing the levels of the binary tree. It can be either a root node of the tree, a
      * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
      * value is provided, the root of
@@ -491,8 +517,8 @@ export class BST extends BinaryTree {
      * @returns The method is returning a two-dimensional array of the return type of the callback
      * function.
      */
-    listLevels(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-        return super.listLevels(callback, beginRoot, iterationType, false);
+    listLevels(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        return super.listLevels(callback, startNode, iterationType, false);
     }
     /**
      * Time complexity: O(n)
@@ -506,7 +532,7 @@ export class BST extends BinaryTree {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
      * 0, or 1, where:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} targetNode - The `targetNode` parameter is the node in
+     * @param {BTNRep<K, V, NODE> | R} targetNode - The `targetNode` parameter is the node in
      * the binary tree that you want to start traversing from. It can be specified either by providing
      * the key of the node, the node itself, or an entry containing the key and value of the node. If no
      * `targetNode` is provided,
@@ -515,7 +541,7 @@ export class BST extends BinaryTree {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._DEFAULT_BTN_CALLBACK, lesserOrGreater = -1, targetNode = this._root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._DEFAULT_NODE_CALLBACK, lesserOrGreater = -1, targetNode = this._root, iterationType = this.iterationType) {
         const targetNodeEnsured = this.ensureNode(targetNode);
         const ans = [];
         if (!this._root)
@@ -567,7 +593,7 @@ export class BST extends BinaryTree {
      */
     perfectlyBalance(iterationType = this.iterationType) {
         const sorted = this.dfs(node => node, 'IN'), n = sorted.length;
-        this.clear();
+        this._clearNodes();
         if (sorted.length < 1)
             return false;
         if (iterationType === 'RECURSIVE') {
@@ -576,7 +602,10 @@ export class BST extends BinaryTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add([midNode.key, midNode.value]);
+                if (this._isMapMode)
+                    this.add(midNode.key);
+                else
+                    this.add([midNode.key, midNode.value]);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -592,7 +621,10 @@ export class BST extends BinaryTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add([midNode.key, midNode.value]);
+                        if (this._isMapMode)
+                            this.add(midNode.key);
+                        else
+                            this.add([midNode.key, midNode.value]);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -679,7 +711,7 @@ export class BST extends BinaryTree {
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
-     * @param {OptBSTN<NODE>} v - v is a parameter of type NODE or undefined.
+     * @param {OptNode<NODE>} v - v is a parameter of type NODE or undefined.
      */
     _setRoot(v) {
         if (v) {

package/dist/mjs/data-structures/binary-tree/rb-tree.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryTreeDeleteResult, BTNKeyOrNodeOrEntry, CRUD, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested, BTNEntry } from '../../types';
+import type { BinaryTreeDeleteResult, BTNRep, CRUD, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
@@ -26,10 +26,10 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
      */
     set color(value: RBTNColor);
 }
-export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, R, NODE, TREE> = RedBlackTree<K, V, R, NODE, RedBlackTreeNested<K, V, R, NODE>>> extends BST<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class RedBlackTree<K = any, V = any, R = object, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, R, NODE, TREE> = RedBlackTree<K, V, R, NODE, RedBlackTreeNested<K, V, R, NODE>>> extends BST<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
      * initialize the RBTree with the provided elements.
      * @param [options] - The `options` parameter is an optional object that can be passed to the
@@ -37,7 +37,7 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
      * depend on the implementation
      */
-    constructor(keysOrNodesOrEntriesOrRaws?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: RBTreeOptions<K, V, R>);
+    constructor(keysNodesEntriesOrRaws?: Iterable<R | BTNRep<K, V, NODE>>, options?: RBTreeOptions<K, V, R>);
     protected _root: NODE | undefined;
     /**
      * The function returns the root node of a tree or undefined if there is no root.
@@ -71,12 +71,12 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `RedBlackTreeNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE;
+    isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -91,8 +91,8 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key in the data structure. It represents the value that you want to add or update in the data
      * structure.
@@ -100,14 +100,14 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * the method returns true. If the node already exists and its value is updated, the method also
      * returns true. If the node cannot be added or updated, the method returns false.
      */
-    add(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): boolean;
+    add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function overrides the delete method in a binary tree data structure to remove a node based on
      * a given predicate and maintain the binary search tree properties.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `keyOrNodeOrEntryOrRaw`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
      * parameter in the `override delete` method is used to specify the condition or key based on which a
      * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
      * function that determines which node(s) should be deleted.
@@ -115,7 +115,7 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * objects. Each object in the array contains information about the deleted node and whether
      * balancing is needed.
      */
-    delete(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[];
+    delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)