data-structure-typed 1.54.2 → 1.54.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.54.2",
+  "version": "1.54.3",
   "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -18,7 +18,7 @@
     "gen:examples": "ts-node scripts/testToExample.ts",
     "test:in-band": "jest --runInBand",
     "test": "npm run test:in-band",
-    "test:integration": "npm run update:subs && jest --config jest.integration.config.js && tsc test/integration/compile.ts",
+    "test:integration": "npm run update:subs && jest --config jest.integration.config.js && tsc test/integration/compile.ts && node test/integration/compile.mjs",
     "test:perf": "npm run build:cjs && npm run build:esm && ts-node test/performance/reportor.ts",
     "check": "tsc --noEmit",
     "check:circular-refs": "dependency-cruiser src",
@@ -65,11 +65,11 @@
     "@typescript-eslint/eslint-plugin": "^8.12.1",
     "@typescript-eslint/parser": "^8.12.1",
     "auto-changelog": "^2.5.0",
-    "avl-tree-typed": "^1.54.1",
+    "avl-tree-typed": "^1.54.2",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.54.1",
-    "bst-typed": "^1.54.1",
-    "data-structure-typed": "^1.54.1",
+    "binary-tree-typed": "^1.54.2",
+    "bst-typed": "^1.54.2",
+    "data-structure-typed": "^1.54.2",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",
@@ -78,7 +78,7 @@
     "eslint-import-resolver-typescript": "^3.6.3",
     "eslint-plugin-import": "^2.31.0",
     "fast-glob": "^3.3.2",
-    "heap-typed": "^1.54.1",
+    "heap-typed": "^1.54.2",
     "istanbul-badges-readme": "^1.9.0",
     "jest": "^29.7.0",
     "js-sdsl": "^4.4.2",

package/src/data-structures/binary-tree/avl-tree-counter.ts

