directed-graph-typed 1.39.5 → 1.40.0

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

@@ -11,7 +11,7 @@ import { BTNCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 export declare class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
     height: number;
-    constructor(key: BTNKey, val?: V);
+    constructor(key: BTNKey, value?: V);
 }
 export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
     /**
@@ -25,22 +25,22 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
      * The function creates a new AVL tree node with the specified key and value.
      * @param {BTNKey} 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 [val] - The parameter `val` is an optional value that can be assigned to the node. It is of
-     * type `V`, which means it can be any value that is assignable to the `val` property of the
+     * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It is of
+     * type `V`, which means it can be any value that is assignable to the `value` property of the
      * node type `N`.
      * @returns a new AVLTreeNode object with the specified key and value.
      */
-    createNode(key: BTNKey, val?: V): N;
+    createNode(key: BTNKey, value?: V): N;
     /**
      * The function overrides the add method of a binary tree node and balances the tree after inserting
      * a new node.
      * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can accept either a
      * `BTNKey` or a `N` (which represents a node in the binary tree) or `null`.
-     * @param [val] - The `val` parameter is the value that you want to assign to the new node that you
+     * @param [value] - The `value` parameter is the value that you want to assign to the new node that you
      * are adding to the binary search tree.
      * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
      */
-    add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined;
+    add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined;
     /**
      * The function overrides the delete method of a binary tree and balances the tree after deleting a
      * node if necessary.

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

@@ -10,8 +10,8 @@ exports.AVLTree = exports.AVLTreeNode = void 0;
  */
 const bst_1 = require("./bst");
 class AVLTreeNode extends bst_1.BSTNode {
-    constructor(key, val) {
-        super(key, val);
+    constructor(key, value) {
+        super(key, value);
         this.height = 0;
     }
 }
@@ -30,26 +30,25 @@ class AVLTree extends bst_1.BST {
      * The function creates a new AVL tree node with the specified key and value.
      * @param {BTNKey} 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 [val] - The parameter `val` is an optional value that can be assigned to the node. It is of
-     * type `V`, which means it can be any value that is assignable to the `val` property of the
+     * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It is of
+     * type `V`, which means it can be any value that is assignable to the `value` property of the
      * node type `N`.
      * @returns a new AVLTreeNode object with the specified key and value.
      */
-    createNode(key, val) {
-        return new AVLTreeNode(key, val);
+    createNode(key, value) {
+        return new AVLTreeNode(key, value);
     }
     /**
      * The function overrides the add method of a binary tree node and balances the tree after inserting
      * a new node.
      * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can accept either a
      * `BTNKey` or a `N` (which represents a node in the binary tree) or `null`.
-     * @param [val] - The `val` parameter is the value that you want to assign to the new node that you
+     * @param [value] - The `value` parameter is the value that you want to assign to the new node that you
      * are adding to the binary search tree.
      * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
      */
-    add(keyOrNode, val) {
-        // TODO support node as a param
-        const inserted = super.add(keyOrNode, val);
+    add(keyOrNode, value) {
+        const inserted = super.add(keyOrNode, value);
         if (inserted)
             this._balancePath(inserted);
         return inserted;
@@ -86,15 +85,15 @@ class AVLTree extends bst_1.BST {
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      */
     _swap(srcNode, destNode) {
-        const { key, val, height } = destNode;
-        const tempNode = this.createNode(key, val);
+        const { key, value, height } = destNode;
+        const tempNode = this.createNode(key, value);
         if (tempNode) {
             tempNode.height = height;
             destNode.key = srcNode.key;
-            destNode.val = srcNode.val;
+            destNode.value = srcNode.value;
             destNode.height = srcNode.height;
             srcNode.key = tempNode.key;
-            srcNode.val = tempNode.val;
+            srcNode.value = tempNode.value;
             srcNode.height = tempNode.height;
         }
         return destNode;

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

@@ -13,13 +13,10 @@ export declare class BinaryIndexedTree {
     });
     protected _freqMap: Record<number, number>;
     get freqMap(): Record<number, number>;
-    set freqMap(value: Record<number, number>);
     protected _msb: number;
     get msb(): number;
-    set msb(value: number);
     protected _negativeCount: number;
     get negativeCount(): number;
-    set negativeCount(value: number);
     get freq(): number;
     get max(): number;
     /**

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

@@ -26,21 +26,12 @@ class BinaryIndexedTree {
     get freqMap() {
         return this._freqMap;
     }
-    set freqMap(value) {
-        this._freqMap = value;
-    }
     get msb() {
         return this._msb;
     }
-    set msb(value) {
-        this._msb = value;
-    }
     get negativeCount() {
         return this._negativeCount;
     }
-    set negativeCount(value) {
-        this._negativeCount = value;
-    }
     get freq() {
         return this._freq;
     }
@@ -198,10 +189,10 @@ class BinaryIndexedTree {
      */
     _updateNegativeCount(freqCur, freqNew) {
         if (freqCur < 0 && freqNew >= 0) {
-            this.negativeCount--;
+            this._negativeCount--;
         }
         else if (freqCur >= 0 && freqNew < 0) {
-            this.negativeCount++;
+            this._negativeCount++;
         }
     }
     /**

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

@@ -21,7 +21,7 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
     /**
      * The value stored in the node.
      */
-    val: V | undefined;
+    value: V | undefined;
     /**
      * The parent node of the current node.
      */
@@ -29,10 +29,10 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
     /**
      * Creates a new instance of BinaryTreeNode.
      * @param {BTNKey} key - The key associated with the node.
-     * @param {V} val - The value stored in the node.
+     * @param {V} value - The value stored in the node.
      */
-    constructor(key: BTNKey, val?: V);
-    private _left;
+    constructor(key: BTNKey, value?: V);
+    protected _left: N | null | undefined;
     /**
      * Get the left child node.
      */
@@ -42,7 +42,7 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
      * @param {N | null | undefined} v - The left child node.
      */
     set left(v: N | null | undefined);
-    private _right;
+    protected _right: N | null | undefined;
     /**
      * Get the right child node.
      */
@@ -63,27 +63,18 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
  * @template N - The type of the binary tree's nodes.
  */
 export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>> implements IBinaryTree<V, N> {
+    iterationType: IterationType;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options?: BinaryTreeOptions);
-    private _iterationType;
-    /**
-     * Get the iteration type used in the binary tree.
-     */
-    get iterationType(): IterationType;
-    /**
-     * Set the iteration type for the binary tree.
-     * @param {IterationType} v - The new iteration type to set.
-     */
-    set iterationType(v: IterationType);
-    private _root;
+    protected _root: N | null;
     /**
      * Get the root node of the binary tree.
      */
     get root(): N | null;
-    private _size;
+    protected _size: number;
     /**
      * Get the number of nodes in the binary tree.
      */
@@ -91,10 +82,10 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {BTNKey} key - The key for the new node.
-     * @param {V} val - The value for the new node.
+     * @param {V} value - The value for the new node.
      * @returns {N} - The newly created BinaryTreeNode.
      */
-    createNode(key: BTNKey, val?: V): N;
+    createNode(key: BTNKey, value?: V): N;
     /**
      * Clear the binary tree, removing all nodes.
      */
@@ -107,10 +98,10 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     /**
      * Add a node with the given key and value to the binary tree.
      * @param {BTNKey | N | null} keyOrNode - The key or node to add to the binary tree.
-     * @param {V} val - The value for the new node (optional).
+     * @param {V} value - The value for the new node (optional).
      * @returns {N | null | undefined} - The inserted node, or null if nothing was inserted, or undefined if the operation failed.
      */
-    add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined;
+    add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined;
     /**
      * The `addMany` function takes an array of binary tree node IDs or nodes, and optionally an array of corresponding data
      * values, and adds them to the binary tree.
@@ -361,10 +352,4 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * type `N` or `null`.
      */
     protected _setRoot(v: N | null): void;
-    /**
-     * The function sets the value of the protected property "_size" to the given number.
-     * @param {number} v - The parameter "v" is a number that represents the size value that we want to
-     * set.
-     */
-    protected _setSize(v: number): void;
 }

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

@@ -20,11 +20,11 @@ class BinaryTreeNode {
     /**
      * Creates a new instance of BinaryTreeNode.
      * @param {BTNKey} key - The key associated with the node.
-     * @param {V} val - The value stored in the node.
+     * @param {V} value - The value stored in the node.
      */
-    constructor(key, val) {
+    constructor(key, value) {
         this.key = key;
-        this.val = val;
+        this.value = value;
     }
     /**
      * Get the left child node.
@@ -87,27 +87,14 @@ class BinaryTree {
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
-        this._iterationType = types_1.IterationType.ITERATIVE;
+        this.iterationType = types_1.IterationType.ITERATIVE;
         this._root = null;
         this._size = 0;
         if (options !== undefined) {
             const { iterationType = types_1.IterationType.ITERATIVE } = options;
-            this._iterationType = iterationType;
+            this.iterationType = iterationType;
         }
     }
-    /**
-     * Get the iteration type used in the binary tree.
-     */
-    get iterationType() {
-        return this._iterationType;
-    }
-    /**
-     * Set the iteration type for the binary tree.
-     * @param {IterationType} v - The new iteration type to set.
-     */
-    set iterationType(v) {
-        this._iterationType = v;
-    }
     /**
      * Get the root node of the binary tree.
      */
@@ -123,17 +110,17 @@ class BinaryTree {
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {BTNKey} key - The key for the new node.
-     * @param {V} val - The value for the new node.
+     * @param {V} value - The value for the new node.
      * @returns {N} - The newly created BinaryTreeNode.
      */
-    createNode(key, val) {
-        return new BinaryTreeNode(key, val);
+    createNode(key, value) {
+        return new BinaryTreeNode(key, value);
     }
     /**
      * Clear the binary tree, removing all nodes.
      */
     clear() {
-        this._root = null;
+        this._setRoot(null);
         this._size = 0;
     }
     /**
@@ -146,10 +133,10 @@ class BinaryTree {
     /**
      * Add a node with the given key and value to the binary tree.
      * @param {BTNKey | N | null} keyOrNode - The key or node to add to the binary tree.
-     * @param {V} val - The value for the new node (optional).
+     * @param {V} value - The value for the new node (optional).
      * @returns {N | null | undefined} - The inserted node, or null if nothing was inserted, or undefined if the operation failed.
      */
-    add(keyOrNode, val) {
+    add(keyOrNode, value) {
         const _bfs = (root, newNode) => {
             const queue = new queue_1.Queue([root]);
             while (queue.size > 0) {
@@ -175,7 +162,7 @@ class BinaryTree {
             needInsert = null;
         }
         else if (typeof keyOrNode === 'number') {
-            needInsert = this.createNode(keyOrNode, val);
+            needInsert = this.createNode(keyOrNode, value);
         }
         else if (keyOrNode instanceof BinaryTreeNode) {
             needInsert = keyOrNode;
@@ -187,7 +174,7 @@ class BinaryTree {
         const existNode = key !== undefined ? this.get(key, (node) => node.key) : undefined;
         if (this.root) {
             if (existNode) {
-                existNode.val = val;
+                existNode.value = value;
                 inserted = existNode;
             }
             else {
@@ -197,10 +184,10 @@ class BinaryTree {
         else {
             this._setRoot(needInsert);
             if (needInsert !== null) {
-                this._setSize(1);
+                this._size = 1;
             }
             else {
-                this._setSize(0);
+                this._size = 0;
             }
             inserted = this.root;
         }
@@ -220,13 +207,13 @@ class BinaryTree {
         // TODO not sure addMany not be run multi times
         return keysOrNodes.map((keyOrNode, i) => {
             if (keyOrNode instanceof BinaryTreeNode) {
-                return this.add(keyOrNode.key, keyOrNode.val);
+                return this.add(keyOrNode.key, keyOrNode.value);
             }
             if (keyOrNode === null) {
                 return this.add(null);
             }
-            const val = values === null || values === void 0 ? void 0 : values[i];
-            return this.add(keyOrNode, val);
+            const value = values === null || values === void 0 ? void 0 : values[i];
+            return this.add(keyOrNode, value);
         });
     }
     /**
@@ -297,7 +284,7 @@ class BinaryTree {
                 }
             }
         }
-        this._setSize(this.size - 1);
+        this._size = this.size - 1;
         bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
         return bstDeletedResult;
     }
@@ -1065,13 +1052,13 @@ class BinaryTree {
      * @returns {N} - The destination node after the swap.
      */
     _swap(srcNode, destNode) {
-        const { key, val } = destNode;
-        const tempNode = this.createNode(key, val);
+        const { key, value } = destNode;
+        const tempNode = this.createNode(key, value);
         if (tempNode) {
             destNode.key = srcNode.key;
-            destNode.val = srcNode.val;
+            destNode.value = srcNode.value;
             srcNode.key = tempNode.key;
-            srcNode.val = tempNode.val;
+            srcNode.value = tempNode.value;
         }
         return destNode;
     }
@@ -1093,14 +1080,14 @@ class BinaryTree {
             if (parent.left === undefined) {
                 parent.left = newNode;
                 if (newNode) {
-                    this._setSize(this.size + 1);
+                    this._size = this.size + 1;
                 }
                 return parent.left;
             }
             else if (parent.right === undefined) {
                 parent.right = newNode;
                 if (newNode) {
-                    this._setSize(this.size + 1);
+                    this._size = this.size + 1;
                 }
                 return parent.right;
             }
@@ -1124,13 +1111,5 @@ class BinaryTree {
         }
         this._root = v;
     }
-    /**
-     * The function sets the value of the protected property "_size" to the given number.
-     * @param {number} v - The parameter "v" is a number that represents the size value that we want to
-     * set.
-     */
-    _setSize(v) {
-        this._size = v;
-    }
 }
 exports.BinaryTree = BinaryTree;

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

@@ -5,12 +5,12 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BTNKey, BSTComparator, BSTNodeNested, BSTOptions, BTNCallback } from '../../types';
+import type { BSTComparator, BSTNodeNested, BSTOptions, BTNCallback, BTNKey } from '../../types';
 import { 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> {
-    constructor(key: BTNKey, val?: V);
+    constructor(key: BTNKey, value?: V);
 }
 export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>> extends BinaryTree<V, N> implements IBinaryTree<V, N> {
     /**
@@ -24,26 +24,26 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * 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
      * the new node. It is used to determine the position of the node in the binary search tree.
-     * @param [val] - The parameter `val` is an optional value that can be assigned to the node. It
+     * @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, val?: V): N;
+    createNode(key: BTNKey, value?: V): N;
     /**
      * The `add` function in a binary search tree class inserts a new node with a given key and value
      * into the tree.
      * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
      * `BTNKey` (which can be a number or a string), a `BSTNode` object, or `null`.
-     * @param [val] - The `val` parameter is the value to be assigned to the new node being added to the
+     * @param [value] - The `value` parameter is the value to be assigned to the new node being added to the
      * binary search tree.
      * @returns the inserted node (N) if it was successfully added to the binary search tree. If the node
      * was not added or if the parameters were invalid, it returns null or undefined.
      */
-    add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined;
+    add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined;
     /**
      * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
      * maintaining balance.
-     * @param {[BTNKey | N, N['val']][]} keysOrNodes - The `arr` parameter in the `addMany` function
+     * @param {[BTNKey | N, N['value']][]} keysOrNodes - The `arr` parameter in the `addMany` function
      * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
      * array of `BTNKey` or `N` (which represents the node type in the binary search tree) or
      * `null

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

@@ -5,8 +5,8 @@ const types_1 = require("../../types");
 const binary_tree_1 = require("./binary-tree");
 const queue_1 = require("../queue");
 class BSTNode extends binary_tree_1.BinaryTreeNode {
-    constructor(key, val) {
-        super(key, val);
+    constructor(key, value) {
+        super(key, value);
     }
 }
 exports.BSTNode = BSTNode;
@@ -31,24 +31,24 @@ class BST extends binary_tree_1.BinaryTree {
      * 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
      * the new node. It is used to determine the position of the node in the binary search tree.
-     * @param [val] - The parameter `val` is an optional value that can be assigned to the node. It
+     * @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, val) {
-        return new BSTNode(key, val);
+    createNode(key, value) {
+        return new BSTNode(key, value);
     }
     /**
      * The `add` function in a binary search tree class inserts a new node with a given key and value
      * into the tree.
      * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
      * `BTNKey` (which can be a number or a string), a `BSTNode` object, or `null`.
-     * @param [val] - The `val` parameter is the value to be assigned to the new node being added to the
+     * @param [value] - The `value` parameter is the value to be assigned to the new node being added to the
      * binary search tree.
      * @returns the inserted node (N) if it was successfully added to the binary search tree. If the node
      * was not added or if the parameters were invalid, it returns null or undefined.
      */
-    add(keyOrNode, val) {
+    add(keyOrNode, value) {
         // TODO support node as a parameter
         let inserted = null;
         let newNode = null;
@@ -56,14 +56,14 @@ class BST extends binary_tree_1.BinaryTree {
             newNode = keyOrNode;
         }
         else if (typeof keyOrNode === 'number') {
-            newNode = this.createNode(keyOrNode, val);
+            newNode = this.createNode(keyOrNode, value);
         }
         else if (keyOrNode === null) {
             newNode = null;
         }
         if (this.root === null) {
             this._setRoot(newNode);
-            this._setSize(this.size + 1);
+            this._size = this.size + 1;
             inserted = this.root;
         }
         else {
@@ -73,7 +73,7 @@ class BST extends binary_tree_1.BinaryTree {
                 if (cur !== null && newNode !== null) {
                     if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
                         if (newNode) {
-                            cur.val = newNode.val;
+                            cur.value = newNode.value;
                         }
                         //Duplicates are not accepted.
                         traversing = false;
@@ -87,7 +87,7 @@ class BST extends binary_tree_1.BinaryTree {
                             }
                             //Add to the left of the current node
                             cur.left = newNode;
-                            this._setSize(this.size + 1);
+                            this._size = this.size + 1;
                             traversing = false;
                             inserted = cur.left;
                         }
@@ -105,7 +105,7 @@ class BST extends binary_tree_1.BinaryTree {
                             }
                             //Add to the right of the current node
                             cur.right = newNode;
-                            this._setSize(this.size + 1);
+                            this._size = this.size + 1;
                             traversing = false;
                             inserted = cur.right;
                         }
@@ -126,7 +126,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
      * maintaining balance.
-     * @param {[BTNKey | N, N['val']][]} keysOrNodes - The `arr` parameter in the `addMany` function
+     * @param {[BTNKey | N, N['value']][]} keysOrNodes - The `arr` parameter in the `addMany` function
      * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
      * array of `BTNKey` or `N` (which represents the node type in the binary search tree) or
      * `null
@@ -170,7 +170,7 @@ class BST extends binary_tree_1.BinaryTree {
             throw new Error('Invalid input keysOrNodes');
         }
         sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
-        sortedData = sorted.map(([, val]) => val);
+        sortedData = sorted.map(([, value]) => value);
         const recursive = (arr, data) => {
             if (arr.length === 0)
                 return;
@@ -414,7 +414,7 @@ class BST extends binary_tree_1.BinaryTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add(midNode.key, midNode.val);
+                this.add(midNode.key, midNode.value);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -430,7 +430,7 @@ class BST extends binary_tree_1.BinaryTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add(midNode.key, midNode.val);
+                        this.add(midNode.key, midNode.value);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }

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

@@ -2,12 +2,10 @@ import { BTNKey, RBColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { BST, BSTNode } from './bst';
 export declare class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
-    constructor(key: BTNKey, val?: V);
-    private _color;
-    get color(): RBColor;
-    set color(value: RBColor);
+    constructor(key: BTNKey, value?: V);
+    color: RBColor;
 }
 export declare class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
     constructor(options?: RBTreeOptions);
-    createNode(key: BTNKey, val?: V): N;
+    createNode(key: BTNKey, value?: V): N;
 }

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

@@ -4,15 +4,9 @@ exports.RBTree = exports.RBTreeNode = void 0;
 const types_1 = require("../../types");
 const bst_1 = require("./bst");
 class RBTreeNode extends bst_1.BSTNode {
-    constructor(key, val) {
-        super(key, val);
-        this._color = types_1.RBColor.RED;
-    }
-    get color() {
-        return this._color;
-    }
-    set color(value) {
-        this._color = value;
+    constructor(key, value) {
+        super(key, value);
+        this.color = types_1.RBColor.RED;
     }
 }
 exports.RBTreeNode = RBTreeNode;
@@ -20,8 +14,8 @@ class RBTree extends bst_1.BST {
     constructor(options) {
         super(options);
     }
-    createNode(key, val) {
-        return new RBTreeNode(key, val);
+    createNode(key, value) {
+        return new RBTreeNode(key, value);
     }
 }
 exports.RBTree = RBTree;