directed-graph-typed 1.48.0 → 1.49.0

package/dist/data-structures/binary-tree/bst.d.ts

@@ -5,13 +5,13 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNKey, BTNodeExemplar, Comparator } from '../../types';
-import { CP, IterationType } from '../../types';
+import type { BSTNested, BSTNodeKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNodeExemplar } from '../../types';
+import { BSTVariant, BTNodeKeyOrNode, CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
-export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
+export declare class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, N> {
     parent?: N;
-    constructor(key: BTNKey, value?: V);
+    constructor(key: K, value?: V);
     protected _left?: N;
     /**
      * Get the left child node.
@@ -42,7 +42,7 @@ export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
  */
-export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>, TREE extends BST<V, N, TREE> = BST<V, N, BSTNested<V, N>>> extends BinaryTree<V, N, TREE> implements IBinaryTree<V, N, TREE> {
+export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, N, TREE> = BST<K, V, N, BSTNested<K, V, N>>> extends BinaryTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
      * the tree with optional elements and options.
@@ -51,19 +51,20 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
-    constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<BSTOptions>);
+    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<BSTOptions<K>>);
     protected _root?: N;
     get root(): N | undefined;
-    comparator: Comparator<BTNKey>;
+    protected _variant: BSTVariant;
+    get variant(): BSTVariant;
     /**
      * The function creates a new binary search tree node with the given key and value.
-     * @param {BTNKey} key - The key parameter is the key value that will be associated with
+     * @param {K} key - The key parameter is the key value that will be associated with
      * the new node. It is used to determine the position of the node in the binary search tree.
      * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It
      * represents the value associated with the node in a binary search tree.
      * @returns a new instance of the BSTNode class with the specified key and value.
      */
-    createNode(key: BTNKey, value?: V): N;
+    createNode(key: K, value?: V): N;
     /**
      * 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
@@ -71,20 +72,22 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * that defines various options for creating a binary search tree.
      * @returns a new instance of the BST class with the specified options.
      */
-    createTree(options?: Partial<BSTOptions>): TREE;
+    createTree(options?: Partial<BSTOptions<K>>): TREE;
     /**
      * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
      */
-    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
+    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
     /**
-     * The function `exemplarToNode` takes an exemplar and returns a corresponding node if the exemplar
-     * is valid, otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
-     * @returns a variable `node` which is of type `N` or `undefined`.
+     * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
+     * otherwise it returns undefined.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
+     * `exemplarToNode` function. It represents the value associated with the exemplar node.
+     * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<V, N>): N | undefined;
+    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -93,13 +96,15 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
      *
-     * The `add` function adds a new node to a binary search tree, either by key or by providing a node
-     * object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
-     * @returns The method returns either the newly added node (`newNode`) or `undefined` if the input
-     * (`keyOrNodeOrEntry`) is null, undefined, or does not match any of the expected types.
+     * The `add` function adds a new node to a binary tree, updating the value if the key already exists
+     * or inserting a new node if the key is unique.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
+     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
+     * being added to the binary tree.
+     * @returns The method `add` returns either the newly added node (`newNode`) or `undefined` if the
+     * node was not added.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | undefined;
+    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
      * Space Complexity: O(k) - Additional space is required for the sorted array.
@@ -108,19 +113,23 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
      * Space Complexity: O(k) - Additional space is required for the sorted array.
      *
-     * The `addMany` function in TypeScript adds multiple nodes to a binary tree, either in a balanced or
-     * unbalanced manner, and returns an array of the inserted nodes.
-     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries to be added to the
-     * binary tree.
-     * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
-     * adding the nodes. The default value is true.
+     * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
+     * balancing the tree after each addition.
+     * @param keysOrNodesOrEntries - An iterable containing the keys, nodes, or entries to be added to
+     * the binary tree.
+     * @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
+     * order. If not provided, undefined will be assigned as the value for each key or node.
+     * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
+     * balanced or not. If set to true, the add operation will be balanced using a binary search tree
+     * algorithm. If set to false, the add operation will not be balanced and the elements will be added
+     * in the order they appear in the input.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when adding multiple keys or nodes to the binary tree. It has a default
-     * value of `this.iterationType`, which means it will use the iteration type specified by the binary
-     * tree instance.
-     * @returns The `addMany` function returns an array of `N` or `undefined` values.
+     * type of iteration to use when adding multiple keys or nodes. It has a default value of
+     * `this.iterationType`, which suggests that it is a property of the current object.
+     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<V, N>>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
     /**
      * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
      * Space Complexity: O(n) - Additional space is required for the sorted array.
@@ -131,8 +140,8 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      *
      * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
      * leftmost node if the comparison result is greater than.
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `BTNKey`, `N`, or `undefined`. It represents the starting point for finding the last key in
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
+     * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
      * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
      * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
      * be performed. It can have one of the following values:
@@ -140,7 +149,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey(beginRoot?: BSTNodeKeyOrNode<N>, iterationType?: IterationType): BTNKey;
+    lastKey(beginRoot?: BSTNodeKeyOrNode<K, N>): K | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.
@@ -151,7 +160,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      *
      * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
      * either recursive or iterative methods.
-     * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
      * It is used to identify the node that we want to retrieve.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when searching for a node in the binary tree. It can have two possible
@@ -159,7 +168,14 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns The function `getNodeByKey` returns a node (`N`) if a node with the specified key is
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
-    getNodeByKey(key: BTNKey, iterationType?: IterationType): N | undefined;
+    getNodeByKey(key: K, iterationType?: IterationType): N | undefined;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -167,13 +183,13 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
     /**
      * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
      * otherwise it returns the key itself.
-     * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
+     * @param {K | N | undefined} key - The `key` parameter can be of type `K`, `N`, or
      * `undefined`.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
-    ensureNode(key: BSTNodeKeyOrNode<N>, iterationType?: IterationType): N | undefined;
+    ensureNode(key: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -190,14 +206,14 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * first node that matches the identifier. If set to true, the function will return an array
      * containing only the first matching node. If set to false (default), the function will continue
      * searching for all nodes that match the identifier and return an array containing
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
      * for the traversal. It can be either a key value or a node object. If it is undefined, the
      * traversal will start from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`N[]`).
      */
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BSTNodeKeyOrNode<N>, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): N[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -215,7 +231,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It is of type
      * `CP`, which is a custom type representing the comparison operator. The possible values for
      * `lesserOrGreater` are
-     * @param {BTNKey | N | undefined} targetNode - The `targetNode` parameter represents the node in the
+     * @param {K | N | undefined} targetNode - The `targetNode` parameter represents the node in the
      * binary tree that you want to traverse from. It can be specified either by its key, by the node
      * object itself, or it can be left undefined to start the traversal from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
@@ -223,7 +239,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @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<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BSTNodeKeyOrNode<N>, iterationType?: IterationType): ReturnType<C>[];
+    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -267,10 +283,10 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
     /**
      * The function compares two values using a comparator function and returns whether the first value
      * is greater than, less than, or equal to the second value.
-     * @param {BTNKey} a - The parameter "a" is of type BTNKey.
-     * @param {BTNKey} b - The parameter "b" in the above code represents a BTNKey.
+     * @param {K} a - The parameter "a" is of type K.
+     * @param {K} b - The parameter "b" in the above code represents a K.
      * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater
      * than), CP.lt (less than), or CP.eq (equal).
      */
