linked-list-typed 1.39.5 → 1.39.6

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,26 @@ 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) {
+    add(keyOrNode, value) {
         // TODO support node as a param
-        const inserted = super.add(keyOrNode, val);
+        const inserted = super.add(keyOrNode, value);
         if (inserted)
             this._balancePath(inserted);
         return inserted;
@@ -86,15 +86,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-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,9 +29,9 @@ 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);
+    constructor(key: BTNKey, value?: V);
     private _left;
     /**
      * Get the left child node.
@@ -91,10 +91,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 +107,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.

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.
@@ -123,11 +123,11 @@ 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.
@@ -146,10 +146,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 +175,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 +187,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 {
@@ -220,13 +220,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);
         });
     }
     /**
@@ -1065,13 +1065,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;
     }

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

@@ -10,7 +10,7 @@ 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,7 +56,7 @@ 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;
@@ -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;
@@ -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,12 @@ 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);
+    constructor(key: BTNKey, value?: V);
     private _color;
     get color(): RBColor;
     set color(value: 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,8 +4,8 @@ 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);
+    constructor(key, value) {
+        super(key, value);
         this._color = types_1.RBColor.RED;
     }
     get color() {
@@ -20,8 +20,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;

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

@@ -7,16 +7,16 @@
  */
 import type { SegmentTreeNodeVal } from '../../types';
 export declare class SegmentTreeNode {
-    constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null);
+    constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null);
     private _start;
     get start(): number;
     set start(v: number);
     private _end;
     get end(): number;
     set end(v: number);
-    private _val;
-    get val(): SegmentTreeNodeVal | null;
-    set val(v: SegmentTreeNodeVal | null);
+    private _value;
+    get value(): SegmentTreeNodeVal | null;
+    set value(v: SegmentTreeNodeVal | null);
     private _sum;
     get sum(): number;
     set sum(v: number);
@@ -62,12 +62,12 @@ export declare 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): void;
+    updateNode(index: number, sum: number, value?: SegmentTreeNodeVal): void;
     /**
      * The function `querySumByRange` calculates the sum of values within a given range in a segment tree.
      * @param {number} indexA - The starting index of the range for which you want to calculate the sum.

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

@@ -9,17 +9,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentTree = exports.SegmentTreeNode = void 0;
 class SegmentTreeNode {
-    constructor(start, end, sum, val) {
+    constructor(start, end, sum, value) {
         this._start = 0;
         this._end = 0;
-        this._val = null;
+        this._value = null;
         this._sum = 0;
         this._left = null;
         this._right = null;
         this._start = start;
         this._end = end;
         this._sum = sum;
-        this._val = val || null;
+        this._value = value || null;
     }
     get start() {
         return this._start;
@@ -33,11 +33,11 @@ class SegmentTreeNode {
     set end(v) {
         this._end = v;
     }
-    get val() {
-        return this._val;
+    get value() {
+        return this._value;
     }
-    set val(v) {
-        this._val = v;
+    set value(v) {
+        this._value = v;
     }
     get sum() {
         return this._sum;
@@ -126,39 +126,39 @@ 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, sum, val) {
+    updateNode(index, sum, value) {
         const root = this.root || null;
         if (!root) {
             return;
         }
-        const dfs = (cur, index, sum, val) => {
+        const dfs = (cur, index, sum, value) => {
             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) {
                 cur.sum = cur.left.sum + cur.right.sum;
             }
         };
-        dfs(root, index, sum, val);
+        dfs(root, index, sum, value);
     }
     /**
      * The function `querySumByRange` calculates the sum of values within a given range in a segment tree.

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

@@ -15,13 +15,13 @@ export declare class TreeMultisetNode<V = any, N extends TreeMultisetNode<V, N>
      * 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?: number);
+    constructor(key: BTNKey, value?: V, count?: number);
 }
 /**
  * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
@@ -40,26 +40,26 @@ export declare class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = Tr
      * 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).
      */
-    createNode(key: BTNKey, val?: V, count?: number): N;
+    createNode(key: BTNKey, value?: V, count?: number): N;
     /**
      * The `add` function adds a new node to a binary search tree, updating the count if the key already
      * exists, and balancing the tree if necessary.
      * @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`.
      */
-    add(keyOrNode: BTNKey | N | null, val?: V, count?: number): N | null | undefined;
+    add(keyOrNode: BTNKey | N | null, value?: V, count?: number): N | null | undefined;
     /**
      * The function adds a new node to a binary tree if there is an available slot in the parent node.
      * @param {N | null} newNode - The `newNode` parameter represents the node that needs to be added to