data-structure-typed 1.47.6 → 1.47.8

package/dist/umd/data-structure-typed.js

@@ -517,13 +517,7 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/hash/hash-map.ts
   var HashMap = class _HashMap {
-    /**
-     * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
-     * @param options - The `options` parameter is an object that contains the `elements` property. The
-     * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
-     */
-    constructor(options = {
-      elements: [],
+    constructor(elements, options = {
       hashFn: (key) => String(key),
       objHashFn: (key) => key
     }) {
@@ -537,7 +531,7 @@ var dataStructureTyped = (() => {
       __publicField(this, "_size", 0);
       this._sentinel = {};
       this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-      const { elements, hashFn, objHashFn } = options;
+      const { hashFn, objHashFn } = options;
       this._hashFn = hashFn;
       this._objHashFn = objHashFn;
       if (elements) {
@@ -844,6 +838,9 @@ var dataStructureTyped = (() => {
         node = node.next;
       }
     }
+    print() {
+      console.log([...this]);
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -871,7 +868,7 @@ var dataStructureTyped = (() => {
   // src/data-structures/linked-list/singly-linked-list.ts
   var SinglyLinkedListNode = class {
     /**
-     * The constructor function initializes an instance of a class with a given value and sets the next property to null.
+     * The constructor function initializes an instance of a class with a given value and sets the next property to undefined.
      * @param {E} value - The "value" parameter is of type E, which means it can be any data type. It represents the value that
      * will be stored in the node of a linked list.
      */
@@ -879,7 +876,7 @@ var dataStructureTyped = (() => {
       __publicField(this, "value");
       __publicField(this, "next");
       this.value = value;
-      this.next = null;
+      this.next = void 0;
     }
   };
   var SinglyLinkedList = class _SinglyLinkedList {
@@ -890,8 +887,8 @@ var dataStructureTyped = (() => {
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_length");
-      this._head = null;
-      this._tail = null;
+      this._head = void 0;
+      this._tail = void 0;
       this._length = 0;
       if (elements) {
         for (const el of elements)
@@ -976,15 +973,15 @@ var dataStructureTyped = (() => {
      * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
      * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
-     * the linked list is empty, it returns `null`.
+     * the linked list is empty, it returns `undefined`.
      */
     pop() {
       if (!this.head)
         return void 0;
       if (this.head === this.tail) {
         const value2 = this.head.value;
-        this._head = null;
-        this._tail = null;
+        this._head = void 0;
+        this._tail = void 0;
         this._length--;
         return value2;
       }
@@ -993,7 +990,7 @@ var dataStructureTyped = (() => {
         current = current.next;
       }
       const value = this.tail.value;
-      current.next = null;
+      current.next = void 0;
       this._tail = current;
       this._length--;
       return value;
@@ -1009,7 +1006,7 @@ var dataStructureTyped = (() => {
      * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
      * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
-     * the linked list is empty, it returns `null`.
+     * the linked list is empty, it returns `undefined`.
      */
     popLast() {
       return this.pop();
@@ -1093,11 +1090,11 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range.
+     * The function `getAt` returns the value at a specified index in a linked list, or undefined if the index is out of range.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
      * retrieve from the list.
-     * @returns The method `getAt(index: number): E | null` returns the value at the specified index in the linked list, or
-     * `null` if the index is out of bounds.
+     * @returns The method `getAt(index: number): E | undefined` returns the value at the specified index in the linked list, or
+     * `undefined` if the index is out of bounds.
      */
     getAt(index) {
       if (index < 0 || index >= this.length)
@@ -1120,7 +1117,7 @@ var dataStructureTyped = (() => {
      * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
      * retrieve from the linked list. It indicates the zero-based index of the node we want to access.
      * @returns The method `getNodeAt(index: number)` returns a `SinglyLinkedListNode<E>` object if the node at the
-     * specified index exists, or `null` if the index is out of bounds.
+     * specified index exists, or `undefined` if the index is out of bounds.
      */
     getNodeAt(index) {
       let current = this.head;
@@ -1140,7 +1137,7 @@ var dataStructureTyped = (() => {
      * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
      * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
      * data structure. It is of type number.
-     * @returns The method `deleteAt` returns the value of the node that was deleted, or `null` if the index is out of
+     * @returns The method `deleteAt` returns the value of the node that was deleted, or `undefined` if the index is out of
      * bounds.
      */
     deleteAt(index) {
@@ -1179,13 +1176,13 @@ var dataStructureTyped = (() => {
       } else {
         value = valueOrNode;
       }
-      let current = this.head, prev = null;
+      let current = this.head, prev = void 0;
       while (current) {
         if (current.value === value) {
-          if (prev === null) {
+          if (prev === void 0) {
             this._head = current.next;
             if (current === this.tail) {
-              this._tail = null;
+              this._tail = void 0;
             }
           } else {
             prev.next = current.next;
@@ -1244,11 +1241,11 @@ var dataStructureTyped = (() => {
       return this.length === 0;
     }
     /**
-     * The `clear` function resets the linked list by setting the head, tail, and length to null and 0 respectively.
+     * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
      */
     clear() {
-      this._head = null;
-      this._tail = null;
+      this._head = void 0;
+      this._tail = void 0;
       this._length = 0;
     }
     /**
@@ -1285,9 +1282,9 @@ var dataStructureTyped = (() => {
     reverse() {
       if (!this.head || this.head === this.tail)
         return;
-      let prev = null;
+      let prev = void 0;
       let current = this.head;
-      let next = null;
+      let next = void 0;
       while (current) {
         next = current.next;
         current.next = prev;
@@ -1308,7 +1305,7 @@ var dataStructureTyped = (() => {
      * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
      * function is used to determine whether a particular value in the linked list satisfies a certain condition.
      * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
-     * the callback function. If no element satisfies the condition, it returns `null`.
+     * the callback function. If no element satisfies the condition, it returns `undefined`.
      */
     find(callback) {
       let current = this.head;
@@ -1318,7 +1315,7 @@ var dataStructureTyped = (() => {
         }
         current = current.next;
       }
-      return null;
+      return void 0;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
@@ -1354,10 +1351,10 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1) - Constant space.
      *
      * The function finds a node in a singly linked list by its value and returns the node if found, otherwise returns
-     * null.
+     * undefined.
      * @param {E} value - The value parameter is the value that we want to search for in the linked list.
      * @returns a `SinglyLinkedListNode<E>` if a node with the specified value is found in the linked list. If no node with
-     * the specified value is found, the function returns `null`.
+     * the specified value is found, the function returns `undefined`.
      */
     getNode(value) {
       let current = this.head;
@@ -1367,7 +1364,7 @@ var dataStructureTyped = (() => {
         }
         current = current.next;
       }
-      return null;
+      return void 0;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
@@ -1589,8 +1586,8 @@ var dataStructureTyped = (() => {
       __publicField(this, "next");
       __publicField(this, "prev");
       this.value = value;
-      this.next = null;
-      this.prev = null;
+      this.next = void 0;
+      this.prev = void 0;
     }
   };
   var DoublyLinkedList = class _DoublyLinkedList {
@@ -1601,8 +1598,8 @@ var dataStructureTyped = (() => {
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_length");
-      this._head = null;
-      this._tail = null;
+      this._head = void 0;
+      this._tail = void 0;
       this._length = 0;
       if (elements) {
         for (const el of elements) {
@@ -1689,18 +1686,18 @@ var dataStructureTyped = (() => {
      *
      * The `pop()` function removes and returns the value of the last node in a doubly linked list.
      * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-     * list is empty, it returns null.
+     * list is empty, it returns undefined.
      */
     pop() {
       if (!this.tail)
         return void 0;
       const removedNode = this.tail;
       if (this.head === this.tail) {
-        this._head = null;
-        this._tail = null;
+        this._head = void 0;
+        this._tail = void 0;
       } else {
         this._tail = removedNode.prev;
-        this.tail.next = null;
+        this.tail.next = void 0;
       }
       this._length--;
       return removedNode.value;
@@ -1715,7 +1712,7 @@ var dataStructureTyped = (() => {
      *
      * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
      * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-     * list is empty, it returns null.
+     * list is empty, it returns undefined.
      */
     popLast() {
       return this.pop();
@@ -1737,11 +1734,11 @@ var dataStructureTyped = (() => {
         return void 0;
       const removedNode = this.head;
       if (this.head === this.tail) {
-        this._head = null;
-        this._tail = null;
+        this._head = void 0;
+        this._tail = void 0;
       } else {
         this._head = removedNode.next;
-        this.head.prev = null;
+        this.head.prev = void 0;
       }
       this._length--;
       return removedNode.value;
@@ -1808,8 +1805,8 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
-     * The `getFirst` function returns the first node in a doubly linked list, or null if the list is empty.
-     * @returns The method `getFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
+     * The `getFirst` function returns the first node in a doubly linked list, or undefined if the list is empty.
+     * @returns The method `getFirst()` returns the first node of the doubly linked list, or `undefined` if the list is empty.
      */
     getFirst() {
       var _a;
@@ -1823,8 +1820,8 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
-     * The `getLast` function returns the last node in a doubly linked list, or null if the list is empty.
-     * @returns The method `getLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
+     * The `getLast` function returns the last node in a doubly linked list, or undefined if the list is empty.
+     * @returns The method `getLast()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
      */
     getLast() {
       var _a;
@@ -1838,11 +1835,11 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
-     * The `getAt` function returns the value at a specified index in a linked list, or null if the index is out of bounds.
+     * The `getAt` function returns the value at a specified index in a linked list, or undefined if the index is out of bounds.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
      * retrieve from the list.
      * @returns The method is returning the value at the specified index in the linked list. If the index is out of bounds
-     * or the linked list is empty, it will return null.
+     * or the linked list is empty, it will return undefined.
      */
     getAt(index) {
       if (index < 0 || index >= this.length)
@@ -1861,16 +1858,16 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
-     * The function `getNodeAt` returns the node at a given index in a doubly linked list, or null if the index is out of
+     * The function `getNodeAt` returns the node at a given index in a doubly linked list, or undefined if the index is out of
      * range.
      * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
      * retrieve from the doubly linked list. It indicates the zero-based index of the node we want to access.
      * @returns The method `getNodeAt(index: number)` returns a `DoublyLinkedListNode<E>` object if the index is within the
-     * valid range of the linked list, otherwise it returns `null`.
+     * valid range of the linked list, otherwise it returns `undefined`.
      */
     getNodeAt(index) {
       if (index < 0 || index >= this.length)
-        return null;
+        return void 0;
       let current = this.head;
       for (let i = 0; i < index; i++) {
         current = current.next;
@@ -1886,10 +1883,10 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `findNodeByValue` searches for a node with a specific value in a doubly linked list and returns the
-     * node if found, otherwise it returns null.
+     * node if found, otherwise it returns undefined.
      * @param {E} value - The `value` parameter is the value that we want to search for in the doubly linked list.
      * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `value`
-     * is found in the linked list. If no such node is found, it returns `null`.
+     * is found in the linked list. If no such node is found, it returns `undefined`.
      */
     getNode(value) {
       let current = this.head;
@@ -1899,7 +1896,7 @@ var dataStructureTyped = (() => {
         }
         current = current.next;
       }
-      return null;
+      return void 0;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -2028,7 +2025,7 @@ var dataStructureTyped = (() => {
      * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
      * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
      * data structure. It is of type number.
-     * @returns The method `deleteAt` returns the value of the node that was deleted, or `null` if the index is out of
+     * @returns The method `deleteAt` returns the value of the node that was deleted, or `undefined` if the index is out of
      * bounds.
      */
     deleteAt(index) {
@@ -2091,11 +2088,11 @@ var dataStructureTyped = (() => {
       return this.length === 0;
     }
     /**
-     * The `clear` function resets the linked list by setting the head, tail, and length to null and 0 respectively.
+     * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
      */
     clear() {
-      this._head = null;
-      this._tail = null;
+      this._head = void 0;
+      this._tail = void 0;
       this._length = 0;
     }
     /**
@@ -2110,7 +2107,7 @@ var dataStructureTyped = (() => {
      * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
      * function is used to determine whether a particular value in the linked list satisfies a certain condition.
      * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
-     * the callback function. If no element satisfies the condition, it returns `null`.
+     * the callback function. If no element satisfies the condition, it returns `undefined`.
      */
     find(callback) {
       let current = this.head;
@@ -2120,7 +2117,7 @@ var dataStructureTyped = (() => {
         }
         current = current.next;
       }
-      return null;
+      return void 0;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -2157,11 +2154,11 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
-     * value that satisfies the given callback function, or null if no value satisfies the callback.
+     * value that satisfies the given callback function, or undefined if no value satisfies the callback.
      * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
      * function is used to determine whether a given value satisfies a certain condition.
      * @returns The method `findBackward` returns the last value in the linked list that satisfies the condition specified by
-     * the callback function. If no value satisfies the condition, it returns `null`.
+     * the callback function. If no value satisfies the condition, it returns `undefined`.
      */
     findBackward(callback) {
       let current = this.tail;
@@ -2171,7 +2168,7 @@ var dataStructureTyped = (() => {
         }
         current = current.prev;
       }
-      return null;
+      return void 0;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -2366,7 +2363,7 @@ var dataStructureTyped = (() => {
       __publicField(this, "_level");
       __publicField(this, "_maxLevel");
       __publicField(this, "_probability");
-      this._head = new SkipListNode(null, null, maxLevel);
+      this._head = new SkipListNode(void 0, void 0, maxLevel);
       this._level = 0;
       this._maxLevel = maxLevel;
       this._probability = probability;
@@ -2410,7 +2407,7 @@ var dataStructureTyped = (() => {
         newNode.forward[i] = update[i].forward[i];
         update[i].forward[i] = newNode;
       }
-      if (newNode.forward[0] !== null) {
+      if (!newNode.forward[0]) {
         this._level = Math.max(this.level, newNode.forward.length);
       }
     }
@@ -2481,7 +2478,7 @@ var dataStructureTyped = (() => {
           }
           update[i].forward[i] = current.forward[i];
         }
-        while (this.level > 0 && this.head.forward[this.level - 1] === null) {
+        while (this.level > 0 && !this.head.forward[this.level - 1]) {
           this._level--;
         }
         return true;
@@ -2559,7 +2556,7 @@ var dataStructureTyped = (() => {
      */
     lower(key) {
       let current = this.head;
-      let lastLess = null;
+      let lastLess = void 0;
       for (let i = this.level - 1; i >= 0; i--) {
         while (current.forward[i] && current.forward[i].key < key) {
           current = current.forward[i];
@@ -2648,12 +2645,12 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
      *
-     * The `peek` function returns the last element of an array, or null if the array is empty.
-     * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
+     * The `peek` function returns the last element of an array, or undefined if the array is empty.
+     * @returns The `peek()` function returns the last element of the `_elements` array, or `undefined` if the array is empty.
      */
     peek() {
       if (this.isEmpty())
-        return null;
+        return void 0;
       return this.elements[this.elements.length - 1];
     }
     /**
@@ -2680,14 +2677,14 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
      *
-     * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
+     * The `pop` function removes and returns the last element from an array, or returns undefined if the array is empty.
      * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
-     * array is empty, it returns `null`.
+     * array is empty, it returns `undefined`.
      */
     pop() {
       if (this.isEmpty())
-        return null;
-      return this.elements.pop() || null;
+        return void 0;
+      return this.elements.pop() || void 0;
     }
     /**
      * Time Complexity: O(n)
@@ -2787,8 +2784,8 @@ var dataStructureTyped = (() => {
       this.push(value);
     }
     /**
-     * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
-     * @returns The method is returning the element at the front of the queue, or null if the queue is empty.
+     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
+     * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
      */
     dequeue() {
       return this.shift();
@@ -2872,7 +2869,7 @@ var dataStructureTyped = (() => {
      *
      * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
      * necessary to optimize performance.
-     * @returns The function `shift()` returns either the first element in the queue or `null` if the queue is empty.
+     * @returns The function `shift()` returns either the first element in the queue or `undefined` if the queue is empty.
      */
     shift() {
       if (this.size === 0)
@@ -2893,9 +2890,9 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
      * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
-     * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
+     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     getFirst() {
       return this.size > 0 ? this.nodes[this.offset] : void 0;
@@ -2908,9 +2905,9 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+     * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
      * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
-     * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
+     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     peek() {
       return this.getFirst();
@@ -2923,9 +2920,9 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * The `getLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
      * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
-     * array is empty, it returns `null`.
+     * array is empty, it returns `undefined`.
      */
     getLast() {
       return this.size > 0 ? this.nodes[this.nodes.length - 1] : void 0;
@@ -2938,9 +2935,9 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
      * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
-     * array is empty, it returns `null`.
+     * array is empty, it returns `undefined`.
      */
     peekLast() {
       return this.getLast();
@@ -2967,8 +2964,8 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n) - same as shift().
      * Space Complexity: O(1) - same as shift().
      *
-     * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
-     * @returns The method is returning a value of type E or null.
+     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
+     * @returns The method is returning a value of type E or undefined.
      */
     dequeue() {
       return this.shift();
@@ -4968,14 +4965,14 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
      *
-     * The function "getVertex" returns the vertex with the specified ID or null if it doesn't exist.
+     * The function "getVertex" returns the vertex with the specified ID or undefined if it doesn't exist.
      * @param {VertexKey} vertexKey - The `vertexKey` parameter is the identifier of the vertex that you want to retrieve from
      * the `_vertices` map.
      * @returns The method `getVertex` returns the vertex with the specified `vertexKey` if it exists in the `_vertices`
-     * map. If the vertex does not exist, it returns `null`.
+     * map. If the vertex does not exist, it returns `undefined`.
      */
     getVertex(vertexKey) {
-      return this._vertices.get(vertexKey) || null;
+      return this._vertices.get(vertexKey) || void 0;
     }
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
@@ -5207,7 +5204,7 @@ var dataStructureTyped = (() => {
         const vertex2 = this._getVertex(v2);
         const vertex1 = this._getVertex(v1);
         if (!(vertex1 && vertex2)) {
-          return null;
+          return void 0;
         }
         const visited = /* @__PURE__ */ new Map();
         const queue = new Queue([vertex1]);
@@ -5231,7 +5228,7 @@ var dataStructureTyped = (() => {
           }
           cost++;
         }
-        return null;
+        return void 0;
       }
     }
     /**
@@ -5255,7 +5252,7 @@ var dataStructureTyped = (() => {
      * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
      * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
      * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
-     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
+     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `undefined`.
      */
     getMinPathBetween(v1, v2, isWeight, isDFS = false) {
       var _a, _b;
@@ -5275,7 +5272,7 @@ var dataStructureTyped = (() => {
             }
             index++;
           }
-          return allPaths[minIndex] || null;
+          return allPaths[minIndex] || void 0;
         } else {
           return (_b = (_a = this.dijkstra(v1, v2, true, true)) == null ? void 0 : _a.minPath) != null ? _b : [];
         }
@@ -5321,9 +5318,9 @@ var dataStructureTyped = (() => {
      * a graph without using a heap data structure.
      * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
      * vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
      * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
-     * identifier. If no destination is provided, the value is set to `null`.
+     * identifier. If no destination is provided, the value is set to `undefined`.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
      * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
      * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
@@ -5338,9 +5335,9 @@ var dataStructureTyped = (() => {
       if (genPaths === void 0)
         genPaths = false;
       if (dest === void 0)
-        dest = null;
+        dest = void 0;
       let minDist = Infinity;
-      let minDest = null;
+      let minDest = void 0;
       let minPath = [];
       const paths = [];
       const vertices = this._vertices;
@@ -5348,9 +5345,9 @@ var dataStructureTyped = (() => {
       const seen = /* @__PURE__ */ new Set();
       const preMap = /* @__PURE__ */ new Map();
       const srcVertex = this._getVertex(src);
-      const destVertex = dest ? this._getVertex(dest) : null;
+      const destVertex = dest ? this._getVertex(dest) : void 0;
       if (!srcVertex) {
-        return null;
+        return void 0;
       }
       for (const vertex of vertices) {
         const vertexOrKey = vertex[1];
@@ -5358,10 +5355,10 @@ var dataStructureTyped = (() => {
           distMap.set(vertexOrKey, Infinity);
       }
       distMap.set(srcVertex, 0);
-      preMap.set(srcVertex, null);
+      preMap.set(srcVertex, void 0);
       const getMinOfNoSeen = () => {
         let min = Infinity;
-        let minV = null;
+        let minV = void 0;
         for (const [key, value] of distMap) {
           if (!seen.has(key)) {
             if (value < min) {
@@ -5454,7 +5451,7 @@ var dataStructureTyped = (() => {
      * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
      * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
      * start. It can be either a vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
      * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
      * will calculate the shortest paths to all other vertices from the source vertex.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
@@ -5472,9 +5469,9 @@ var dataStructureTyped = (() => {
       if (genPaths === void 0)
         genPaths = false;
       if (dest === void 0)
-        dest = null;
+        dest = void 0;
       let minDist = Infinity;
-      let minDest = null;
+      let minDest = void 0;
       let minPath = [];
       const paths = [];
       const vertices = this._vertices;
@@ -5482,9 +5479,9 @@ var dataStructureTyped = (() => {
       const seen = /* @__PURE__ */ new Set();
       const preMap = /* @__PURE__ */ new Map();
       const srcVertex = this._getVertex(src);
-      const destVertex = dest ? this._getVertex(dest) : null;
+      const destVertex = dest ? this._getVertex(dest) : void 0;
       if (!srcVertex)
-        return null;
+        return void 0;
       for (const vertex of vertices) {
         const vertexOrKey = vertex[1];
         if (vertexOrKey instanceof AbstractVertex)
@@ -5493,7 +5490,7 @@ var dataStructureTyped = (() => {
       const heap = new PriorityQueue([], { comparator: (a, b) => a.key - b.key });
       heap.add({ key: 0, value: srcVertex });
       distMap.set(srcVertex, 0);
-      preMap.set(srcVertex, null);
+      preMap.set(srcVertex, void 0);
       const getPaths = (minV) => {
         for (const vertex of vertices) {
           const vertexOrKey = vertex[1];
@@ -5627,7 +5624,7 @@ var dataStructureTyped = (() => {
           }
         }
       }
-      let minDest = null;
+      let minDest = void 0;
       if (getMin) {
         distMap.forEach((d, v) => {
           if (v !== srcVertex) {
@@ -5703,7 +5700,7 @@ var dataStructureTyped = (() => {
        * graph.
        * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
        * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
-       * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
+       * `predecessor` property is a 2D array of vertices (or `undefined`) representing the predecessor vertices in the shortest
        * path between vertices in the
        */
     floydWarshall() {
@@ -5716,7 +5713,7 @@ var dataStructureTyped = (() => {
         costs[i] = [];
         predecessor[i] = [];
         for (let j = 0; j < n; j++) {
-          predecessor[i][j] = null;
+          predecessor[i][j] = void 0;
         }
       }
       for (let i = 0; i < n; i++) {
@@ -5827,7 +5824,7 @@ var dataStructureTyped = (() => {
           }
         }
       };
-      dfs(root, null);
+      dfs(root, void 0);
       let SCCs = /* @__PURE__ */ new Map();
       const getSCCs = () => {
         const SCCs2 = /* @__PURE__ */ new Map();
@@ -5920,7 +5917,7 @@ var dataStructureTyped = (() => {
     }
     _getVertex(vertexOrKey) {
       const vertexKey = this._getVertexKey(vertexOrKey);
-      return this._vertices.get(vertexKey) || null;
+      return this._vertices.get(vertexKey) || void 0;
     }
     _getVertexKey(vertexOrKey) {
       return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
@@ -6017,15 +6014,15 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `getEdge` function retrieves an edge between two vertices based on their source and destination IDs.
-     * @param {VO | VertexKey | null} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
-     * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `null` if the
+     * @param {VO | VertexKey | undefined} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
+     * @param {VO | VertexKey | undefined} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
+     * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `undefined` if the
      * destination is not specified.
-     * @returns the first edge found between the source and destination vertices, or null if no such edge is found.
+     * @returns the first edge found between the source and destination vertices, or undefined if no such edge is found.
      */
     getEdge(srcOrKey, destOrKey) {
       let edges = [];
-      if (srcOrKey !== null && destOrKey !== null) {
+      if (srcOrKey !== void 0 && destOrKey !== void 0) {
         const src = this._getVertex(srcOrKey);
         const dest = this._getVertex(destOrKey);
         if (src && dest) {
@@ -6035,7 +6032,7 @@ var dataStructureTyped = (() => {
           }
         }
       }
-      return edges[0] || null;
+      return edges[0] || void 0;
     }
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
@@ -6048,14 +6045,14 @@ var dataStructureTyped = (() => {
      * The function removes an edge between two vertices in a graph and returns the removed edge.
      * @param {VO | VertexKey} srcOrKey - The source vertex or its ID.
      * @param {VO | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
-     * @returns the removed edge (EO) if it exists, or null if either the source or destination vertex does not exist.
+     * @returns the removed edge (EO) if it exists, or undefined if either the source or destination vertex does not exist.
      */
     deleteEdgeSrcToDest(srcOrKey, destOrKey) {
       const src = this._getVertex(srcOrKey);
       const dest = this._getVertex(destOrKey);
-      let removed = null;
+      let removed = void 0;
       if (!src || !dest) {
-        return null;
+        return void 0;
       }
       const srcOutEdges = this._outEdgeMap.get(src);
       if (srcOutEdges) {
@@ -6063,7 +6060,7 @@ var dataStructureTyped = (() => {
       }
       const destInEdges = this._inEdgeMap.get(dest);
       if (destInEdges) {
-        removed = arrayRemove(destInEdges, (edge) => edge.src === src.key)[0] || null;
+        removed = arrayRemove(destInEdges, (edge) => edge.src === src.key)[0] || void 0;
       }
       return removed;
     }
@@ -6075,13 +6072,13 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
      *
-     * The function removes an edge from a graph and returns the removed edge, or null if the edge was not found.
+     * The function removes an edge from a graph and returns the removed edge, or undefined if the edge was not found.
      * @param {EO} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
      * and `dest`, which represent the source and destination vertices of the edge, respectively.
-     * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `null` if the edge does not exist.
+     * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `undefined` if the edge does not exist.
      */
     deleteEdge(edge) {
-      let removed = null;
+      let removed = void 0;
       const src = this._getVertex(edge.src);
       const dest = this._getVertex(edge.dest);
       if (src && dest) {
@@ -6229,9 +6226,9 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function "getEdgeSrc" returns the source vertex of an edge, or null if the edge does not exist.
+     * The function "getEdgeSrc" returns the source vertex of an edge, or undefined if the edge does not exist.
      * @param {EO} e - The parameter "e" is of type EO, which represents an edge in a graph.
-     * @returns either a vertex object (VO) or null.
+     * @returns either a vertex object (VO) or undefined.
      */
     getEdgeSrc(e) {
       return this._getVertex(e.src);
@@ -6246,7 +6243,7 @@ var dataStructureTyped = (() => {
      *
      * The function "getEdgeDest" returns the destination vertex of an edge.
      * @param {EO} e - The parameter "e" is of type "EO", which represents an edge in a graph.
-     * @returns either a vertex object of type VO or null.
+     * @returns either a vertex object of type VO or undefined.
      */
     getEdgeDest(e) {
       return this._getVertex(e.dest);
@@ -6260,12 +6257,12 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `getDestinations` returns an array of destination vertices connected to a given vertex.
-     * @param {VO | VertexKey | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
-     * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `null`.
+     * @param {VO | VertexKey | undefined} vertex - The `vertex` parameter represents the starting vertex from which we want to
+     * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `undefined`.
      * @returns an array of vertices (VO[]).
      */
     getDestinations(vertex) {
-      if (vertex === null) {
+      if (vertex === void 0) {
         return [];
       }
       const destinations = [];
@@ -6287,11 +6284,11 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(|V|)
      *
      * The `topologicalSort` function performs a topological sort on a graph and returns an array of vertices or vertex IDs
-     * in the sorted order, or null if the graph contains a cycle.
+     * in the sorted order, or undefined if the graph contains a cycle.
      * @param {'vertex' | 'key'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
      * property to use for sorting the vertices. It can have two possible values: 'vertex' or 'key'. If 'vertex' is
      * specified, the vertices themselves will be used for sorting. If 'key' is specified, the ids of
-     * @returns an array of vertices or vertex IDs in topological order. If there is a cycle in the graph, it returns null.
+     * @returns an array of vertices or vertex IDs in topological order. If there is a cycle in the graph, it returns undefined.
      */
     topologicalSort(propertyName) {
       propertyName = propertyName != null ? propertyName : "key";
@@ -6321,7 +6318,7 @@ var dataStructureTyped = (() => {
         }
       }
       if (hasCycle)
-        return null;
+        return void 0;
       if (propertyName === "key")
         sorted = sorted.map((vertex) => vertex instanceof DirectedVertex ? vertex.key : vertex);
       return sorted.reverse();
@@ -6380,21 +6377,21 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function "getEndsOfEdge" returns the source and destination vertices of an edge if it exists in the graph,
-     * otherwise it returns null.
+     * otherwise it returns undefined.
      * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph.
      * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
-     * graph. If the edge does not exist, it returns `null`.
+     * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge) {
       if (!this.hasEdge(edge.src, edge.dest)) {
-        return null;
+        return void 0;
       }
       const v1 = this._getVertex(edge.src);
       const v2 = this._getVertex(edge.dest);
       if (v1 && v2) {
         return [v1, v2];
       } else {
-        return null;
+        return void 0;
       }
     }
     /**
@@ -6512,24 +6509,24 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-     * @param {VO | VertexKey | null} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
-     * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
-     * @param {VO | VertexKey | null} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
-     * object), `null`, or `VertexKey` (vertex ID).
-     * @returns an edge (EO) or null.
+     * The function `getEdge` returns the first edge that connects two vertices, or undefined if no such edge exists.
+     * @param {VO | VertexKey | undefined} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
+     * object), `undefined`, or `VertexKey` (a string or number representing the ID of a vertex).
+     * @param {VO | VertexKey | undefined} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
+     * object), `undefined`, or `VertexKey` (vertex ID).
+     * @returns an edge (EO) or undefined.
      */
     getEdge(v1, v2) {
       var _a;
       let edges = [];
-      if (v1 !== null && v2 !== null) {
+      if (v1 !== void 0 && v2 !== void 0) {
         const vertex1 = this._getVertex(v1);
         const vertex2 = this._getVertex(v2);
         if (vertex1 && vertex2) {
           edges = (_a = this._edges.get(vertex1)) == null ? void 0 : _a.filter((e) => e.vertices.includes(vertex2.key));
         }
       }
-      return edges ? edges[0] || null : null;
+      return edges ? edges[0] || void 0 : void 0;
     }
     /**
      * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
@@ -6543,18 +6540,18 @@ var dataStructureTyped = (() => {
      * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
      * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
      * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-     * @returns the removed edge (EO) if it exists, or null if either of the vertices (VO) does not exist.
+     * @returns the removed edge (EO) if it exists, or undefined if either of the vertices (VO) does not exist.
      */
     deleteEdgeBetween(v1, v2) {
       const vertex1 = this._getVertex(v1);
       const vertex2 = this._getVertex(v2);
       if (!vertex1 || !vertex2) {
-        return null;
+        return void 0;
       }
       const v1Edges = this._edges.get(vertex1);
-      let removed = null;
+      let removed = void 0;
       if (v1Edges) {
-        removed = arrayRemove(v1Edges, (e) => e.vertices.includes(vertex2.key))[0] || null;
+        removed = arrayRemove(v1Edges, (e) => e.vertices.includes(vertex2.key))[0] || void 0;
       }
       const v2Edges = this._edges.get(vertex2);
       if (v2Edges) {
@@ -6572,7 +6569,7 @@ var dataStructureTyped = (() => {
      *
      * The deleteEdge function removes an edge between two vertices in a graph.
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
-     * @returns The method is returning either the removed edge (of type EO) or null if the edge was not found.
+     * @returns The method is returning either the removed edge (of type EO) or undefined if the edge was not found.
      */
     deleteEdge(edge) {
       return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
@@ -6677,21 +6674,21 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
-     * it returns null.
+     * it returns undefined.
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
      * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
-     * graph. If the edge does not exist, it returns `null`.
+     * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge) {
       if (!this.hasEdge(edge.vertices[0], edge.vertices[1])) {
-        return null;
+        return void 0;
       }
       const v1 = this._getVertex(edge.vertices[0]);
       const v2 = this._getVertex(edge.vertices[1]);
       if (v1 && v2) {
         return [v1, v2];
       } else {
-        return null;
+        return void 0;
       }
     }
     /**
@@ -6709,7 +6706,7 @@ var dataStructureTyped = (() => {
     _addEdgeOnly(edge) {
       for (const end of edge.vertices) {
         const endVertex = this._getVertex(end);
-        if (endVertex === null)
+        if (endVertex === void 0)
           return false;
         if (endVertex) {
           const edges = this._edges.get(endVertex);
@@ -6849,55 +6846,27 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/binary-tree/binary-tree.ts
   var BinaryTreeNode = class {
-    /**
-     * Creates a new instance of BinaryTreeNode.
-     * @param {BTNKey} key - The key associated with the node.
-     * @param {V} value - The value stored in the node.
-     */
     constructor(key, value) {
-      /**
-       * The key associated with the node.
-       */
       __publicField(this, "key");
-      /**
-       * The value stored in the node.
-       */
       __publicField(this, "value");
-      /**
-       * The parent node of the current node.
-       */
       __publicField(this, "parent");
       __publicField(this, "_left");
       __publicField(this, "_right");
       this.key = key;
       this.value = value;
     }
-    /**
-     * Get the left child node.
-     */
     get left() {
       return this._left;
     }
-    /**
-     * Set the left child node.
-     * @param {N | null | undefined} v - The left child node.
-     */
     set left(v) {
       if (v) {
         v.parent = this;
       }
       this._left = v;
     }
-    /**
-     * Get the right child node.
-     */
     get right() {
       return this._right;
     }
-    /**
-     * Set the right child node.
-     * @param {N | null | undefined} v - The right child node.
-     */
     set right(v) {
       if (v) {
         v.parent = this;
@@ -6923,8 +6892,13 @@ var dataStructureTyped = (() => {
   };
   var BinaryTree = class _BinaryTree {
     /**
-     * Creates a new instance of BinaryTree.
-     * @param {BinaryTreeOptions} [options] - The options for the binary tree.
+     * The constructor function initializes a binary tree object with optional elements and options.
+     * @param [elements] - An optional iterable of BTNodeExemplar objects. These objects represent the
+     * elements to be added to the binary tree.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the binary tree. In this case, it is of type
+     * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
+     * required.
      */
     constructor(elements, options) {
       __publicField(this, "iterationType", "ITERATIVE" /* ITERATIVE */);
@@ -6939,17 +6913,11 @@ var dataStructureTyped = (() => {
       }
       this._size = 0;
       if (elements)
-        this.init(elements);
+        this.addMany(elements);
     }
-    /**
-     * Get the root node of the binary tree.
-     */
     get root() {
       return this._root;
     }
-    /**
-     * Get the number of nodes in the binary tree.
-     */
     get size() {
       return this._size;
     }
@@ -6962,30 +6930,46 @@ var dataStructureTyped = (() => {
     createNode(key, value) {
       return new BinaryTreeNode(key, value);
     }
+    /**
+     * The function creates a binary tree with the given options.
+     * @param [options] - The `options` parameter is an optional object that allows you to customize the
+     * behavior of the `BinaryTree` class. It is of type `Partial<BinaryTreeOptions>`, which means that
+     * you can provide only a subset of the properties defined in the `BinaryTreeOptions` interface.
+     * @returns a new instance of a binary tree.
+     */
     createTree(options) {
       return new _BinaryTree([], __spreadValues({ iterationType: this.iterationType }, options));
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * The function checks if a given value is an entry in a binary tree node.
+     * @param kne - BTNodeExemplar<V, N> - A generic type representing a node in a binary tree. It has
+     * two type parameters V and N, representing the value and node type respectively.
+     * @returns a boolean value.
+     */
+    isEntry(kne) {
+      return Array.isArray(kne) && kne.length === 2;
+    }
+    /**
+     * Time Complexity O(log n) - O(n)
+     * Space Complexity O(1)
+     */
+    /**
+     * Time Complexity O(log n) - O(n)
+     * Space Complexity O(1)
      *
-     * The `add` function adds a new node with a key and value to a binary tree, or updates the value of
-     * an existing node with the same key.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The value to be associated with the key or node being added to the binary
-     * tree.
-     * @returns The function `add` returns a node (`N`) if it was successfully inserted into the binary
-     * tree, or `null` or `undefined` if the insertion was not successful.
+     * The `add` function adds a new node to a binary tree, either by key or by providing a node object.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be one of the following:
+     * @returns The function `add` returns the inserted node (`N`), `null`, or `undefined`.
      */
-    add(keyOrNode, value) {
+    add(keyOrNodeOrEntry) {
+      let inserted, needInsert;
       const _bfs = (root, newNode) => {
         const queue = new Queue([root]);
         while (queue.size > 0) {
           const cur = queue.shift();
           if (newNode && cur.key === newNode.key) {
-            cur.value = newNode.value;
-            return;
+            this._replaceNode(cur, newNode);
+            return newNode;
           }
           const inserted2 = this._addTo(newNode, cur);
           if (inserted2 !== void 0)
@@ -6996,13 +6980,21 @@ var dataStructureTyped = (() => {
             queue.push(cur.right);
         }
       };
-      let inserted, needInsert;
-      if (keyOrNode === null) {
+      if (keyOrNodeOrEntry === null) {
         needInsert = null;
-      } else if (this.isNodeKey(keyOrNode)) {
-        needInsert = this.createNode(keyOrNode, value);
-      } else if (keyOrNode instanceof BinaryTreeNode) {
-        needInsert = keyOrNode;
+      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
+        needInsert = this.createNode(keyOrNodeOrEntry);
+      } else if (keyOrNodeOrEntry instanceof BinaryTreeNode) {
+        needInsert = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value] = keyOrNodeOrEntry;
+        if (key === void 0) {
+          return;
+        } else if (key === null) {
+          needInsert = null;
+        } else {
+          needInsert = this.createNode(key, value);
+        }
       } else {
         return;
       }
@@ -7020,35 +7012,27 @@ var dataStructureTyped = (() => {
       return inserted;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
      * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
      */
     /**
-     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+     * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
      *
-     * The `addMany` function takes an array of keys or nodes and an optional array of values, and adds
-     * each key-value pair to a data structure.
-     * @param {(BTNKey | N |null | undefined)[]} keysOrNodes - An array of keys or nodes to be added to
-     * the binary search tree. Each element can be of type `BTNKey` (a key value), `N` (a node), `null`,
-     * or `undefined`.
-     * @param {(V | undefined)[]} [values] - The `values` parameter is an optional array of values that
-     * correspond to the keys or nodes being added. If provided, the values will be associated with the
-     * keys or nodes during the add operation.
-     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     * The function `addMany` takes in an iterable of `BTNodeExemplar` objects, adds each object to the
+     * current instance, and returns an array of the inserted nodes.
+     * @param nodes - The `nodes` parameter is an iterable (such as an array or a set) of
+     * `BTNodeExemplar<V, N>` objects.
+     * @returns The function `addMany` returns an array of values, where each value is either of type
+     * `N`, `null`, or `undefined`.
      */
-    addMany(keysOrNodes, values) {
-      return keysOrNodes.map((keyOrNode, i) => {
-        if (keyOrNode instanceof BinaryTreeNode) {
-          return this.add(keyOrNode.key, keyOrNode.value);
-        }
-        if (keyOrNode === null) {
-          return this.add(null);
-        }
-        const value = values == null ? void 0 : values[i];
-        return this.add(keyOrNode, value);
-      });
+    addMany(nodes) {
+      const inserted = [];
+      for (const kne of nodes) {
+        inserted.push(this.add(kne));
+      }
+      return inserted;
     }
     /**
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
@@ -7058,17 +7042,13 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
      * Space Complexity: O(1)
      *
-     * The `refill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
-     * @param {(BTNKey | N)[]} keysOrNodes - The `keysOrNodes` parameter is an array that can contain either
-     * `BTNKey` or `N` values.
-     * @param {N[] | Array<V>} [values] - The `data` parameter is an optional array of values that will be assigned to
-     * the nodes being added. If provided, the length of the `data` array should be equal to the length of the `keysOrNodes`
-     * array. Each value in the `data` array will be assigned to the
-     * @returns The method is returning a boolean value.
+     * The `refill` function clears the current collection and adds new nodes, keys, or entries to it.
+     * @param nodesOrKeysOrEntries - The parameter `nodesOrKeysOrEntries` is an iterable object that can
+     * contain either `BTNodeExemplar` objects, keys, or entries.
      */
-    refill(keysOrNodes, values) {
+    refill(nodesOrKeysOrEntries) {
       this.clear();
-      return keysOrNodes.length === this.addMany(keysOrNodes, values).length;
+      this.addMany(nodesOrKeysOrEntries);
     }
     /**
      * Time Complexity: O(n)
@@ -7114,7 +7094,7 @@ var dataStructureTyped = (() => {
           const leftSubTreeRightMost = this.getRightMost(curr.left);
           if (leftSubTreeRightMost) {
             const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-            orgCurrent = this._swap(curr, leftSubTreeRightMost);
+            orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
             if (parentOfLeftSubTreeMax) {
               if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
                 parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
@@ -7147,8 +7127,8 @@ var dataStructureTyped = (() => {
      * @returns the depth of the `distNode` relative to the `beginRoot`.
      */
     getDepth(distNode, beginRoot = this.root) {
-      distNode = this.ensureNotKey(distNode);
-      beginRoot = this.ensureNotKey(beginRoot);
+      distNode = this.ensureNode(distNode);
+      beginRoot = this.ensureNode(beginRoot);
       let depth = 0;
       while (distNode == null ? void 0 : distNode.parent) {
         if (distNode === beginRoot) {
@@ -7178,7 +7158,7 @@ var dataStructureTyped = (() => {
      * @returns the height of the binary tree.
      */
     getHeight(beginRoot = this.root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return -1;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7224,7 +7204,7 @@ var dataStructureTyped = (() => {
      */
     getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
       var _a, _b, _c;
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return -1;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7311,7 +7291,7 @@ var dataStructureTyped = (() => {
     getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
       if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
@@ -7448,7 +7428,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(log n)
      */
     /**
-     * The function `ensureNotKey` returns the node corresponding to the given key if it is a valid node
+     * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
      * @param {BTNKey | N | null | undefined} key - The `key` parameter can be of type `BTNKey`, `N`,
      * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
@@ -7458,7 +7438,7 @@ var dataStructureTyped = (() => {
      * @returns either the node corresponding to the given key if it is a valid node key, or the key
      * itself if it is not a valid node key.
      */
-    ensureNotKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
+    ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
       return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
@@ -7523,7 +7503,7 @@ var dataStructureTyped = (() => {
      */
     getPathToRoot(beginRoot, isReverse = true) {
       const result = [];
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return result;
       while (beginRoot.parent) {
@@ -7552,7 +7532,7 @@ var dataStructureTyped = (() => {
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return beginRoot;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7591,7 +7571,7 @@ var dataStructureTyped = (() => {
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
     getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return beginRoot;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7627,7 +7607,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     isSubtreeBST(beginRoot, iterationType = this.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return true;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7699,7 +7679,7 @@ var dataStructureTyped = (() => {
      * by the return type of the `callback` function.
      */
     subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       const ans = [];
       if (!beginRoot)
         return ans;
@@ -7797,7 +7777,7 @@ var dataStructureTyped = (() => {
      * @returns an array of values that are the return values of the callback function.
      */
     dfs(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root, iterationType = "ITERATIVE" /* ITERATIVE */, includeNull = false) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
@@ -7917,7 +7897,7 @@ var dataStructureTyped = (() => {
      * the breadth-first traversal of a binary tree.
      */
     bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
@@ -7987,7 +7967,7 @@ var dataStructureTyped = (() => {
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
     listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       const levelsNodes = [];
       if (!beginRoot)
         return levelsNodes;
@@ -8039,7 +8019,7 @@ var dataStructureTyped = (() => {
      * @returns The function `getPredecessor` returns a value of type `N | undefined`.
      */
     getPredecessor(node) {
-      node = this.ensureNotKey(node);
+      node = this.ensureNode(node);
       if (!this.isRealNode(node))
         return void 0;
       if (node.left) {
@@ -8061,7 +8041,7 @@ var dataStructureTyped = (() => {
      * after the given node in the inorder traversal of the binary tree.
      */
     getSuccessor(x) {
-      x = this.ensureNotKey(x);
+      x = this.ensureNode(x);
       if (!x)
         return void 0;
       if (x.right) {
@@ -8093,7 +8073,7 @@ var dataStructureTyped = (() => {
      * by the return type of the `callback` function.
      */
     morris(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (beginRoot === null)
         return [];
       const ans = [];
@@ -8200,7 +8180,7 @@ var dataStructureTyped = (() => {
       const newTree = this.createTree();
       for (const [key, value] of this) {
         if (predicate([key, value], this)) {
-          newTree.add(key, value);
+          newTree.add([key, value]);
         }
       }
       return newTree;
@@ -8214,7 +8194,7 @@ var dataStructureTyped = (() => {
     map(callback) {
       const newTree = this.createTree();
       for (const [key, value] of this) {
-        newTree.add(key, callback([key, value], this));
+        newTree.add([key, callback([key, value], this)]);
       }
       return newTree;
     }
@@ -8290,7 +8270,7 @@ var dataStructureTyped = (() => {
      */
     print(beginRoot = this.root, options) {
       const opts = __spreadValues({ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false }, options);
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return;
       if (opts.isShowUndefined)
@@ -8310,18 +8290,6 @@ var dataStructureTyped = (() => {
       };
       display(beginRoot);
     }
-    init(elements) {
-      if (elements) {
-        for (const entryOrKey of elements) {
-          if (Array.isArray(entryOrKey)) {
-            const [key, value] = entryOrKey;
-            this.add(key, value);
-          } else {
-            this.add(entryOrKey);
-          }
-        }
-      }
-    }
     _displayAux(node, options) {
       const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
       const emptyDisplayLayout = [["\u2500"], 1, 0, 0];
@@ -8358,9 +8326,9 @@ var dataStructureTyped = (() => {
      * @param {N} destNode - The destination node to swap.
      * @returns {N} - The destination node after the swap.
      */
-    _swap(srcNode, destNode) {
-      srcNode = this.ensureNotKey(srcNode);
-      destNode = this.ensureNotKey(destNode);
+    _swapProperties(srcNode, destNode) {
+      srcNode = this.ensureNode(srcNode);
+      destNode = this.ensureNode(destNode);
       if (srcNode && destNode) {
         const { key, value } = destNode;
         const tempNode = this.createNode(key, value);
@@ -8374,6 +8342,30 @@ var dataStructureTyped = (() => {
       }
       return void 0;
     }
+    /**
+     * The function replaces an old node with a new node in a binary tree.
+     * @param {N} oldNode - The oldNode parameter represents the node that needs to be replaced in the
+     * tree.
+     * @param {N} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
+     * tree.
+     * @returns The method is returning the newNode.
+     */
+    _replaceNode(oldNode, newNode) {
+      if (oldNode.parent) {
+        if (oldNode.parent.left === oldNode) {
+          oldNode.parent.left = newNode;
+        } else if (oldNode.parent.right === oldNode) {
+          oldNode.parent.right = newNode;
+        }
+      }
+      newNode.left = oldNode.left;
+      newNode.right = oldNode.right;
+      newNode.parent = oldNode.parent;
+      if (this.root === oldNode) {
+        this._root = newNode;
+      }
+      return newNode;
+    }
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
      * @param {N | null | undefined} newNode - The `newNode` parameter represents the node that you want to add to
@@ -8468,9 +8460,12 @@ var dataStructureTyped = (() => {
   };
   var BST = class _BST extends BinaryTree {
     /**
-     * The constructor function initializes a binary search tree with an optional comparator function.
-     * @param {BSTOptions} [options] - An optional object that contains additional configuration options
-     * for the binary search tree.
+     * This is the constructor function for a binary search tree class in TypeScript, which initializes
+     * the tree with optional elements and options.
+     * @param [elements] - An optional iterable of BTNodeExemplar objects that will be added to the
+     * binary search tree.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the binary search tree. It can have the following properties:
      */
     constructor(elements, options) {
       super([], options);
@@ -8484,11 +8479,8 @@ var dataStructureTyped = (() => {
       }
       this._root = void 0;
       if (elements)
-        this.init(elements);
+        this.addMany(elements);
     }
-    /**
-     * Get the root node of the binary tree.
-     */
     get root() {
       return this._root;
     }
@@ -8503,151 +8495,145 @@ var dataStructureTyped = (() => {
     createNode(key, value) {
       return new BSTNode(key, value);
     }
+    /**
+     * The function creates a new binary search tree with the specified options.
+     * @param [options] - The `options` parameter is an optional object that allows you to customize the
+     * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which is a type
+     * that defines various options for creating a binary search tree.
+     * @returns a new instance of the BST class with the specified options.
+     */
     createTree(options) {
       return new _BST([], __spreadValues({
         iterationType: this.iterationType,
         comparator: this.comparator
       }, options));
     }
+    /**
+     * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
+     * Space Complexity: O(1) - Constant space is used.
+     */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
      *
-     * The `add` function adds a new node to a binary search tree based on the provided key and value.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
-     * key or node being added to the binary search tree.
-     * @returns The method `add` returns a node (`N`) that was inserted into the binary search tree. If
-     * no node was inserted, it returns `undefined`.
+     * The `add` function adds a new node to a binary search tree, either by key or by providing a node
+     * object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
+     * @returns The method returns either the newly added node (`newNode`) or `undefined` if the input
+     * (`keyOrNodeOrEntry`) is null, undefined, or does not match any of the expected types.
      */
-    add(keyOrNode, value) {
-      if (keyOrNode === null)
+    add(keyOrNodeOrEntry) {
+      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
         return void 0;
-      let inserted;
+      }
       let newNode;
-      if (keyOrNode instanceof BSTNode) {
-        newNode = keyOrNode;
-      } else if (this.isNodeKey(keyOrNode)) {
-        newNode = this.createNode(keyOrNode, value);
+      if (keyOrNodeOrEntry instanceof BSTNode) {
+        newNode = keyOrNodeOrEntry;
+      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
+        newNode = this.createNode(keyOrNodeOrEntry);
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value] = keyOrNodeOrEntry;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          newNode = this.createNode(key, value);
+        }
       } else {
-        newNode = void 0;
+        return;
       }
       if (this.root === void 0) {
         this._setRoot(newNode);
-        this._size = this.size + 1;
-        inserted = this.root;
-      } else {
-        let cur = this.root;
-        let traversing = true;
-        while (traversing) {
-          if (cur !== void 0 && newNode !== void 0) {
-            if (this._compare(cur.key, newNode.key) === "eq" /* eq */) {
-              if (newNode) {
-                cur.value = newNode.value;
-              }
-              traversing = false;
-              inserted = cur;
-            } else if (this._compare(cur.key, newNode.key) === "gt" /* gt */) {
-              if (cur.left === void 0) {
-                if (newNode) {
-                  newNode.parent = cur;
-                }
-                cur.left = newNode;
-                this._size = this.size + 1;
-                traversing = false;
-                inserted = cur.left;
-              } else {
-                if (cur.left)
-                  cur = cur.left;
-              }
-            } else if (this._compare(cur.key, newNode.key) === "lt" /* lt */) {
-              if (cur.right === void 0) {
-                if (newNode) {
-                  newNode.parent = cur;
-                }
-                cur.right = newNode;
-                this._size = this.size + 1;
-                traversing = false;
-                inserted = cur.right;
-              } else {
-                if (cur.right)
-                  cur = cur.right;
-              }
-            }
-          } else {
-            traversing = false;
+        this._size++;
+        return this.root;
+      }
+      let current = this.root;
+      while (current !== void 0) {
+        if (this._compare(current.key, newNode.key) === "eq" /* eq */) {
+          this._replaceNode(current, newNode);
+          return newNode;
+        } else if (this._compare(current.key, newNode.key) === "gt" /* gt */) {
+          if (current.left === void 0) {
+            current.left = newNode;
+            newNode.parent = current;
+            this._size++;
+            return newNode;
           }
+          current = current.left;
+        } else {
+          if (current.right === void 0) {
+            current.right = newNode;
+            newNode.parent = current;
+            this._size++;
+            return newNode;
+          }
+          current = current.right;
         }
       }
-      return inserted;
+      return void 0;
     }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
+     * Space Complexity: O(k) - Additional space is required for the sorted array.
      */
     /**
-     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
+     * Space Complexity: O(k) - Additional space is required for the sorted array.
      *
-     * The `addMany` function is used to efficiently add multiple keys or nodes with corresponding data
-     * to a binary search tree.
-     * @param {(BTNKey | N | undefined)[]} keysOrNodes - An array of keys or nodes to be added to the
-     * binary search tree. Each element can be of type `BTNKey` (binary tree node key), `N` (binary tree
-     * node), or `undefined`.
-     * @param {(V | undefined)[]} [data] - An optional array of values to associate with the keys or
-     * nodes being added. If provided, the length of the `data` array must be the same as the length of
-     * the `keysOrNodes` array.
+     * The `addMany` function in TypeScript adds multiple nodes to a binary tree, either in a balanced or
+     * unbalanced manner, and returns an array of the inserted nodes.
+     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries to be added to the
+     * binary tree.
      * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
-     * adding the nodes. The default value is `true`.
+     * adding the nodes. The default value is true.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when adding multiple keys or nodes to the binary search tree. It has a
-     * default value of `this.iterationType`, which means it will use the iteration type specified in the
-     * current instance of the binary search tree
-     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
+     * type of iteration to use when adding multiple keys or nodes to the binary tree. It has a default
+     * value of `this.iterationType`, which means it will use the iteration type specified by the binary
+     * tree instance.
+     * @returns The `addMany` function returns an array of `N` or `undefined` values.
      */
-    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
-      function hasNoUndefined(arr) {
-        return arr.indexOf(void 0) === -1;
-      }
-      if (!isBalanceAdd || !hasNoUndefined(keysOrNodes)) {
-        return super.addMany(keysOrNodes, data).map((n) => n != null ? n : void 0);
-      }
+    addMany(keysOrNodesOrEntries, isBalanceAdd = true, iterationType = this.iterationType) {
       const inserted = [];
-      const combinedArr = keysOrNodes.map(
-        (value, index) => [value, data == null ? void 0 : data[index]]
-      );
-      let sorted = [];
-      function _isNodeOrUndefinedTuple(arr) {
-        for (const [keyOrNode] of arr)
-          if (keyOrNode instanceof BSTNode)
-            return true;
-        return false;
+      if (!isBalanceAdd) {
+        for (const kve of keysOrNodesOrEntries) {
+          const nn = this.add(kve);
+          inserted.push(nn);
+        }
+        return inserted;
       }
-      const _isBinaryTreeKeyOrNullTuple = (arr) => {
-        for (const [keyOrNode] of arr)
-          if (this.isNodeKey(keyOrNode))
-            return true;
-        return false;
+      const realBTNExemplars = [];
+      const isRealBTNExemplar = (kve) => {
+        if (kve === void 0 || kve === null)
+          return false;
+        return !(this.isEntry(kve) && (kve[0] === void 0 || kve[0] === null));
       };
-      let sortedKeysOrNodes = [], sortedData = [];
-      if (_isNodeOrUndefinedTuple(combinedArr)) {
-        sorted = combinedArr.sort((a, b) => a[0].key - b[0].key);
-      } else if (_isBinaryTreeKeyOrNullTuple(combinedArr)) {
-        sorted = combinedArr.sort((a, b) => a[0] - b[0]);
-      } else {
-        throw new Error("Invalid input keysOrNodes");
+      for (const kve of keysOrNodesOrEntries) {
+        isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
       }
-      sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
-      sortedData = sorted.map(([, value]) => value);
-      const _dfs = (arr, data2) => {
+      let sorted = [];
+      sorted = realBTNExemplars.sort((a, b) => {
+        let aR, bR;
+        if (this.isEntry(a))
+          aR = a[0];
+        else if (this.isRealNode(a))
+          aR = a.key;
+        else
+          aR = a;
+        if (this.isEntry(b))
+          bR = b[0];
+        else if (this.isRealNode(b))
+          bR = b.key;
+        else
+          bR = b;
+        return aR - bR;
+      });
+      const _dfs = (arr) => {
         if (arr.length === 0)
           return;
         const mid = Math.floor((arr.length - 1) / 2);
-        const newNode = this.add(arr[mid], data2 == null ? void 0 : data2[mid]);
+        const newNode = this.add(arr[mid]);
         inserted.push(newNode);
-        _dfs(arr.slice(0, mid), data2 == null ? void 0 : data2.slice(0, mid));
-        _dfs(arr.slice(mid + 1), data2 == null ? void 0 : data2.slice(mid + 1));
+        _dfs(arr.slice(0, mid));
+        _dfs(arr.slice(mid + 1));
       };
       const _iterate = () => {
         const n = sorted.length;
@@ -8658,7 +8644,7 @@ var dataStructureTyped = (() => {
             const [l, r] = popped;
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
-              const newNode = this.add(sortedKeysOrNodes[m], sortedData == null ? void 0 : sortedData[m]);
+              const newNode = this.add(sorted[m]);
               inserted.push(newNode);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
@@ -8667,7 +8653,7 @@ var dataStructureTyped = (() => {
         }
       };
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
-        _dfs(sortedKeysOrNodes, sortedData);
+        _dfs(sorted);
       } else {
         _iterate();
       }
@@ -8754,7 +8740,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
      */
     /**
-     * The function `ensureNotKey` returns the node corresponding to the given key if it is a node key,
+     * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
      * otherwise it returns the key itself.
      * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
      * `undefined`.
@@ -8762,7 +8748,7 @@ var dataStructureTyped = (() => {
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
-    ensureNotKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
+    ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
       return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
@@ -8789,7 +8775,7 @@ var dataStructureTyped = (() => {
      * @returns The method returns an array of nodes (`N[]`).
      */
     getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
@@ -8865,7 +8851,7 @@ var dataStructureTyped = (() => {
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
     lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = "lt" /* lt */, targetNode = this.root, iterationType = this.iterationType) {
-      targetNode = this.ensureNotKey(targetNode);
+      targetNode = this.ensureNode(targetNode);
       const ans = [];
       if (!targetNode)
         return ans;
@@ -8929,7 +8915,7 @@ var dataStructureTyped = (() => {
             return;
           const m = l + Math.floor((r - l) / 2);
           const midNode = sorted[m];
-          this.add(midNode.key, midNode.value);
+          this.add([midNode.key, midNode.value]);
           buildBalanceBST(l, m - 1);
           buildBalanceBST(m + 1, r);
         };
@@ -8945,7 +8931,7 @@ var dataStructureTyped = (() => {
               const m = l + Math.floor((r - l) / 2);
               const midNode = sorted[m];
               debugger;
-              this.add(midNode.key, midNode.value);
+              this.add([midNode.key, midNode.value]);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
             }
@@ -9019,22 +9005,6 @@ var dataStructureTyped = (() => {
       }
       return balanced;
     }
-    /**
-     * Time Complexity: O(n) - Visiting each node once.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
-     */
-    init(elements) {
-      if (elements) {
-        for (const entryOrKey of elements) {
-          if (Array.isArray(entryOrKey)) {
-            const [key, value] = entryOrKey;
-            this.add(key, value);
-          } else {
-            this.add(entryOrKey);
-          }
-        }
-      }
-    }
     _setRoot(v) {
       if (v) {
         v.parent = void 0;
@@ -9327,14 +9297,14 @@ var dataStructureTyped = (() => {
     constructor(start, end, sum, value) {
       __publicField(this, "start", 0);
       __publicField(this, "end", 0);
-      __publicField(this, "value", null);
+      __publicField(this, "value");
       __publicField(this, "sum", 0);
-      __publicField(this, "left", null);
-      __publicField(this, "right", null);
+      __publicField(this, "left");
+      __publicField(this, "right");
       this.start = start;
       this.end = end;
       this.sum = sum;
-      this.value = value || null;
+      this.value = value || void 0;
     }
   };
   var SegmentTree = class {
@@ -9360,7 +9330,7 @@ var dataStructureTyped = (() => {
       if (values.length > 0) {
         this._root = this.build(start, end);
       } else {
-        this._root = null;
+        this._root = void 0;
         this._values = [];
       }
     }
@@ -9411,7 +9381,7 @@ var dataStructureTyped = (() => {
      * @returns The function does not return anything.
      */
     updateNode(index, sum, value) {
-      const root = this.root || null;
+      const root = this.root || void 0;
       if (!root) {
         return;
       }
@@ -9446,7 +9416,7 @@ var dataStructureTyped = (() => {
      * @returns The function `querySumByRange` returns a number.
      */
     querySumByRange(indexA, indexB) {
-      const root = this.root || null;
+      const root = this.root || void 0;
       if (!root) {
         return 0;
       }
@@ -9496,15 +9466,18 @@ var dataStructureTyped = (() => {
   };
   var AVLTree = class _AVLTree extends BST {
     /**
-     * This is a constructor function for an AVL tree data structure in TypeScript.
-     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
-     * constructor of the AVLTree class. It allows you to customize the behavior of the AVL tree by providing different
-     * options.
+     * The constructor function initializes an AVLTree object with optional elements and options.
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * objects. It represents a collection of elements that will be added to the AVL tree during
+     * initialization.
+     * @param [options] - The `options` parameter is an optional object that allows you to customize the
+     * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
+     * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
      */
     constructor(elements, options) {
       super([], options);
       if (elements)
-        this.init(elements);
+        super.addMany(elements);
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
@@ -9518,28 +9491,37 @@ var dataStructureTyped = (() => {
     createNode(key, value) {
       return new AVLTreeNode(key, value);
     }
+    /**
+     * The function creates a new AVL tree with the specified options and returns it.
+     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
+     * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
+     * being created.
+     * @returns a new AVLTree object.
+     */
     createTree(options) {
       return new _AVLTree([], __spreadValues({
         iterationType: this.iterationType,
         comparator: this.comparator
       }, options));
     }
+    /**
+     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
+     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     */
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
      *
-     * The function overrides the add method of a class, adds a key-value pair to a data structure, and
-     * balances the structure if necessary.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be of type
-     * `BTNKey`, `N`, `null`, or `undefined`.
-     * @param {V} [value] - The `value` parameter is the value associated with the key that is being
-     * added to the binary search tree.
-     * @returns The method is returning either a node (N) or undefined.
+     * The function overrides the add method of a binary tree node and balances the tree after inserting
+     * a new node.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be either a key, a node, or an
+     * entry.
+     * @returns The method is returning either the inserted node or `undefined`.
      */
-    add(keyOrNode, value) {
-      if (keyOrNode === null)
+    add(keyOrNodeOrEntry) {
+      if (keyOrNodeOrEntry === null)
         return void 0;
-      const inserted = super.add(keyOrNode, value);
+      const inserted = super.add(keyOrNodeOrEntry);
       if (inserted)
         this._balancePath(inserted);
       return inserted;
@@ -9575,23 +9557,7 @@ var dataStructureTyped = (() => {
       return deletedResults;
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (BST) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-     */
-    init(elements) {
-      if (elements) {
-        for (const entryOrKey of elements) {
-          if (Array.isArray(entryOrKey)) {
-            const [key, value] = entryOrKey;
-            this.add(key, value);
-          } else {
-            this.add(entryOrKey);
-          }
-        }
-      }
-    }
-    /**
-     * The `_swap` function swaps the key, value, and height properties between two nodes in a binary
+     * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
      * tree.
      * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node that
      * needs to be swapped with the destination node. It can be of type `BTNKey`, `N`, or `undefined`.
@@ -9600,9 +9566,9 @@ var dataStructureTyped = (() => {
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    _swap(srcNode, destNode) {
-      srcNode = this.ensureNotKey(srcNode);
-      destNode = this.ensureNotKey(destNode);
+    _swapProperties(srcNode, destNode) {
+      srcNode = this.ensureNode(srcNode);
+      destNode = this.ensureNode(destNode);
       if (srcNode && destNode) {
         const { key, value, height } = destNode;
         const tempNode = this.createNode(key, value);
@@ -9889,6 +9855,10 @@ var dataStructureTyped = (() => {
       B && this._updateHeight(B);
       C && this._updateHeight(C);
     }
+    _replaceNode(oldNode, newNode) {
+      newNode.height = oldNode.height;
+      return super._replaceNode(oldNode, newNode);
+    }
   };
 
   // src/data-structures/binary-tree/rb-tree.ts
@@ -9901,9 +9871,15 @@ var dataStructureTyped = (() => {
   };
   var RedBlackTree = class _RedBlackTree extends BST {
     /**
-     * The constructor function initializes a Red-Black Tree with an optional set of options.
-     * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
-     * passed to the constructor. It is used to configure the RBTree object with specific options.
+     * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
+     * initializes the tree with optional elements and options.
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * objects. It represents the initial elements that will be added to the RBTree during its
+     * construction. If this parameter is provided, the `addMany` method is called to add all the
+     * elements to the
+     * @param [options] - The `options` parameter is an optional object that allows you to customize the
+     * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
+     * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
     constructor(elements, options) {
       super([], options);
@@ -9912,7 +9888,7 @@ var dataStructureTyped = (() => {
       __publicField(this, "_size", 0);
       this._root = this.Sentinel;
       if (elements)
-        this.init(elements);
+        super.addMany(elements);
     }
     get root() {
       return this._root;
@@ -9920,9 +9896,28 @@ var dataStructureTyped = (() => {
     get size() {
       return this._size;
     }
+    /**
+     * The function creates a new Red-Black Tree node with the specified key, value, and color.
+     * @param {BTNKey} key - The key parameter is the key value associated with the node. It is used to
+     * identify and compare nodes in the Red-Black Tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the node. It is of type `V`, which is a generic type that can be replaced with any
+     * specific type when using the `createNode` method.
+     * @param {RBTNColor} color - The "color" parameter is used to specify the color of the node in a
+     * Red-Black Tree. It can be either "RED" or "BLACK". By default, the color is set to "BLACK".
+     * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
+     * value, and color.
+     */
     createNode(key, value, color = 0 /* BLACK */) {
       return new RedBlackTreeNode(key, value, color);
     }
+    /**
+     * The function creates a Red-Black Tree with the specified options and returns it.
+     * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
+     * passed to the `createTree` function. It is used to customize the behavior of the `RedBlackTree`
+     * class.
+     * @returns a new instance of a RedBlackTree object.
+     */
     createTree(options) {
       return new _RedBlackTree([], __spreadValues({
         iterationType: this.iterationType,
@@ -9932,24 +9927,28 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
-     *
-     * The `add` function adds a new node to a Red-Black Tree data structure.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
-     * key in the node being added to the Red-Black Tree.
-     * @returns The method returns either a node (`N`) or `undefined`.
      */
-    add(keyOrNode, value) {
+    /**
+     * The function adds a node to a Red-Black Tree data structure.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
+     * @returns The method `add` returns either an instance of `N` (the node that was added) or
+     * `undefined`.
+     */
+    add(keyOrNodeOrEntry) {
       let node;
-      if (this.isNodeKey(keyOrNode)) {
-        node = this.createNode(keyOrNode, value, 1 /* RED */);
-      } else if (keyOrNode instanceof RedBlackTreeNode) {
-        node = keyOrNode;
-      } else if (keyOrNode === null) {
-        return;
-      } else if (keyOrNode === void 0) {
+      if (this.isNodeKey(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, void 0, 1 /* RED */);
+      } else if (keyOrNodeOrEntry instanceof RedBlackTreeNode) {
+        node = keyOrNodeOrEntry;
+      } else if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
         return;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value] = keyOrNodeOrEntry;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          node = this.createNode(key, value, 1 /* RED */);
+        }
       } else {
         return;
       }
@@ -9965,6 +9964,9 @@ var dataStructureTyped = (() => {
           } else if (node.key > x.key) {
             x = x == null ? void 0 : x.right;
           } else {
+            if (node !== x) {
+              this._replaceNode(x, node);
+            }
             return;
           }
         }
@@ -10068,6 +10070,10 @@ var dataStructureTyped = (() => {
     isRealNode(node) {
       return node !== this.Sentinel && node !== void 0;
     }
+    /**
+     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -10093,7 +10099,7 @@ var dataStructureTyped = (() => {
       var _a;
       if (identifier instanceof BinaryTreeNode)
         callback = (node) => node;
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
     }
     /**
@@ -10152,18 +10158,6 @@ var dataStructureTyped = (() => {
       this._root = this.Sentinel;
       this._size = 0;
     }
-    init(elements) {
-      if (elements) {
-        for (const entryOrKey of elements) {
-          if (Array.isArray(entryOrKey)) {
-            const [key, value] = entryOrKey;
-            this.add(key, value);
-          } else {
-            this.add(entryOrKey);
-          }
-        }
-      }
-    }
     _setRoot(v) {
       if (v) {
         v.parent = void 0;
@@ -10381,6 +10375,19 @@ var dataStructureTyped = (() => {
       }
       this.root.color = 0 /* BLACK */;
     }
+    /**
+     * The function replaces an old node with a new node while preserving the color of the old node.
+     * @param {N} oldNode - The `oldNode` parameter represents the node that needs to be replaced in a
+     * data structure. It is of type `N`, which is the type of the nodes in the data structure.
+     * @param {N} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
+     * data structure.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, passing in the `oldNode` and `newNode` as arguments.
+     */
+    _replaceNode(oldNode, newNode) {
+      newNode.color = oldNode.color;
+      return super._replaceNode(oldNode, newNode);
+    }
   };
 
   // src/data-structures/binary-tree/tree-multimap.ts
@@ -10402,20 +10409,17 @@ var dataStructureTyped = (() => {
     }
   };
   var TreeMultimap = class _TreeMultimap extends AVLTree {
-    /**
-     * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
-     * merge duplicated values.
-     * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
-     * TreeMultimap.
-     */
     constructor(elements, options) {
       super([], options);
       __publicField(this, "_count", 0);
       if (elements)
-        this.init(elements);
+        this.addMany(elements);
     }
+    // TODO the _count is not accurate after nodes count modified
     get count() {
-      return this._count;
+      let sum = 0;
+      this.subTreeTraverse((node) => sum += node.count);
+      return sum;
     }
     /**
      * The function creates a new BSTNode with the given key, value, and count.
@@ -10435,115 +10439,63 @@ var dataStructureTyped = (() => {
         comparator: this.comparator
       }, options));
     }
+    /**
+     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
+     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     */
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
      *
-     * The `add` function adds a new node to the tree multimap, updating the count if the key already
-     * exists, and balances the tree if necessary.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-     * being added to the tree. It is an optional parameter, so it can be omitted if not needed.
+     * The `add` function overrides the base class `add` function to add a new node to the tree multimap
+     * and update the count.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the multimap. If not provided, the default value is 1.
-     * @returns a node (`N`) or `undefined`.
+     * times the key or node or entry should be added to the multimap. If not provided, the default value
+     * is 1.
+     * @returns either a node (`N`) or `undefined`.
      */
-    add(keyOrNode, value, count = 1) {
-      if (keyOrNode === null)
-        return void 0;
-      let inserted = void 0, newNode;
-      if (keyOrNode instanceof TreeMultimapNode) {
-        newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
-      } else if (keyOrNode === void 0) {
-        newNode = void 0;
+    add(keyOrNodeOrEntry, count = 1) {
+      let newNode;
+      if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
+        return;
+      } else if (keyOrNodeOrEntry instanceof TreeMultimapNode) {
+        newNode = keyOrNodeOrEntry;
+      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
+        newNode = this.createNode(keyOrNodeOrEntry, void 0, count);
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value] = keyOrNodeOrEntry;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          newNode = this.createNode(key, value, count);
+        }
       } else {
-        newNode = this.createNode(keyOrNode, value, count);
+        return;
       }
-      if (!this.root) {
-        this._setRoot(newNode);
-        this._size = this.size + 1;
-        if (newNode)
-          this._count += newNode.count;
-        inserted = this.root;
-      } else {
-        let cur = this.root;
-        let traversing = true;
-        while (traversing) {
-          if (cur) {
-            if (newNode) {
-              if (this._compare(cur.key, newNode.key) === "eq" /* eq */) {
-                cur.value = newNode.value;
-                cur.count += newNode.count;
-                this._count += newNode.count;
-                traversing = false;
-                inserted = cur;
-              } else if (this._compare(cur.key, newNode.key) === "gt" /* gt */) {
-                if (cur.left === void 0) {
-                  cur.left = newNode;
-                  this._size = this.size + 1;
-                  this._count += newNode.count;
-                  traversing = false;
-                  inserted = cur.left;
-                } else {
-                  if (cur.left)
-                    cur = cur.left;
-                }
-              } else if (this._compare(cur.key, newNode.key) === "lt" /* lt */) {
-                if (cur.right === void 0) {
-                  cur.right = newNode;
-                  this._size = this.size + 1;
-                  this._count += newNode.count;
-                  traversing = false;
-                  inserted = cur.right;
-                } else {
-                  if (cur.right)
-                    cur = cur.right;
-                }
-              }
-            } else {
-            }
-          } else {
-            traversing = false;
-          }
-        }
+      const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
+      const inserted = super.add(newNode);
+      if (inserted) {
+        this._count += orgNodeCount;
       }
-      if (inserted)
-        this._balancePath(inserted);
       return inserted;
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
+     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
+     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
      *
-     * The function `addMany` takes an array of keys or nodes and adds them to the TreeMultimap,
-     * returning an array of the inserted nodes.
-     * @param {(BTNKey | N | undefined)[]} keysOrNodes - An array of keys or nodes. Each element can be
-     * of type BTNKey, N, or undefined.
-     * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond to the
-     * keys or nodes being added. It is used to associate data with each key or node being added to the
-     * TreeMultimap. If provided, the length of the `data` array should be the same as the length of the
-     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
+     * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
+     * structure.
+     * @param keysOrNodesOrEntries - The parameter `keysOrNodesOrEntries` is an iterable that can contain
+     * either keys, nodes, or entries.
+     * @returns The method is returning an array of type `N | undefined`.
      */
-    addMany(keysOrNodes, data) {
-      const inserted = [];
-      for (let i = 0; i < keysOrNodes.length; i++) {
-        const keyOrNode = keysOrNodes[i];
-        if (keyOrNode instanceof TreeMultimapNode) {
-          inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count));
-          continue;
-        }
-        if (keyOrNode === void 0) {
-          inserted.push(this.add(NaN, void 0, 0));
-          continue;
-        }
-        inserted.push(this.add(keyOrNode, data == null ? void 0 : data[i], 1));
-      }
-      return inserted;
+    addMany(keysOrNodesOrEntries) {
+      return super.addMany(keysOrNodesOrEntries);
     }
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
@@ -10571,7 +10523,7 @@ var dataStructureTyped = (() => {
             return;
           const m = l + Math.floor((r - l) / 2);
           const midNode = sorted[m];
-          this.add(midNode.key, midNode.value, midNode.count);
+          this.add([midNode.key, midNode.value], midNode.count);
           buildBalanceBST(l, m - 1);
           buildBalanceBST(m + 1, r);
         };
@@ -10586,7 +10538,7 @@ var dataStructureTyped = (() => {
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
               const midNode = sorted[m];
-              this.add(midNode.key, midNode.value, midNode.count);
+              this.add([midNode.key, midNode.value], midNode.count);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
             }
@@ -10649,7 +10601,7 @@ var dataStructureTyped = (() => {
           const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : void 0;
           if (leftSubTreeRightMost) {
             const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-            orgCurrent = this._swap(curr, leftSubTreeRightMost);
+            orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
             if (parentOfLeftSubTreeMax) {
               if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
                 parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
@@ -10681,22 +10633,6 @@ var dataStructureTyped = (() => {
       super.clear();
       this._count = 0;
     }
-    /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-     */
-    init(elements) {
-      if (elements) {
-        for (const entryOrKey of elements) {
-          if (Array.isArray(entryOrKey)) {
-            const [key, value] = entryOrKey;
-            this.add(key, value);
-          } else {
-            this.add(entryOrKey);
-          }
-        }
-      }
-    }
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
@@ -10713,7 +10649,7 @@ var dataStructureTyped = (() => {
      * added, or `undefined` if no node was added.
      */
     _addTo(newNode, parent) {
-      parent = this.ensureNotKey(parent);
+      parent = this.ensureNode(parent);
       if (parent) {
         if (parent.left === void 0) {
           parent.left = newNode;
@@ -10737,7 +10673,7 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * The `_swap` function swaps the key, value, count, and height properties between two nodes.
+     * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
      * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
      * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
      * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
@@ -10745,9 +10681,9 @@ var dataStructureTyped = (() => {
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    _swap(srcNode, destNode) {
-      srcNode = this.ensureNotKey(srcNode);
-      destNode = this.ensureNotKey(destNode);
+    _swapProperties(srcNode, destNode) {
+      srcNode = this.ensureNode(srcNode);
+      destNode = this.ensureNode(destNode);
       if (srcNode && destNode) {
         const { key, value, count, height } = destNode;
         const tempNode = this.createNode(key, value, count);
@@ -10766,6 +10702,10 @@ var dataStructureTyped = (() => {
       }
       return void 0;
     }
+    _replaceNode(oldNode, newNode) {
+      newNode.count = oldNode.count + newNode.count;
+      return super._replaceNode(oldNode, newNode);
+    }
   };
 
   // src/data-structures/tree/tree.ts
@@ -11416,16 +11356,21 @@ var dataStructureTyped = (() => {
   };
   var Trie = class _Trie {
     constructor(words, caseSensitive = true) {
+      __publicField(this, "_size");
       __publicField(this, "_caseSensitive");
       __publicField(this, "_root");
       this._root = new TrieNode("");
       this._caseSensitive = caseSensitive;
+      this._size = 0;
       if (words) {
-        for (const i of words) {
-          this.add(i);
+        for (const word of words) {
+          this.add(word);
         }
       }
     }
+    get size() {
+      return this._size;
+    }
     get caseSensitive() {
       return this._caseSensitive;
     }
@@ -11447,6 +11392,7 @@ var dataStructureTyped = (() => {
     add(word) {
       word = this._caseProcess(word);
       let cur = this.root;
+      let isNewWord = false;
       for (const c of word) {
         let nodeC = cur.children.get(c);
         if (!nodeC) {
@@ -11455,8 +11401,12 @@ var dataStructureTyped = (() => {
         }
         cur = nodeC;
       }
-      cur.isEnd = true;
-      return true;
+      if (!cur.isEnd) {
+        isNewWord = true;
+        cur.isEnd = true;
+        this._size++;
+      }
+      return isNewWord;
     }
     /**
      * Time Complexity: O(M), where M is the length of the input word.
@@ -11522,6 +11472,9 @@ var dataStructureTyped = (() => {
         return false;
       };
       dfs(this.root, 0);
+      if (isDeleted) {
+        this._size--;
+      }
       return isDeleted;
     }
     /**
@@ -11744,6 +11697,9 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    print() {
+      console.log([...this]);
+    }
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.