data-structure-typed 1.54.0 → 1.54.1

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

@@ -3,46 +3,33 @@ import { Queue } from '../queue';
 import { isComparable } from '../../utils';
 import { Range } from '../../common';
 export class BSTNode extends BinaryTreeNode {
-    parent;
+    /**
+     * This TypeScript constructor function initializes an instance with a key and an optional value.
+     * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
+     * within a data structure. It serves as a reference or identifier for accessing or manipulating the
+     * associated value.
+     * @param {V} [value] - The `value` parameter in the constructor is optional, meaning it does not
+     * have to be provided when creating an instance of the class. If a value is not provided, it will
+     * default to `undefined`.
+     */
     constructor(key, value) {
         super(key, value);
-        this.parent = undefined;
-        this._left = undefined;
-        this._right = undefined;
     }
-    _left;
-    /**
-     * The function returns the value of the `_left` property.
-     * @returns The `_left` property of the current object is being returned.
-     */
+    parent = undefined;
+    _left = undefined;
     get left() {
         return this._left;
     }
-    /**
-     * The function sets the left child of a node and updates the parent reference of the child.
-     * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be an
-     * instance of the `NODE` class or `undefined`.
-     */
     set left(v) {
         if (v) {
             v.parent = this;
         }
         this._left = v;
     }
-    _right;
-    /**
-     * The function returns the right node of a binary tree or undefined if there is no right node.
-     * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
-     * `undefined`.
-     */
+    _right = undefined;
     get right() {
         return this._right;
     }
-    /**
-     * The function sets the right child of a node and updates the parent reference of the child.
-     * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be a
-     * `NODE` object or `undefined`.
-     */
     set right(v) {
         if (v) {
             v.parent = this;
@@ -117,12 +104,13 @@ export class BSTNode extends BinaryTreeNode {
  */
 export class BST extends BinaryTree {
     /**
-     * This is the constructor function for a Binary Search Tree class in TypeScript.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
-     * iterable that can contain either keys, nodes, entries, or raw elements. These elements will be
-     * added to the binary search tree during the construction of the object.
-     * @param [options] - An optional object that contains additional options for the Binary Search Tree.
-     * It can include a comparator function that defines the order of the elements in the tree.
+     * This TypeScript constructor initializes a binary search tree with optional options and adds
+     * elements if provided.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain elements of type `BTNRep<K, V, BSTNode<K, V>>` or `R`. It is used to
+     * initialize the binary search tree with keys, nodes, entries, or raw data.
+     * @param [options] - The `options` parameter is an optional object that can contain the following
+     * properties:
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
         super([], options);
@@ -137,34 +125,58 @@ export class BST extends BinaryTree {
             this.addMany(keysNodesEntriesOrRaws);
     }
     _root = undefined;
-    /**
-     * The function returns the root node of a tree structure.
-     * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
-     */
     get root() {
         return this._root;
     }
     _isReverse = false;
-    /**
-     * The above function is a getter method in TypeScript that returns the value of the private property
-     * `_isReverse`.
-     * @returns The `isReverse` property of the object, which is a boolean value.
-     */
     get isReverse() {
         return this._isReverse;
     }
+    _comparator = (a, b) => {
+        if (isComparable(a) && isComparable(b)) {
+            if (a > b)
+                return 1;
+            if (a < b)
+                return -1;
+            return 0;
+        }
+        if (this._specifyComparable) {
+            if (this._specifyComparable(a) > this._specifyComparable(b))
+                return 1;
+            if (this._specifyComparable(a) < this._specifyComparable(b))
+                return -1;
+            return 0;
+        }
+        if (typeof a === 'object' || typeof b === 'object') {
+            throw TypeError(`When comparing object types, a custom specifyComparable must be defined in the constructor's options parameter.`);
+        }
+        return 0;
+    };
+    get comparator() {
+        return this._comparator;
+    }
+    _specifyComparable;
+    get specifyComparable() {
+        return this._specifyComparable;
+    }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new BSTNode with the given key and value and returns it.
      * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
      * being created.
      * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
      * value associated with the key in the node being created.
-     * @returns The method is returning a new instance of the BSTNode class, casted as the NODE type.
+     * @returns The method is returning a new instance of the BSTNode class, casted as the BSTNode<K, V> type.
      */
     createNode(key, value) {
         return new BSTNode(key, this._isMapMode ? undefined : value);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new binary search tree with the specified options.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
      * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which has the
@@ -181,29 +193,14 @@ export class BST extends BinaryTree {
             ...options
         });
     }
-    /**
-     * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
-     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
-     * element.
-     * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
-     * value associated with a key in a key-value pair.
-     * @returns either a NODE object or undefined.
-     */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
-        const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
-        if (node === null)
-            return [undefined, undefined];
-        return [node, value ?? entryValue];
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can accept a value of type `R`, which represents the key, node,
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept a value of type `R`, which represents the key, node,
      * entry, or raw element that needs to be ensured in the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
      * parameter that specifies the type of iteration to be used when ensuring a node. It has a default
@@ -211,43 +208,49 @@ 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(keyNodeEntryOrRaw, iterationType = this.iterationType) {
-        return super.ensureNode(keyNodeEntryOrRaw, iterationType) ?? undefined;
+    ensureNode(keyNodeOrEntry, iterationType = this.iterationType) {
+        return super.ensureNode(keyNodeOrEntry, iterationType) ?? undefined;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, BSTNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `BSTNode` class.
      */
-    isNode(keyNodeEntryOrRaw) {
-        return keyNodeEntryOrRaw instanceof BSTNode;
+    isNode(keyNodeOrEntry) {
+        return keyNodeOrEntry instanceof BSTNode;
     }
     /**
-     * The function "override isKey" checks if a key is comparable based on a given comparator.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function "override isValidKey" checks if a key is comparable based on a given comparator.
      * @param {any} key - The `key` parameter is a value that will be checked to determine if it is of
      * type `K`.
-     * @returns The `override isKey(key: any): key is K` function is returning a boolean value based on
+     * @returns The `override isValidKey(key: any): key is K` function is returning a boolean value based on
      * the result of the `isComparable` function with the condition `this._compare !==
      * this._DEFAULT_COMPARATOR`.
      */
-    isKey(key) {
+    isValidKey(key) {
         return isComparable(key, this._specifyComparable !== undefined);
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept a value of type `R` or `BTNRep<K, V, BSTNode<K, V>>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key in the binary search tree. If provided, it will be stored in the node along with the key.
      * @returns a boolean value.
      */
-    add(keyNodeEntryOrRaw, value) {
-        const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    add(keyNodeOrEntry, value) {
+        const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
         if (newNode === undefined)
             return false;
         if (this._root === undefined) {
@@ -318,8 +321,10 @@ export class BST extends BinaryTree {
             valuesIterator = values[Symbol.iterator]();
         }
         if (!isBalanceAdd) {
-            for (const kve of keysNodesEntriesOrRaws) {
+            for (let kve of keysNodesEntriesOrRaws) {
                 const value = valuesIterator?.next().value;
+                if (this.isRaw(kve))
+                    kve = this._toEntryFn(kve);
                 inserted.push(this.add(kve, value));
             }
             return inserted;
@@ -333,23 +338,21 @@ export class BST extends BinaryTree {
         let sorted = [];
         sorted = realBTNExemplars.sort(({ key: a }, { key: b }) => {
             let keyA, keyB;
-            if (this.isEntry(a))
+            if (this.isRaw(a))
+                keyA = this._toEntryFn(a)[0];
+            else if (this.isEntry(a))
                 keyA = a[0];
             else if (this.isRealNode(a))
                 keyA = a.key;
-            else if (this._toEntryFn) {
-                keyA = this._toEntryFn(a)[0];
-            }
             else {
                 keyA = a;
             }
-            if (this.isEntry(b))
+            if (this.isRaw(b))
+                keyB = this._toEntryFn(b)[0];
+            else if (this.isEntry(b))
                 keyB = b[0];
             else if (this.isRealNode(b))
                 keyB = b.key;
-            else if (this._toEntryFn) {
-                keyB = this._toEntryFn(b)[0];
-            }
             else {
                 keyB = b;
             }
@@ -362,7 +365,13 @@ export class BST extends BinaryTree {
             if (arr.length === 0)
                 return;
             const mid = Math.floor((arr.length - 1) / 2);
-            const { key, value, orgIndex } = arr[mid];
+            let { key, value } = arr[mid];
+            const { orgIndex } = arr[mid];
+            if (this.isRaw(key)) {
+                const entry = this._toEntryFn(key);
+                key = entry[0];
+                value = entry[1] ?? value;
+            }
             inserted[orgIndex] = this.add(key, value);
             _dfs(arr.slice(0, mid));
             _dfs(arr.slice(mid + 1));
@@ -376,7 +385,13 @@ export class BST extends BinaryTree {
                     const [l, r] = popped;
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
-                        const { key, value, orgIndex } = sorted[m];
+                        let { key, value } = sorted[m];
+                        const { orgIndex } = sorted[m];
+                        if (this.isRaw(key)) {
+                            const entry = this._toEntryFn(key);
+                            key = entry[0];
+                            value = entry[1] ?? value;
+                        }
                         inserted[orgIndex] = this.add(key, value);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -398,17 +413,17 @@ export class BST extends BinaryTree {
      *
      * The function `search` in TypeScript overrides the search behavior in a binary tree structure based
      * on specified criteria.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
-     * `keyNodeEntryRawOrPredicate` parameter in the `override search` method can accept one of the
+     * @param {BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The
+     * `keyNodeEntryOrPredicate` parameter in the `override search` method can accept one of the
      * following types:
      * @param [onlyOne=false] - The `onlyOne` parameter is a boolean flag that determines whether the
      * search should stop after finding the first matching node. If `onlyOne` is set to `true`, the
      * search will return as soon as a matching node is found. If `onlyOne` is set to `false`, the
      * @param {C} callback - The `callback` parameter in the `override search` function is a function
      * that will be called on each node that matches the search criteria. It is of type `C`, which
-     * extends `NodeCallback<NODE>`. The callback function should accept a node of type `NODE` as its
+     * extends `NodeCallback<BSTNode<K, V>>`. The callback function should accept a node of type `BSTNode<K, V>` as its
      * argument and
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `override search`
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter in the `override search`
      * method represents the node from which the search operation will begin. It is the starting point
      * for searching within the tree data structure. The method ensures that the `startNode` is a valid
      * node before proceeding with the search operation. If the `
@@ -420,26 +435,26 @@ export class BST extends BinaryTree {
      * structure based on the provided key, predicate, and other options. The search results are
      * collected in an array and returned as the output of the method.
      */
-    search(keyNodeEntryRawOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-        if (keyNodeEntryRawOrPredicate === undefined)
+    search(keyNodeEntryOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        if (keyNodeEntryOrPredicate === undefined)
             return [];
-        if (keyNodeEntryRawOrPredicate === null)
+        if (keyNodeEntryOrPredicate === null)
             return [];
         startNode = this.ensureNode(startNode);
         if (!startNode)
             return [];
         let predicate;
-        const isRange = this.isRange(keyNodeEntryRawOrPredicate);
+        const isRange = this.isRange(keyNodeEntryOrPredicate);
         // Set predicate based on parameter type
         if (isRange) {
-            predicate = node => keyNodeEntryRawOrPredicate.isInRange(node.key, this._comparator);
+            predicate = node => keyNodeEntryOrPredicate.isInRange(node.key, this._comparator);
         }
         else {
-            predicate = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+            predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
         }
         const isToLeftByRange = (cur) => {
             if (isRange) {
-                const range = keyNodeEntryRawOrPredicate;
+                const range = keyNodeEntryOrPredicate;
                 const leftS = this.isReverse ? range.high : range.low;
                 const leftI = this.isReverse ? range.includeHigh : range.includeLow;
                 return (leftI && this._compare(cur.key, leftS) >= 0) || (!leftI && this._compare(cur.key, leftS) > 0);
@@ -448,7 +463,7 @@ export class BST extends BinaryTree {
         };
         const isToRightByRange = (cur) => {
             if (isRange) {
-                const range = keyNodeEntryRawOrPredicate;
+                const range = keyNodeEntryOrPredicate;
                 const rightS = this.isReverse ? range.low : range.high;
                 const rightI = this.isReverse ? range.includeLow : range.includeLow;
                 return (rightI && this._compare(cur.key, rightS) <= 0) || (!rightI && this._compare(cur.key, rightS) < 0);
@@ -471,8 +486,8 @@ export class BST extends BinaryTree {
                     if (this.isRealNode(cur.right) && isToRightByRange(cur))
                         dfs(cur.right);
                 }
-                else if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-                    const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
+                else if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+                    const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
                     if (this.isRealNode(cur.left) &&
                         benchmarkKey !== null &&
                         benchmarkKey !== undefined &&
@@ -508,8 +523,8 @@ export class BST extends BinaryTree {
                     if (this.isRealNode(cur.right) && isToRightByRange(cur))
                         stack.push(cur.right);
                 }
-                else if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-                    const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
+                else if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+                    const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
                     if (this.isRealNode(cur.right) &&
                         benchmarkKey !== null &&
                         benchmarkKey !== undefined &&
@@ -533,16 +548,16 @@ export class BST extends BinaryTree {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(k + log n)
      *
      * The `rangeSearch` function searches for nodes within a specified range in a binary search tree.
      * @param {Range<K> | [K, K]} range - The `range` parameter in the `rangeSearch` function can be
      * either a `Range` object or an array of two elements representing the range boundaries.
      * @param {C} callback - The `callback` parameter in the `rangeSearch` function is a callback
      * function that is used to process each node that is found within the specified range during the
-     * search operation. It is of type `NodeCallback<NODE>`, where `NODE` is the type of nodes in the
+     * search operation. It is of type `NodeCallback<BSTNode<K, V>>`, where `BSTNode<K, V>` is the type of nodes in the
      * data structure.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `rangeSearch`
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter in the `rangeSearch`
      * function represents the node from which the search for nodes within the specified range will
      * begin. It is the starting point for the range search operation.
      * @param {IterationType} iterationType - The `iterationType` parameter in the `rangeSearch` function
@@ -558,12 +573,12 @@ export class BST extends BinaryTree {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
-     * This function retrieves a node based on a given keyNodeEntryRawOrPredicate within a binary search tree structure.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The `keyNodeEntryRawOrPredicate`
-     * parameter can be of type `BTNRep<K, V, NODE>`, `R`, or `NodePredicate<NODE>`.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} startNode - The `startNode` parameter in the `getNode` method
+     * This function retrieves a node based on a given keyNodeEntryOrPredicate within a binary search tree structure.
+     * @param {BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The `keyNodeEntryOrPredicate`
+     * parameter can be of type `BTNRep<K, V, BSTNode<K, V>>`, `R`, or `NodePredicate<BSTNode<K, V>>`.
+     * @param {BSTNOptKeyOrNode<K, BSTNode<K, V>>} startNode - The `startNode` parameter in the `getNode` method
      * is used to specify the starting point for searching nodes in the binary search tree. If no
      * specific starting point is provided, the default value is set to `this._root`, which is the root
      * node of the binary search tree.
@@ -571,13 +586,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 (`OptNode<NODE>`).
-     * It is using the `getNodes` method to find the node based on the provided keyNodeEntryRawOrPredicate, beginning at
+     * @returns The `getNode` method is returning an optional binary search tree node (`OptNode<BSTNode<K, V>>`).
+     * It is using the `getNodes` method to find the node based on the provided keyNodeEntryOrPredicate, beginning at
      * the specified root node (`startNode`) and using the specified iteration type. The method then
      * returns the first node found or `undefined` if no node is found.
      */
-    getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-        return this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0] ?? undefined;
+    getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+        return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? undefined;
     }
     /**
      * Time complexity: O(n)
@@ -591,7 +606,7 @@ export class BST extends BinaryTree {
      * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
      * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
      * take one of the following values:
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
      * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
      * node entry. If not specified, the default value is the root of the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
@@ -611,7 +626,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 {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
      * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
      * object. If no value is provided, the default value is the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -629,9 +644,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
-     * `NodeCallback<NODE>`. It represents a callback function that will be called for each node in the
+     * `NodeCallback<BSTNode<K, V>>`. It represents a callback function that will be called for each node in the
      * tree during the iteration process.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
      * point for listing the levels of the binary tree. It can be either a root node of the tree, a
      * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
      * value is provided, the root of
@@ -655,7 +670,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 {BTNRep<K, V, NODE> | R} targetNode - The `targetNode` parameter is the node in
+     * @param {BTNRep<K, V, BSTNode<K, V>>} targetNode - The `targetNode` parameter is the node in
      * the binary tree that you want to start traversing from. It can be specified either by providing
      * the key of the node, the node itself, or an entry containing the key and value of the node. If no
      * `targetNode` is provided,
@@ -815,46 +830,71 @@ export class BST extends BinaryTree {
         }
         return balanced;
     }
-    _comparator = (a, b) => {
-        if (isComparable(a) && isComparable(b)) {
-            if (a > b)
-                return 1;
-            if (a < b)
-                return -1;
-            return 0;
-        }
-        if (this._specifyComparable) {
-            if (this._specifyComparable(a) > this._specifyComparable(b))
-                return 1;
-            if (this._specifyComparable(a) < this._specifyComparable(b))
-                return -1;
-            return 0;
-        }
-        if (typeof a === 'object' || typeof b === 'object') {
-            throw TypeError(`When comparing object types, a custom specifyComparable must be defined in the constructor's options parameter.`);
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default map behavior for a binary search tree by
+     * applying a callback function to each entry and creating a new tree with the results.
+     * @param callback - A function that will be called for each entry in the BST. It takes four
+     * arguments: the key, the value (which can be undefined), the index of the entry, and a reference to
+     * the BST itself.
+     * @param [options] - The `options` parameter in the `override map` method is of type `BSTOptions<MK,
+     * MV, MR>`. It is an optional parameter that allows you to specify additional options for the Binary
+     * Search Tree (BST) being created in the `map` method. These options could include configuration
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` method is used to specify
+     * the value of `this` that should be used when executing the `callback` function. It allows you to
+     * set the context or scope in which the callback function will be called. This can be useful when
+     * you want
+     * @returns The `map` method is returning a new Binary Search Tree (`BST`) instance with the entries
+     * transformed by the provided callback function.
+     */
+    map(callback, options, thisArg) {
+        const newTree = new BST([], options);
+        let index = 0;
+        for (const [key, value] of this) {
+            newTree.add(callback.call(thisArg, key, value, index++, this));
         }
-        return 0;
-    };
+        return newTree;
+    }
     /**
-     * The function returns the value of the _comparator property.
-     * @returns The `_comparator` property is being returned.
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+     * structure.
+     * @returns The `cloned` object is being returned.
      */
-    get comparator() {
-        return this._comparator;
+    clone() {
+        const cloned = this.createTree();
+        this._clone(cloned);
+        return cloned;
     }
-    _specifyComparable;
     /**
-     * This function returns the value of the `_specifyComparable` property.
-     * @returns The method `specifyComparable()` is being returned, which is a getter method for the
-     * `_specifyComparable` property.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function overrides a method and converts a key, value pair or entry or raw element to a node.
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - A variable that can be of
+     * type R or BTNRep<K, V, BSTNode<K, V>>. It represents either a key, a node, an entry, or a raw
+     * element.
+     * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
+     * value associated with a key in a key-value pair.
+     * @returns either a BSTNode<K, V> object or undefined.
      */
-    get specifyComparable() {
-        return this._specifyComparable;
+    _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value) {
+        const [node, entryValue] = super._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
+        if (node === null)
+            return [undefined, undefined];
+        return [node, value ?? entryValue];
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
-     * @param {OptNode<NODE>} v - v is a parameter of type NODE or undefined.
+     * @param {OptNode<BSTNode<K, V>>} v - v is a parameter of type BSTNode<K, V> or undefined.
      */
     _setRoot(v) {
         if (v) {
@@ -862,16 +902,22 @@ export class BST extends BinaryTree {
         }
         this._root = v;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The _compare function compares two values using a specified comparator function and optionally
+     * reverses the result.
+     * @param {K} a - The parameter `a` is of type `K`, which is used as an input for comparison in the
+     * `_compare` method.
+     * @param {K} b - The parameter `b` in the `_compare` function is of type `K`.
+     * @returns The `_compare` method is returning the result of the ternary expression. If `_isReverse`
+     * is true, it returns the negation of the result of calling the `_comparator` function with
+     * arguments `a` and `b`. If `_isReverse` is false, it returns the result of calling the
+     * `_comparator` function with arguments `a` and `b`.
+     */
     _compare(a, b) {
         return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
     }
-    map(callback, options, thisArg) {
-        const newTree = new BST([], options);
-        let index = 0;
-        for (const [key, value] of this) {
-            newTree.add(callback.call(thisArg, key, value, index++, this));
-        }
-        return newTree;
-    }
 }
 //# sourceMappingURL=bst.js.map