-    protected _compare(a: BTNKey, b: BTNKey): CP;
+    protected _compare(a: K, b: K): CP;
 }

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

@@ -65,11 +65,11 @@ class BST extends binary_tree_1.BinaryTree {
      */
     constructor(elements, options) {
         super([], options);
-        this.comparator = (a, b) => a - b;
+        this._variant = types_1.BSTVariant.MIN;
         if (options) {
-            const { comparator } = options;
-            if (comparator) {
-                this.comparator = comparator;
+            const { variant } = options;
+            if (variant) {
+                this._variant = variant;
             }
         }
         this._root = undefined;
@@ -79,9 +79,12 @@ class BST extends binary_tree_1.BinaryTree {
     get root() {
         return this._root;
     }
+    get variant() {
+        return this._variant;
+    }
     /**
      * The function creates a new binary search tree node with the given key and value.
-     * @param {BTNKey} key - The key parameter is the key value that will be associated with
+     * @param {K} key - The key parameter is the key value that will be associated with
      * the new node. It is used to determine the position of the node in the binary search tree.
      * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It
      * represents the value associated with the node in a binary search tree.
@@ -98,23 +101,25 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns a new instance of the BST class with the specified options.
      */
     createTree(options) {
-        return new BST([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
+        return new BST([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
     }
     /**
      * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
      */
     isNode(exemplar) {
         return exemplar instanceof BSTNode;
     }
     /**
-     * The function `exemplarToNode` takes an exemplar and returns a corresponding node if the exemplar
-     * is valid, otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
-     * @returns a variable `node` which is of type `N` or `undefined`.
+     * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
+     * otherwise it returns undefined.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
+     * `exemplarToNode` function. It represents the value associated with the exemplar node.
+     * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar) {
+    exemplarToNode(exemplar, value) {
         let node;
         if (exemplar === null || exemplar === undefined) {
             return;
@@ -131,8 +136,8 @@ class BST extends binary_tree_1.BinaryTree {
                 node = this.createNode(key, value);
             }
         }
-        else if (this.isNodeKey(exemplar)) {
-            node = this.createNode(exemplar);
+        else if (this.isNotNodeInstance(exemplar)) {
+            node = this.createNode(exemplar, value);
         }
         else {
             return;
@@ -147,14 +152,16 @@ class BST extends binary_tree_1.BinaryTree {
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
      *
-     * The `add` function adds a new node to a binary search tree, either by key or by providing a node
-     * object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
-     * @returns The method returns either the newly added node (`newNode`) or `undefined` if the input
-     * (`keyOrNodeOrEntry`) is null, undefined, or does not match any of the expected types.
+     * The `add` function adds a new node to a binary tree, updating the value if the key already exists
+     * or inserting a new node if the key is unique.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
+     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
+     * being added to the binary tree.
+     * @returns The method `add` returns either the newly added node (`newNode`) or `undefined` if the
+     * node was not added.
      */
-    add(keyOrNodeOrEntry) {
-        const newNode = this.exemplarToNode(keyOrNodeOrEntry);
+    add(keyOrNodeOrEntry, value) {
+        const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
         if (newNode === undefined)
             return;
         if (this.root === undefined) {
@@ -204,23 +211,32 @@ class BST extends binary_tree_1.BinaryTree {
      * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
      * Space Complexity: O(k) - Additional space is required for the sorted array.
      *
-     * The `addMany` function in TypeScript adds multiple nodes to a binary tree, either in a balanced or
-     * unbalanced manner, and returns an array of the inserted nodes.
-     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries to be added to the
-     * binary tree.
-     * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
-     * adding the nodes. The default value is true.
+     * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
+     * balancing the tree after each addition.
+     * @param keysOrNodesOrEntries - An iterable containing the keys, nodes, or entries to be added to
+     * the binary tree.
+     * @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
+     * order. If not provided, undefined will be assigned as the value for each key or node.
+     * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
+     * balanced or not. If set to true, the add operation will be balanced using a binary search tree
+     * algorithm. If set to false, the add operation will not be balanced and the elements will be added
+     * in the order they appear in the input.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when adding multiple keys or nodes to the binary tree. It has a default
-     * value of `this.iterationType`, which means it will use the iteration type specified by the binary
-     * tree instance.
-     * @returns The `addMany` function returns an array of `N` or `undefined` values.
+     * type of iteration to use when adding multiple keys or nodes. It has a default value of
+     * `this.iterationType`, which suggests that it is a property of the current object.
+     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodesOrEntries, isBalanceAdd = true, iterationType = this.iterationType) {
+    addMany(keysOrNodesOrEntries, values, isBalanceAdd = true, iterationType = this.iterationType) {
         const inserted = [];
+        let valuesIterator;
+        if (values) {
+            valuesIterator = values[Symbol.iterator]();
+        }
         if (!isBalanceAdd) {
             for (const kve of keysOrNodesOrEntries) {
-                const nn = this.add(kve);
+                const value = valuesIterator === null || valuesIterator === void 0 ? void 0 : valuesIterator.next().value;
+                const nn = this.add(kve, value);
                 inserted.push(nn);
             }
             return inserted;
@@ -234,22 +250,21 @@ class BST extends binary_tree_1.BinaryTree {
         for (const kve of keysOrNodesOrEntries) {
             isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
         }
-        // TODO this addMany function is inefficient, it should be optimized
         let sorted = [];
         sorted = realBTNExemplars.sort((a, b) => {
             let aR, bR;
             if (this.isEntry(a))
-                aR = a[0];
+                aR = this.extractor(a[0]);
             else if (this.isRealNode(a))
-                aR = a.key;
+                aR = this.extractor(a.key);
             else
-                aR = a;
+                aR = this.extractor(a);
             if (this.isEntry(b))
-                bR = b[0];
+                bR = this.extractor(b[0]);
             else if (this.isRealNode(b))
-                bR = b.key;
+                bR = this.extractor(b.key);
             else
-                bR = b;
+                bR = this.extractor(b);
             return aR - bR;
         });
         const _dfs = (arr) => {
@@ -296,8 +311,8 @@ class BST extends binary_tree_1.BinaryTree {
      *
      * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
      * leftmost node if the comparison result is greater than.
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `BTNKey`, `N`, or `undefined`. It represents the starting point for finding the last key in
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
+     * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
      * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
      * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
      * be performed. It can have one of the following values:
@@ -305,14 +320,23 @@ class BST extends binary_tree_1.BinaryTree {
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey(beginRoot = this.root, iterationType = this.iterationType) {
-        var _a, _b, _c, _d, _e, _f;
-        if (this._compare(0, 1) === types_1.CP.lt)
-            return (_b = (_a = this.getRightMost(beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
-        else if (this._compare(0, 1) === types_1.CP.gt)
-            return (_d = (_c = this.getLeftMost(beginRoot, iterationType)) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : 0;
-        else
-            return (_f = (_e = this.getRightMost(beginRoot, iterationType)) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : 0;
+    lastKey(beginRoot = this.root) {
+        let current = this.ensureNode(beginRoot);
+        if (!current)
+            return undefined;
+        if (this._variant === types_1.BSTVariant.MIN) {
+            // For BSTVariant.MIN, find the rightmost node
+            while (current.right !== undefined) {
+                current = current.right;
+            }
+        }
+        else {
+            // For BSTVariant.MAX, find the leftmost node
+            while (current.left !== undefined) {
+                current = current.left;
+            }
+        }
+        return current.key;
     }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
@@ -324,7 +348,7 @@ class BST extends binary_tree_1.BinaryTree {
      *
      * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
      * either recursive or iterative methods.
-     * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
      * It is used to identify the node that we want to retrieve.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when searching for a node in the binary tree. It can have two possible
@@ -363,6 +387,15 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof BSTNode);
+    }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -370,14 +403,14 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
      * otherwise it returns the key itself.
-     * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
+     * @param {K | N | undefined} key - The `key` parameter can be of type `K`, `N`, or
      * `undefined`.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
     ensureNode(key, iterationType = types_1.IterationType.ITERATIVE) {
-        return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
+        return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
@@ -395,7 +428,7 @@ class BST extends binary_tree_1.BinaryTree {
      * first node that matches the identifier. If set to true, the function will return an array
      * containing only the first matching node. If set to false (default), the function will continue
      * searching for all nodes that match the identifier and return an array containing
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
      * for the traversal. It can be either a key value or a node object. If it is undefined, the
      * traversal will start from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
@@ -475,7 +508,7 @@ class BST extends binary_tree_1.BinaryTree {
      * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It is of type
      * `CP`, which is a custom type representing the comparison operator. The possible values for
      * `lesserOrGreater` are
-     * @param {BTNKey | N | undefined} targetNode - The `targetNode` parameter represents the node in the
+     * @param {K | N | undefined} targetNode - The `targetNode` parameter represents the node in the
      * binary tree that you want to traverse from. It can be specified either by its key, by the node
      * object itself, or it can be left undefined to start the traversal from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
@@ -565,7 +598,6 @@ class BST extends binary_tree_1.BinaryTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        debugger;
                         this.add([midNode.key, midNode.value]);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -652,19 +684,16 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The function compares two values using a comparator function and returns whether the first value
      * is greater than, less than, or equal to the second value.
-     * @param {BTNKey} a - The parameter "a" is of type BTNKey.
-     * @param {BTNKey} b - The parameter "b" in the above code represents a BTNKey.
+     * @param {K} a - The parameter "a" is of type K.
+     * @param {K} b - The parameter "b" in the above code represents a K.
      * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater
      * than), CP.lt (less than), or CP.eq (equal).
      */
     _compare(a, b) {
-        const compared = this.comparator(a, b);
-        if (compared > 0)
-            return types_1.CP.gt;
-        else if (compared < 0)
-            return types_1.CP.lt;
-        else
-            return types_1.CP.eq;
+        const extractedA = this.extractor(a);
+        const extractedB = this.extractor(b);
+        const compared = this.variant === types_1.BSTVariant.MIN ? extractedA - extractedB : extractedB - extractedA;
+        return compared > 0 ? types_1.CP.gt : compared < 0 ? types_1.CP.lt : types_1.CP.eq;
     }
 }
 exports.BST = BST;