graph-typed 1.39.5 → 1.40.0

package/src/data-structures/binary-tree/bst.ts

@@ -5,22 +5,21 @@
  * @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';
 import {Queue} from '../queue';
 
 export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
-  constructor(key: BTNKey, val?: V) {
-    super(key, val);
+  constructor(key: BTNKey, value?: V) {
+    super(key, value);
   }
 }
 
 export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
   extends BinaryTree<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   /**
    * The constructor function initializes a binary search tree object with an optional comparator
    * function.
@@ -41,12 +40,12 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * 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.
    */
-  override createNode(key: BTNKey, val?: V): N {
-    return new BSTNode<V, N>(key, val) as N;
+  override createNode(key: BTNKey, value?: V): N {
+    return new BSTNode<V, N>(key, value) as N;
   }
 
   /**
@@ -54,25 +53,25 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * 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.
    */
-  override add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined {
+  override add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined {
     // TODO support node as a parameter
     let inserted: N | null = null;
     let newNode: N | null = null;
     if (keyOrNode instanceof BSTNode) {
       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 {
       let cur = this.root;
@@ -81,7 +80,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
         if (cur !== null && newNode !== null) {
           if (this._compare(cur.key, newNode.key) === CP.eq) {
             if (newNode) {
-              cur.val = newNode.val;
+              cur.value = newNode.value;
             }
             //Duplicates are not accepted.
             traversing = false;
@@ -94,7 +93,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
               }
               //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;
             } else {
@@ -109,7 +108,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
               }
               //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;
             } else {
@@ -128,7 +127,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   /**
    * 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
@@ -154,15 +153,15 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       return super.addMany(keysOrNodes, data);
     }
     const inserted: (N | null | undefined)[] = [];
-    const combinedArr: [BTNKey | N, N['val']][] = keysOrNodes.map((value, index) => [value, data?.[index]]);
+    const combinedArr: [BTNKey | N, N['value']][] = keysOrNodes.map((value, index) => [value, data?.[index]]);
     let sorted = [];
 
-    function isNodeOrNullTuple(arr: [BTNKey | N, N['val']][]): arr is [N, N['val']][] {
+    function isNodeOrNullTuple(arr: [BTNKey | N, N['value']][]): arr is [N, N['value']][] {
       for (const [keyOrNode] of arr) if (keyOrNode instanceof BSTNode) return true;
       return false;
     }
 
-    function isBinaryTreeKeyOrNullTuple(arr: [BTNKey | N, N['val']][]): arr is [BTNKey, N['val']][] {
+    function isBinaryTreeKeyOrNullTuple(arr: [BTNKey | N, N['value']][]): arr is [BTNKey, N['value']][] {
       for (const [keyOrNode] of arr) if (typeof keyOrNode === 'number') return true;
       return false;
     }
@@ -178,7 +177,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       throw new Error('Invalid input keysOrNodes');
     }
     sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
-    sortedData = sorted.map(([, val]) => val);
+    sortedData = sorted.map(([, value]) => value);
     const recursive = (arr: (BTNKey | null | N)[], data?: (V | undefined)[]) => {
       if (arr.length === 0) return;
 
@@ -426,7 +425,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
         if (l > r) 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);
       };
@@ -442,7 +441,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
           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/src/data-structures/binary-tree/rb-tree.ts

@@ -3,42 +3,34 @@ import {IBinaryTree} from '../../interfaces';
 import {BST, BSTNode} from './bst';
 
 export class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
-  constructor(key: BTNKey, val?: V) {
-    super(key, val);
-    this._color = RBColor.RED;
+  constructor(key: BTNKey, value?: V) {
+    super(key, value);
+    this.color = RBColor.RED;
   }
 
-  private _color: RBColor;
+  color: RBColor;
 
-  get color(): RBColor {
-    return this._color;
-  }
-
-  set color(value: RBColor) {
-    this._color = value;
-  }
 }
 
 export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>>
   extends BST<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   constructor(options?: RBTreeOptions) {
     super(options);
   }
 
-  override createNode(key: BTNKey, val?: V): N {
-    return new RBTreeNode(key, val) as N;
+  override createNode(key: BTNKey, value?: V): N {
+    return new RBTreeNode(key, value) as N;
   }
 
-  // override add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined {
-  //   const inserted = super.add(keyOrNode, val);
+  // override add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined {
+  //   const inserted = super.add(keyOrNode, value);
   //   if (inserted) this._fixInsertViolation(inserted);
   //   return inserted;
   // }
   //
   // // Method for fixing insert violations in a red-black tree
-  // private _fixInsertViolation(node: N) {
+  // protected _fixInsertViolation(node: N) {
   //   while (node !== this.root! && node.color === RBColor.RED && node.parent!.color === RBColor.RED) {
   //     const parent = node.parent!;
   //     const grandparent = parent.parent!;
@@ -101,7 +93,7 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
   // }
   //
   // // Left rotation operation
-  // private _rotateLeft(node: N) {
+  // protected _rotateLeft(node: N) {
   //   const rightChild = node.right;
   //   node.right = rightChild!.left;
   //
@@ -125,7 +117,7 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
   // }
   //
   // // Right rotation operation
-  // private _rotateRight(node: N) {
+  // protected _rotateRight(node: N) {
   //   const leftChild = node.left;
   //   node.left = leftChild!.right;
   //
@@ -148,12 +140,12 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
   //   node.parent = leftChild;
   // }
   //
-  // private _isNodeRed(node: N | null | undefined): boolean {
+  // protected _isNodeRed(node: N | null | undefined): boolean {
   //   return node ? node.color === RBColor.RED : false;
   // }
   //
   // // Find the sibling node
-  // private _findSibling(node: N): N | null | undefined {
+  // protected _findSibling(node: N): N | null | undefined {
   //   if (!node.parent) {
   //     return undefined;
   //   }
@@ -162,7 +154,7 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
   // }
   //
   // // Remove a node
-  // private _removeNode(node: N, replacement: N | null | undefined): void {
+  // protected _removeNode(node: N, replacement: N | null | undefined): void {
   //   if (node === this.root && !replacement) {
   //     // If there's only the root node and no replacement, simply delete the root node
   //     this._setRoot(null);
@@ -230,7 +222,7 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
   // }
   //
   // // Repair operation after node deletion
-  // private _fixDeleteViolation(node: N | null | undefined) {
+  // protected _fixDeleteViolation(node: N | null | undefined) {
   //   let sibling;
   //
   //   while (node && node !== this.root && !this._isNodeRed(node)) {
@@ -327,7 +319,7 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
   //   }
   // }
   //
-  // private _findMin(node: N): N {
+  // protected _findMin(node: N): N {
   //   while (node.left) {
   //     node = node.left;
   //   }
@@ -335,7 +327,7 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
   // }
   //
   // // Get the replacement node
-  // private _getReplacementNode(node: N): N | null | undefined {
+  // protected _getReplacementNode(node: N): N | null | undefined {
   //   if (node.left && node.right) {
   //     return this._findSuccessor(node);
   //   }
@@ -348,7 +340,7 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
   // }
   //
   // // Find the successor node
-  // private _findSuccessor(node: N): N | null | undefined {
+  // protected _findSuccessor(node: N): N | null | undefined {
   //   if (node.right) {
   //     // If the node has a right child, find the minimum node in the right subtree as the successor
   //     return this._findMin(node.right);

package/src/data-structures/binary-tree/segment-tree.ts

@@ -9,70 +9,18 @@
 import type {SegmentTreeNodeVal} from '../../types';
 
 export class SegmentTreeNode {
-  constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null) {
-    this._start = start;
-    this._end = end;
-    this._sum = sum;
-    this._val = val || null;
-  }
-
-  private _start = 0;
-  get start(): number {
-    return this._start;
-  }
-
-  set start(v: number) {
-    this._start = v;
-  }
-
-  private _end = 0;
-
-  get end(): number {
-    return this._end;
-  }
-
-  set end(v: number) {
-    this._end = v;
-  }
-
-  private _val: SegmentTreeNodeVal | null = null;
-
-  get val(): SegmentTreeNodeVal | null {
-    return this._val;
-  }
-
-  set val(v: SegmentTreeNodeVal | null) {
-    this._val = v;
-  }
-
-  private _sum = 0;
-
-  get sum(): number {
-    return this._sum;
-  }
-
-  set sum(v: number) {
-    this._sum = v;
-  }
-
-  private _left: SegmentTreeNode | null = null;
-
-  get left(): SegmentTreeNode | null {
-    return this._left;
-  }
-
-  set left(v: SegmentTreeNode | null) {
-    this._left = v;
-  }
-
-  private _right: SegmentTreeNode | null = null;
-
-  get right(): SegmentTreeNode | null {
-    return this._right;
-  }
-
-  set right(v: SegmentTreeNode | null) {
-    this._right = v;
+  start = 0;
+  end = 0;
+  value: SegmentTreeNodeVal | null = null;
+  sum = 0;
+  left: SegmentTreeNode | null = null;
+  right: SegmentTreeNode | null = null;
+
+  constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null) {
+    this.start = start;
+    this.end = end;
+    this.sum = sum;
+    this.value = value || null;
   }
 }
 
@@ -101,24 +49,25 @@ export class SegmentTree {
     }
   }
 
-  private _values: number[] = [];
+  protected _values: number[] = [];
 
   get values(): number[] {
     return this._values;
   }
 
-  private _start = 0;
+  protected _start = 0;
+
   get start(): number {
     return this._start;
   }
 
-  private _end: number;
+  protected _end: number;
 
   get end(): number {
     return this._end;
   }
 
-  private _root: SegmentTreeNode | null;
+  protected _root: SegmentTreeNode | null;
 
   get root(): SegmentTreeNode | null {
     return this._root;
@@ -154,30 +103,30 @@ export class SegmentTree {
    * updated.
    * @param {number} sum - The `sum` parameter represents the new value that should be assigned to the `sum` property of
    * the `SegmentTreeNode` at the specified `index`.
-   * @param {SegmentTreeNodeVal} [val] - The `val` parameter is an optional value that can be assigned to the `val`
+   * @param {SegmentTreeNodeVal} [value] - The `value` parameter is an optional value that can be assigned to the `value`
    * property of the `SegmentTreeNode` object. It is not currently used in the code, but you can uncomment the line `//
-   * cur.val = val;` and pass a value for `val` in the
+   * cur.value = value;` and pass a value for `value` in the
    * @returns The function does not return anything.
    */
-  updateNode(index: number, sum: number, val?: SegmentTreeNodeVal) {
+  updateNode(index: number, sum: number, value?: SegmentTreeNodeVal) {
     const root = this.root || null;
     if (!root) {
       return;
     }
-    const dfs = (cur: SegmentTreeNode, index: number, sum: number, val?: SegmentTreeNodeVal) => {
+    const dfs = (cur: SegmentTreeNode, index: number, sum: number, value?: SegmentTreeNodeVal) => {
       if (cur.start === cur.end && cur.start === index) {
         cur.sum = sum;
-        if (val !== undefined) cur.val = val;
+        if (value !== undefined) cur.value = value;
         return;
       }
       const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
       if (index <= mid) {
         if (cur.left) {
-          dfs(cur.left, index, sum, val);
+          dfs(cur.left, index, sum, value);
         }
       } else {
         if (cur.right) {
-          dfs(cur.right, index, sum, val);
+          dfs(cur.right, index, sum, value);
         }
       }
       if (cur.left && cur.right) {
@@ -185,7 +134,7 @@ export class SegmentTree {
       }
     };
 
-    dfs(root, index, sum, val);
+    dfs(root, index, sum, value);
   }
 
   /**
@@ -238,20 +187,4 @@ export class SegmentTree {
     };
     return dfs(root, indexA, indexB);
   }
-
-  protected _setValues(value: number[]) {
-    this._values = value;
-  }
-
-  protected _setStart(value: number) {
-    this._start = value;
-  }
-
-  protected _setEnd(value: number) {
-    this._end = value;
-  }
-
-  protected _setRoot(v: SegmentTreeNode | null) {
-    this._root = v;
-  }
 }

package/src/data-structures/binary-tree/tree-multiset.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type {BTNKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
-import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType, BTNCallback} from '../../types';
+import {BinaryTreeDeletedResult, BTNCallback, CP, FamilyPosition, IterationType} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
@@ -20,14 +20,14 @@ export class TreeMultisetNode<
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
    * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
    * of the binary tree node.
-   * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value of the binary
+   * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
    * tree node. If no value is provided, it will be `undefined`.
    * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
    * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
    * parameter when creating a new instance of the `BinaryTreeNode` class.
    */
-  constructor(key: BTNKey, val?: V, count = 1) {
-    super(key, val);
+  constructor(key: BTNKey, value?: V, count = 1) {
+    super(key, value);
     this.count = count;
   }
 }
@@ -37,8 +37,7 @@ export class TreeMultisetNode<
  */
 export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode<V, TreeMultisetNodeNested<V>>>
   extends AVLTree<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   /**
    * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
    * merge duplicated values.
@@ -59,13 +58,13 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * The function creates a new BSTNode with the given key, value, and count.
    * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
    * distinguish one node from another in the tree.
-   * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
+   * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
    * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
    * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
    * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
    */
-  override createNode(key: BTNKey, val?: V, count?: number): N {
-    return new TreeMultisetNode(key, val, count) as N;
+  override createNode(key: BTNKey, value?: V, count?: number): N {
+    return new TreeMultisetNode(key, value, count) as N;
   }
 
   /**
@@ -74,26 +73,26 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
    * `BTNKey` (which represents the key of the node to be added), a `N` (which represents a
    * node to be added), or `null` (which represents a null node).
-   * @param [val] - The `val` parameter represents the value associated with the key that is being
+   * @param [value] - The `value` parameter represents the value associated with the key that is being
    * added to the binary tree.
    * @param [count=1] - The `count` parameter represents the number of occurrences of the key/value
    * pair that will be added to the binary tree. It has a default value of 1, which means that if no
    * count is specified, the default count will be 1.
    * @returns The function `add` returns a value of type `N | null | undefined`.
    */
-  override add(keyOrNode: BTNKey | N | null, val?: V, count = 1): N | null | undefined {
+  override add(keyOrNode: BTNKey | N | null, value?: V, count = 1): N | null | undefined {
     let inserted: N | null | undefined = undefined,
       newNode: N | null;
     if (keyOrNode instanceof TreeMultisetNode) {
-      newNode = this.createNode(keyOrNode.key, keyOrNode.val, keyOrNode.count);
+      newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
     } else if (keyOrNode === null) {
       newNode = null;
     } else {
-      newNode = this.createNode(keyOrNode, val, count);
+      newNode = this.createNode(keyOrNode, value, count);
     }
     if (!this.root) {
       this._setRoot(newNode);
-      this._setSize(this.size + 1);
+      this._size = this.size + 1;
       newNode && this._setCount(this.count + newNode.count);
       inserted = this.root;
     } else {
@@ -103,7 +102,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
         if (cur) {
           if (newNode) {
             if (this._compare(cur.key, newNode.key) === CP.eq) {
-              cur.val = newNode.val;
+              cur.value = newNode.value;
               cur.count += newNode.count;
               this._setCount(this.count + newNode.count);
               traversing = false;
@@ -113,7 +112,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
               if (cur.left === undefined) {
                 //Add to the left of the current node
                 cur.left = newNode;
-                this._setSize(this.size + 1);
+                this._size = this.size + 1;
                 this._setCount(this.count + newNode.count);
 
                 traversing = false;
@@ -127,7 +126,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
               if (cur.right === undefined) {
                 //Add to the right of the current node
                 cur.right = newNode;
-                this._setSize(this.size + 1);
+                this._size = this.size + 1;
                 this._setCount(this.count + newNode.count);
 
                 traversing = false;
@@ -162,7 +161,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
       if (parent.left === undefined) {
         parent.left = newNode;
         if (newNode !== null) {
-          this._setSize(this.size + 1);
+          this._size = this.size + 1;
           this._setCount(this.count + newNode.count);
         }
 
@@ -170,7 +169,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
       } else if (parent.right === undefined) {
         parent.right = newNode;
         if (newNode !== null) {
-          this._setSize(this.size + 1);
+          this._size = (this.size + 1);
           this._setCount(this.count + newNode.count);
         }
         return parent.right;
@@ -199,7 +198,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
       const keyOrNode = keysOrNodes[i];
 
       if (keyOrNode instanceof TreeMultisetNode) {
-        inserted.push(this.add(keyOrNode.key, keyOrNode.val, keyOrNode.count));
+        inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count));
         continue;
       }
 
@@ -233,7 +232,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
         const midNode = sorted[m];
-        this.add(midNode.key, midNode.val, midNode.count);
+        this.add(midNode.key, midNode.value, midNode.count);
         buildBalanceBST(l, m - 1);
         buildBalanceBST(m + 1, r);
       };
@@ -249,7 +248,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            this.add(midNode.key, midNode.val, midNode.count);
+            this.add(midNode.key, midNode.value, midNode.count);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }
@@ -321,7 +320,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
           }
         }
       }
-      this._setSize(this.size - 1);
+      this._size = this.size - 1;
       // TODO How to handle when the count of target node is lesser than current node's count
       this._setCount(this.count - orgCurrent.count);
     }
@@ -351,18 +350,18 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
    */
   protected override _swap(srcNode: N, destNode: N): N {
-    const {key, val, count, height} = destNode;
-    const tempNode = this.createNode(key, val, count);
+    const {key, value, count, height} = destNode;
+    const tempNode = this.createNode(key, value, count);
     if (tempNode) {
       tempNode.height = height;
 
       destNode.key = srcNode.key;
-      destNode.val = srcNode.val;
+      destNode.value = srcNode.value;
       destNode.count = srcNode.count;
       destNode.height = srcNode.height;
 
       srcNode.key = tempNode.key;
-      srcNode.val = tempNode.val;
+      srcNode.value = tempNode.value;
       srcNode.count = tempNode.count;
       srcNode.height = tempNode.height;
     }