@@ -9,15 +9,15 @@ import type {
   AVLTreeCounterOptions,
   BinaryTreeDeleteResult,
   BSTNOptKeyOrNode,
-  BTNRep,
   EntryCallback,
-  IterationType,
-  OptNodeOrNull
+  IterationType
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
 export class AVLTreeCounterNode<K = any, V = any> extends AVLTreeNode<K, V> {
+  override parent?: AVLTreeCounterNode<K, V> = undefined;
+
   /**
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
    * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -33,28 +33,26 @@ export class AVLTreeCounterNode<K = any, V = any> extends AVLTreeNode<K, V> {
     this.count = count;
   }
 
-  override parent?: AVLTreeCounterNode<K, V> = undefined;
-
-  override _left?: OptNodeOrNull<AVLTreeCounterNode<K, V>> = undefined;
+  override _left?: AVLTreeCounterNode<K, V> | null | undefined = undefined;
 
-  override get left(): OptNodeOrNull<AVLTreeCounterNode<K, V>> {
+  override get left(): AVLTreeCounterNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<AVLTreeCounterNode<K, V>>) {
+  override set left(v: AVLTreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<AVLTreeCounterNode<K, V>> = undefined;
+  override _right?: AVLTreeCounterNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<AVLTreeCounterNode<K, V>> {
+  override get right(): AVLTreeCounterNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<AVLTreeCounterNode<K, V>>) {
+  override set right(v: AVLTreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -78,7 +76,9 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * `compareValues` functions to define custom comparison logic for keys and values, respectively.
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, AVLTreeCounterNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
     options?: AVLTreeCounterOptions<K, V, R>
   ) {
     super([], options);
@@ -145,12 +145,14 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
 
   /**
    * The function checks if the input is an instance of AVLTreeCounterNode.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeCounterNode<K, V>>`.
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `AVLTreeCounterNode` class.
    */
-  override isNode(keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>): keyNodeOrEntry is AVLTreeCounterNode<K, V> {
+  override isNode(
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is AVLTreeCounterNode<K, V> {
     return keyNodeOrEntry instanceof AVLTreeCounterNode;
   }
 
@@ -160,9 +162,9 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    *
    * The function overrides the add method of a TypeScript class to add a new node to a data structure
    * and update the count.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
    * `keyNodeOrEntry` parameter can accept a value of type `R`, which can be any type. It
-   * can also accept a value of type `BTNRep<K, V, AVLTreeCounterNode<K, V>>`, which represents a key, node,
+   * can also accept a value of type `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`, which represents a key, node,
    * entry, or raw element
    * @param {V} [value] - The `value` parameter represents the value associated with the key in the
    * data structure. It is an optional parameter, so it can be omitted if not needed.
@@ -171,7 +173,11 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * be added once. However, you can specify a different value for `count` if you want to add
    * @returns a boolean value.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>, value?: V, count = 1): boolean {
+  override add(
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V,
+    count = 1
+  ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
     if (newNode === undefined) return false;
 
@@ -189,7 +195,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    *
    * The function overrides the delete method in a binary tree data structure, handling deletion of
    * nodes and maintaining balance in the tree.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `predicate`
    * parameter in the `delete` method is used to specify the condition for deleting a node from the
    * binary tree. It can be a key, node, or entry that determines which
    * node(s) should be deleted.
@@ -203,7 +209,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * deleted node and whether balancing is needed in the tree.
    */
   override delete(
-    keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>,
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     ignoreCount = false
   ): BinaryTreeDeleteResult<AVLTreeCounterNode<K, V>>[] {
     const deletedResult: BinaryTreeDeleteResult<AVLTreeCounterNode<K, V>>[] = [];
@@ -276,6 +282,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
   /**
    * Time Complexity: O(n log n)
    * Space Complexity: O(log n)
+   *
    * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
    * tree using either a recursive or iterative approach.
    * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
@@ -374,8 +381,8 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
   /**
    * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
    * a node object.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The
-   * `keyNodeOrEntry` parameter can be of type `R` or `BTNRep<K, V, AVLTreeCounterNode<K, V>>`.
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
+   * `keyNodeOrEntry` parameter can be of type `R` or `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
    * `override` function. It represents the value associated with the key in the data structure. If no
    * value is provided, it will default to `undefined`.
@@ -384,7 +391,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * @returns either a AVLTreeCounterNode<K, V> object or undefined.
    */
   protected override _keyValueNodeOrEntryToNodeAndValue(
-    keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>,
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V,
     count = 1
   ): [AVLTreeCounterNode<K, V> | undefined, V | undefined] {

package/src/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -5,11 +5,13 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { AVLTreeMultiMapOptions, BTNOptKeyOrNull, BTNRep, OptNodeOrNull } from '../../types';
+import { AVLTreeMultiMapOptions, BTNOptKeyOrNull } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeMultiMapNode<K = any, V = any> extends AVLTreeNode<K, V[]> {
+  override parent?: AVLTreeMultiMapNode<K, V> = undefined;
+
   /**
    * This TypeScript constructor initializes an object with a key of type K and an array of values of
    * type V.
@@ -23,28 +25,26 @@ export class AVLTreeMultiMapNode<K = any, V = any> extends AVLTreeNode<K, V[]> {
     super(key, value);
   }
 
-  override parent?: AVLTreeMultiMapNode<K, V> = undefined;
-
-  override _left?: OptNodeOrNull<AVLTreeMultiMapNode<K, V>> = undefined;
+  override _left?: AVLTreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override get left(): OptNodeOrNull<AVLTreeMultiMapNode<K, V>> {
+  override get left(): AVLTreeMultiMapNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<AVLTreeMultiMapNode<K, V>>) {
+  override set left(v: AVLTreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<AVLTreeMultiMapNode<K, V>> = undefined;
+  override _right?: AVLTreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<AVLTreeMultiMapNode<K, V>> {
+  override get right(): AVLTreeMultiMapNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<AVLTreeMultiMapNode<K, V>>) {
+  override set right(v: AVLTreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -71,7 +71,9 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * additional options for configuring the AVLTreeMultiMap instance.
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | R
+    > = [],
     options?: AVLTreeMultiMapOptions<K, V[], R>
   ) {
     super([], { ...options, isMapMode: true });
@@ -117,7 +119,9 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
     return new AVLTreeMultiMapNode<K, V>(key, []);
   }
 
-  override add(node: BTNRep<K, V[], AVLTreeMultiMapNode<K, V>>): boolean;
+  override add(
+    node: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
+  ): boolean;
 
   override add(key: K, value: V): boolean;
 
@@ -127,7 +131,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    *
    * The function `add` in TypeScript overrides the superclass method to add key-value pairs to an AVL
    * tree multi-map.
-   * @param {BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `override add` method can be either a key-value pair entry or just a key. If it
    * is a key-value pair entry, it will be in the format `[key, values]`, where `key` is the key and
    * `values`
@@ -137,7 +141,10 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * @returns The `override add` method is returning a boolean value, which indicates whether the
    * addition operation was successful or not.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K,
+    value?: V
+  ): boolean {
     if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
 
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
@@ -180,7 +187,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    *
    * The function `deleteValue` removes a specific value from a key in an AVLTreeMultiMap data
    * structure and deletes the entire node if no values are left for that key.
-   * @param {BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `deleteValue` function can be either a `BTNRep` object representing a key-value
    * pair in the AVLTreeMultiMapNode, or just the key itself.
    * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
@@ -191,7 +198,10 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * `value` was successfully deleted from the array of values associated with the `keyNodeOrEntry`. If
    * the value was not found in the array, it returns `false`.
    */
-  deleteValue(keyNodeOrEntry: BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K, value: V): boolean {
+  deleteValue(
+    keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K,
+    value: V
+  ): boolean {
     const values = this.get(keyNodeOrEntry);
     if (Array.isArray(values)) {
       const index = values.indexOf(value);

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

@@ -6,17 +6,12 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type {
-  AVLTreeOptions,
-  BinaryTreeDeleteResult,
-  BSTNOptKeyOrNode,
-  BTNRep,
-  EntryCallback,
-  OptNodeOrNull
-} from '../../types';
+import type { AVLTreeOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, EntryCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
+  override parent?: AVLTreeNode<K, V> = undefined;
+
   /**
    * This TypeScript constructor function initializes an instance with a key and an optional value.
    * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
@@ -30,28 +25,26 @@ export class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
     super(key, value);
   }
 
-  override parent?: AVLTreeNode<K, V> = undefined;
-
-  override _left?: OptNodeOrNull<AVLTreeNode<K, V>> = undefined;
+  override _left?: AVLTreeNode<K, V> | null | undefined = undefined;
 
-  override get left(): OptNodeOrNull<AVLTreeNode<K, V>> {
+  override get left(): AVLTreeNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<AVLTreeNode<K, V>>) {
+  override set left(v: AVLTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<AVLTreeNode<K, V>> = undefined;
+  override _right?: AVLTreeNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<AVLTreeNode<K, V>> {
+  override get right(): AVLTreeNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<AVLTreeNode<K, V>>) {
+  override set right(v: AVLTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -76,7 +69,8 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    * This TypeScript constructor initializes an AVLTree with keys, nodes, entries, or raw data provided
    * in an iterable format.
    * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-   * iterable that can contain either `BTNRep<K, V, AVLTreeNode<K, V>>` objects or `R` objects. It is
+   * iterable that can contain either `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined ` objects or `R` objects. It is
    * used to initialize the AVLTree with key-value pairs or raw data entries. If provided
    * @param [options] - The `options` parameter in the constructor is of type `AVLTreeOptions<K, V,
    * R>`. It is an optional parameter that allows you to specify additional options for configuring the
@@ -84,7 +78,9 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    * other configuration settings specific
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, AVLTreeNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
     options?: AVLTreeOptions<K, V, R>
   ) {
     super([], options);
@@ -133,12 +129,15 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    * Space Complexity: O(1)
    *
    * The function checks if the input is an instance of AVLTreeNode.
-   * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeNode<K, V>>`.
+   * @param {K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `.
    * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `AVLTreeNode` class.
    */
-  override isNode(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>): keyNodeOrEntry is AVLTreeNode<K, V> {
+  override isNode(
+    keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is AVLTreeNode<K, V> {
     return keyNodeOrEntry instanceof AVLTreeNode;
   }
 
@@ -148,13 +147,17 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    *
    * The function overrides the add method of a class and inserts a key-value pair into a data
    * structure, then balances the path.
-   * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can accept values of type `R`, `BTNRep<K, V, AVLTreeNode<K, V>>`
+   * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can accept values of type `R`, `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `
    * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
    * the key or node being added to the data structure.
    * @returns The method is returning a boolean value.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V
+  ): boolean {
     if (keyNodeOrEntry === null) return false;
     const inserted = super.add(keyNodeOrEntry, value);
     if (inserted) this._balancePath(keyNodeOrEntry);
@@ -167,14 +170,16 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    *
    * The function overrides the delete method in a TypeScript class, performs deletion, and then
    * balances the tree if necessary.
-   * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `override delete` method can be one of the following types:
    * @returns The `delete` method is being overridden in this code snippet. It first calls the `delete`
    * method from the superclass (presumably a parent class) with the provided `predicate`, which could
    * be a key, node, entry, or a custom predicate. The result of this deletion operation is stored in
    * `deletedResults`, which is an array of `BinaryTreeDeleteResult` objects.
    */
-  override delete(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>): BinaryTreeDeleteResult<AVLTreeNode<K, V>>[] {
+  override delete(
+    keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): BinaryTreeDeleteResult<AVLTreeNode<K, V>>[] {
     const deletedResults = super.delete(keyNodeOrEntry);
     for (const { needBalanced } of deletedResults) {
       if (needBalanced) {
@@ -487,10 +492,11 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    *
    * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
    * to restore balance in an AVL tree after inserting a node.
-   * @param {BTNRep<K, V, AVLTreeNode<K, V>>} node - The `node` parameter can be of type `R` or
-   * `BTNRep<K, V, AVLTreeNode<K, V>>`.
+   * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } node - The `node` parameter can be of type `R` or
+   * `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `.
    */
-  protected _balancePath(node: BTNRep<K, V, AVLTreeNode<K, V>>): void {
+  protected _balancePath(node: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): void {
     node = this.ensureNode(node);
     const path = this.getPathToRoot(node, node => node, false); // first O(log n) + O(log n)
     for (let i = 0; i < path.length; i++) {