data-structure-typed 1.47.5 → 1.47.7

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)
@@ -886,13 +883,17 @@ var dataStructureTyped = (() => {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor() {
+    constructor(elements) {
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_length");
       this._head = null;
       this._tail = null;
       this._length = 0;
+      if (elements) {
+        for (const el of elements)
+          this.push(el);
+      }
     }
     get head() {
       return this._head;
@@ -1568,6 +1569,9 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    print() {
+      console.log([...this]);
+    }
   };
 
   // src/data-structures/linked-list/doubly-linked-list.ts
@@ -1590,13 +1594,18 @@ var dataStructureTyped = (() => {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor() {
+    constructor(elements) {
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_length");
       this._head = null;
       this._tail = null;
       this._length = 0;
+      if (elements) {
+        for (const el of elements) {
+          this.push(el);
+        }
+      }
     }
     get head() {
       return this._head;
@@ -2325,6 +2334,9 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    print() {
+      console.log([...this]);
+    }
   };
 
   // src/data-structures/linked-list/skip-linked-list.ts
@@ -2585,7 +2597,12 @@ var dataStructureTyped = (() => {
      */
     constructor(elements) {
       __publicField(this, "_elements");
-      this._elements = Array.isArray(elements) ? elements : [];
+      this._elements = [];
+      if (elements) {
+        for (const el of elements) {
+          this.push(el);
+        }
+      }
     }
     get elements() {
       return this._elements;
@@ -2708,7 +2725,7 @@ var dataStructureTyped = (() => {
      * @returns An iterator object.
      */
     *[Symbol.iterator]() {
-      for (let i = this.elements.length - 1; i >= 0; i--) {
+      for (let i = 0; i < this.elements.length; i++) {
         yield this.elements[i];
       }
     }
@@ -2752,6 +2769,9 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    print() {
+      console.log([...this]);
+    }
   };
 
   // src/data-structures/queue/queue.ts
@@ -3012,6 +3032,9 @@ var dataStructureTyped = (() => {
     clone() {
       return new _Queue(this.nodes.slice(this.offset));
     }
+    print() {
+      console.log([...this]);
+    }
     *[Symbol.iterator]() {
       for (const item of this.nodes) {
         yield item;
@@ -3845,6 +3868,9 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    print() {
+      console.log([...this]);
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4075,21 +4101,32 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/heap/heap.ts
   var Heap = class _Heap {
-    constructor(options) {
+    constructor(elements, options) {
+      __publicField(this, "options");
       __publicField(this, "_elements", []);
-      __publicField(this, "_comparator");
-      this._comparator = options.comparator;
-      if (options.elements && options.elements.length > 0) {
-        this._elements = options.elements;
-        this.fix();
+      const defaultComparator = (a, b) => {
+        if (!(typeof a === "number" && typeof b === "number")) {
+          throw new Error("The a, b params of compare function must be number");
+        } else {
+          return a - b;
+        }
+      };
+      if (options) {
+        this.options = options;
+      } else {
+        this.options = {
+          comparator: defaultComparator
+        };
+      }
+      if (elements) {
+        for (const el of elements) {
+          this.push(el);
+        }
       }
     }
     get elements() {
       return this._elements;
     }
-    get comparator() {
-      return this._comparator;
-    }
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -4107,10 +4144,11 @@ var dataStructureTyped = (() => {
     /**
      * Static method that creates a binary heap from an array of elements and a comparison function.
      * @returns A new Heap instance.
+     * @param elements
      * @param options
      */
-    static heapify(options) {
-      return new _Heap(options);
+    static heapify(elements, options) {
+      return new _Heap(elements, options);
     }
     /**
      * Time Complexity: O(log n), where n is the number of elements in the heap.
@@ -4319,7 +4357,7 @@ var dataStructureTyped = (() => {
      * @returns A new Heap instance containing the same elements.
      */
     clone() {
-      const clonedHeap = new _Heap({ comparator: this.comparator });
+      const clonedHeap = new _Heap([], this.options);
       clonedHeap._elements = [...this.elements];
       return clonedHeap;
     }
@@ -4371,7 +4409,7 @@ var dataStructureTyped = (() => {
       }
     }
     filter(predicate) {
-      const filteredHeap = new _Heap({ comparator: this.comparator });
+      const filteredHeap = new _Heap([], this.options);
       let index = 0;
       for (const el of this) {
         if (predicate(el, index, this)) {
@@ -4382,7 +4420,7 @@ var dataStructureTyped = (() => {
       return filteredHeap;
     }
     map(callback, comparator) {
-      const mappedHeap = new _Heap({ comparator });
+      const mappedHeap = new _Heap([], { comparator });
       let index = 0;
       for (const el of this) {
         mappedHeap.add(callback(el, index, this));
@@ -4403,6 +4441,13 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
+    print() {
+      console.log([...this]);
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -4415,17 +4460,13 @@ var dataStructureTyped = (() => {
       while (index > 0) {
         const parent = index - 1 >> 1;
         const parentItem = this.elements[parent];
-        if (this._comparator(parentItem, element) <= 0)
+        if (this.options.comparator(parentItem, element) <= 0)
           break;
         this.elements[index] = parentItem;
         index = parent;
       }
       this.elements[index] = element;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -4440,11 +4481,11 @@ var dataStructureTyped = (() => {
         let left = index << 1 | 1;
         const right = left + 1;
         let minItem = this.elements[left];
-        if (right < this.elements.length && this._comparator(minItem, this.elements[right]) > 0) {
+        if (right < this.elements.length && this.options.comparator(minItem, this.elements[right]) > 0) {
           left = right;
           minItem = this.elements[right];
         }
-        if (this._comparator(minItem, element) >= 0)
+        if (this.options.comparator(minItem, element) >= 0)
           break;
         this.elements[index] = minItem;
         index = left;
@@ -4473,7 +4514,7 @@ var dataStructureTyped = (() => {
       __publicField(this, "_min");
       __publicField(this, "_comparator");
       this.clear();
-      this._comparator = comparator || this.defaultComparator;
+      this._comparator = comparator || this._defaultComparator;
       if (typeof this.comparator !== "function") {
         throw new Error("FibonacciHeap constructor: given comparator should be a function.");
       }
@@ -4642,7 +4683,7 @@ var dataStructureTyped = (() => {
         this._root = void 0;
       } else {
         this._min = z.right;
-        this.consolidate();
+        this._consolidate();
       }
       this._size--;
       return z.element;
@@ -4678,27 +4719,27 @@ var dataStructureTyped = (() => {
       this._size += heapToMerge.size;
       heapToMerge.clear();
     }
+    /**
+     * Create a new node.
+     * @param element
+     * @protected
+     */
+    createNode(element) {
+      return new FibonacciHeapNode(element);
+    }
     /**
      * Default comparator function used by the heap.
      * @param {E} a
      * @param {E} b
      * @protected
      */
-    defaultComparator(a, b) {
+    _defaultComparator(a, b) {
       if (a < b)
         return -1;
       if (a > b)
         return 1;
       return 0;
     }
-    /**
-     * Create a new node.
-     * @param element
-     * @protected
-     */
-    createNode(element) {
-      return new FibonacciHeapNode(element);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -4753,7 +4794,7 @@ var dataStructureTyped = (() => {
      * @param x
      * @protected
      */
-    link(y, x) {
+    _link(y, x) {
       this.removeFromRoot(y);
       y.left = y;
       y.right = y;
@@ -4772,7 +4813,7 @@ var dataStructureTyped = (() => {
      * Remove and return the top element (smallest or largest element) from the heap.
      * @protected
      */
-    consolidate() {
+    _consolidate() {
       const A = new Array(this.size);
       const elements = this.consumeLinkedList(this.root);
       let x, y, d, t;
@@ -4786,7 +4827,7 @@ var dataStructureTyped = (() => {
             x = y;
             y = t;
           }
-          this.link(y, x);
+          this._link(y, x);
           A[d] = void 0;
           d++;
         }
@@ -4802,7 +4843,7 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/heap/max-heap.ts
   var MaxHeap = class extends Heap {
-    constructor(options = {
+    constructor(elements, options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -4811,13 +4852,13 @@ var dataStructureTyped = (() => {
         }
       }
     }) {
-      super(options);
+      super(elements, options);
     }
   };
 
   // src/data-structures/heap/min-heap.ts
   var MinHeap = class extends Heap {
-    constructor(options = {
+    constructor(elements, options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -4826,20 +4867,20 @@ var dataStructureTyped = (() => {
         }
       }
     }) {
-      super(options);
+      super(elements, options);
     }
   };
 
   // src/data-structures/priority-queue/priority-queue.ts
   var PriorityQueue = class extends Heap {
-    constructor(options) {
-      super(options);
+    constructor(elements, options) {
+      super(elements, options);
     }
   };
 
   // src/data-structures/priority-queue/min-priority-queue.ts
   var MinPriorityQueue = class extends PriorityQueue {
-    constructor(options = {
+    constructor(elements, options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -4848,13 +4889,13 @@ var dataStructureTyped = (() => {
         }
       }
     }) {
-      super(options);
+      super(elements, options);
     }
   };
 
   // src/data-structures/priority-queue/max-priority-queue.ts
   var MaxPriorityQueue = class extends PriorityQueue {
-    constructor(options = {
+    constructor(elements, options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -4863,7 +4904,7 @@ var dataStructureTyped = (() => {
         }
       }
     }) {
-      super(options);
+      super(elements, options);
     }
   };
 
@@ -5446,7 +5487,7 @@ var dataStructureTyped = (() => {
         if (vertexOrKey instanceof AbstractVertex)
           distMap.set(vertexOrKey, Infinity);
       }
-      const heap = new PriorityQueue({ comparator: (a, b) => a.key - b.key });
+      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);
@@ -6772,10 +6813,10 @@ var dataStructureTyped = (() => {
   };
 
   // src/types/data-structures/binary-tree/binary-tree.ts
-  var IterationType = /* @__PURE__ */ ((IterationType2) => {
-    IterationType2["ITERATIVE"] = "ITERATIVE";
-    IterationType2["RECURSIVE"] = "RECURSIVE";
-    return IterationType2;
+  var IterationType = /* @__PURE__ */ ((IterationType3) => {
+    IterationType3["ITERATIVE"] = "ITERATIVE";
+    IterationType3["RECURSIVE"] = "RECURSIVE";
+    return IterationType3;
   })(IterationType || {});
   var FamilyPosition = /* @__PURE__ */ ((FamilyPosition2) => {
     FamilyPosition2["ROOT"] = "ROOT";
@@ -6805,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;
@@ -6879,30 +6892,32 @@ 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(options) {
-      __publicField(this, "options");
+    constructor(elements, options) {
+      __publicField(this, "iterationType", "ITERATIVE" /* ITERATIVE */);
       __publicField(this, "_root");
       __publicField(this, "_size");
       __publicField(this, "_defaultOneParamCallback", (node) => node.key);
       if (options) {
-        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */ }, options);
-      } else {
-        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */ };
+        const { iterationType } = options;
+        if (iterationType) {
+          this.iterationType = iterationType;
+        }
       }
       this._size = 0;
+      if (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;
     }
@@ -6915,35 +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(__spreadValues({}, this.options), options));
+      return new _BinaryTree([], __spreadValues({ iterationType: this.iterationType }, options));
     }
     /**
-     * Time Complexity: O(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.
+     * 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(n)
-     * Space Complexity: O(1)
+     * 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)
@@ -6954,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;
       }
@@ -6978,34 +7012,27 @@ var dataStructureTyped = (() => {
       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.
+     * 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.
@@ -7015,22 +7042,14 @@ 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)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -7075,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;
@@ -7108,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) {
@@ -7122,8 +7141,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -7139,8 +7157,8 @@ var dataStructureTyped = (() => {
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return -1;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7184,9 +7202,9 @@ var dataStructureTyped = (() => {
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
-    getMinHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
+    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 */) {
@@ -7229,6 +7247,7 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
+     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
      */
     /**
      * Time Complexity: O(n)
@@ -7244,10 +7263,6 @@ var dataStructureTyped = (() => {
     isPerfectlyBalanced(beginRoot = this.root) {
       return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n).
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
@@ -7273,10 +7288,10 @@ var dataStructureTyped = (() => {
      * traverse the binary tree. It can have two possible values:
      * @returns an array of nodes of type `N`.
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.options.iterationType) {
+    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 = [];
@@ -7310,10 +7325,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n).
-     */
     /**
      * Time Complexity: O(n)
      *
@@ -7334,15 +7345,11 @@ var dataStructureTyped = (() => {
      * be performed in a pre-order, in-order, or post-order manner.
      * @returns a boolean value.
      */
-    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
       if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
       return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -7364,7 +7371,7 @@ var dataStructureTyped = (() => {
      * nodes are visited during the search.
      * @returns a value of type `N | null | undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
       var _a;
       if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
@@ -7417,7 +7424,11 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * The function `ensureNotKey` returns the node corresponding to the given key if it is a valid node
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * 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.
@@ -7427,13 +7438,9 @@ 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;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -7456,12 +7463,16 @@ var dataStructureTyped = (() => {
      * @returns The value of the node with the given identifier is being returned. If the node is not
      * found, `undefined` is returned.
      */
-    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
       var _a, _b;
       if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
       return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) == null ? void 0 : _a.value) != null ? _b : void 0;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * Clear the binary tree, removing all nodes.
      */
@@ -7476,10 +7487,6 @@ var dataStructureTyped = (() => {
     isEmpty() {
       return this.size === 0;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -7496,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) {
@@ -7508,7 +7515,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(log n)
@@ -7524,8 +7531,8 @@ var dataStructureTyped = (() => {
      * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
-    getLeftMost(beginRoot = this.root, iterationType = this.options.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+    getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return beginRoot;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7563,8 +7570,8 @@ var dataStructureTyped = (() => {
      * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
-    getRightMost(beginRoot = this.root, iterationType = this.options.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+    getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return beginRoot;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7584,7 +7591,7 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -7599,8 +7606,8 @@ var dataStructureTyped = (() => {
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot, iterationType = this.options.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+    isSubtreeBST(beginRoot, iterationType = this.iterationType) {
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return true;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7644,15 +7651,11 @@ var dataStructureTyped = (() => {
      * expected to be
      * @returns a boolean value.
      */
-    isBST(iterationType = this.options.iterationType) {
+    isBST(iterationType = this.iterationType) {
       if (this.root === null)
         return true;
       return this.isSubtreeBST(this.root, iterationType);
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(log n)
@@ -7675,8 +7678,8 @@ var dataStructureTyped = (() => {
      * the `callback` function on each node in the subtree. The type of the array elements is determined
      * by the return type of the `callback` function.
      */
-    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
-      beginRoot = this.ensureNotKey(beginRoot);
+    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+      beginRoot = this.ensureNode(beginRoot);
       const ans = [];
       if (!beginRoot)
         return ans;
@@ -7712,6 +7715,10 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(log n)
+     */
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
@@ -7746,10 +7753,6 @@ var dataStructureTyped = (() => {
     isNodeKey(potentialKey) {
       return typeof potentialKey === "number";
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -7774,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 = [];
@@ -7872,10 +7875,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -7897,8 +7896,8 @@ var dataStructureTyped = (() => {
      * @returns an array of values that are the result of invoking the callback function on each node in
      * the breadth-first traversal of a binary tree.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
-      beginRoot = this.ensureNotKey(beginRoot);
+    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
@@ -7946,10 +7945,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -7971,8 +7966,8 @@ var dataStructureTyped = (() => {
      * be excluded
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
-      beginRoot = this.ensureNotKey(beginRoot);
+    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+      beginRoot = this.ensureNode(beginRoot);
       const levelsNodes = [];
       if (!beginRoot)
         return levelsNodes;
@@ -8024,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) {
@@ -8046,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) {
@@ -8059,10 +8054,6 @@ var dataStructureTyped = (() => {
       }
       return y;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(1)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)
@@ -8082,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 = [];
@@ -8162,6 +8153,10 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
     /**
      * The `forEach` function iterates over each entry in a tree and calls a callback function with the
      * entry and the tree as arguments.
@@ -8185,19 +8180,11 @@ 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;
     }
-    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
-    //   const newTree = this.createTree();
-    //   for (const [key, value] of this) {
-    //     newTree.add(key, callback([key, value], this));
-    //   }
-    //   return newTree;
-    // }
     /**
      * The `map` function creates a new tree by applying a callback function to each entry in the current
      * tree.
@@ -8207,10 +8194,18 @@ 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;
     }
+    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
+    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
+    //   const newTree = this.createTree();
+    //   for (const [key, value] of this) {
+    //     newTree.add(key, callback([key, value], this));
+    //   }
+    //   return newTree;
+    // }
     /**
      * The `reduce` function iterates over the entries of a tree and applies a callback function to each
      * entry, accumulating a single value.
@@ -8242,7 +8237,7 @@ var dataStructureTyped = (() => {
     *[Symbol.iterator](node = this.root) {
       if (!node)
         return;
-      if (this.options.iterationType === "ITERATIVE" /* ITERATIVE */) {
+      if (this.iterationType === "ITERATIVE" /* ITERATIVE */) {
         const stack = [];
         let current = node;
         while (current || stack.length > 0) {
@@ -8275,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)
@@ -8331,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);
@@ -8347,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
@@ -8441,24 +8460,27 @@ 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(options) {
-      super(options);
-      __publicField(this, "options");
+    constructor(elements, options) {
+      super([], options);
       __publicField(this, "_root");
+      __publicField(this, "comparator", (a, b) => a - b);
       if (options) {
-        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
-      } else {
-        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
+        const { comparator } = options;
+        if (comparator) {
+          this.comparator = comparator;
+        }
       }
       this._root = void 0;
+      if (elements)
+        this.addMany(elements);
     }
-    /**
-     * Get the root node of the binary tree.
-     */
     get root() {
       return this._root;
     }
@@ -8473,8 +8495,18 @@ 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(__spreadValues({}, this.options), 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).
@@ -8484,141 +8516,124 @@ var dataStructureTyped = (() => {
      * 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(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.
      */
     /**
-     * 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.options.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;
@@ -8629,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]);
@@ -8638,15 +8653,15 @@ var dataStructureTyped = (() => {
         }
       };
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
-        _dfs(sortedKeysOrNodes, sortedData);
+        _dfs(sorted);
       } else {
         _iterate();
       }
       return inserted;
     }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
+     * 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(log n) - Average case for a balanced tree.
@@ -8663,7 +8678,7 @@ var dataStructureTyped = (() => {
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey(beginRoot = this.root, iterationType = this.options.iterationType) {
+    lastKey(beginRoot = this.root, iterationType = this.iterationType) {
       var _a, _b, _c, _d, _e, _f;
       if (this._compare(0, 1) === "lt" /* lt */)
         return (_b = (_a = this.getRightMost(beginRoot, iterationType)) == null ? void 0 : _a.key) != null ? _b : 0;
@@ -8674,7 +8689,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Space Complexity: O(1) - Constant space is used.
      */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
@@ -8721,7 +8736,11 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * The function `ensureNotKey` returns the node corresponding to the given key if it is a node key,
+     * Time Complexity: O(log n) - Average case for a balanced tree.
+     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     */
+    /**
+     * 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`.
@@ -8729,13 +8748,9 @@ 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;
     }
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
-     */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -8759,8 +8774,8 @@ var dataStructureTyped = (() => {
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`N[]`).
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.options.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
@@ -8835,8 +8850,8 @@ var dataStructureTyped = (() => {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `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.options.iterationType) {
-      targetNode = this.ensureNotKey(targetNode);
+    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = "lt" /* lt */, targetNode = this.root, iterationType = this.iterationType) {
+      targetNode = this.ensureNode(targetNode);
       const ans = [];
       if (!targetNode)
         return ans;
@@ -8875,17 +8890,8 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Balancing Adjustment:
-     * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
-     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
-     *
-     * Use Cases and Efficiency:
-     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
-     * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
-     */
-    /**
-     * Time Complexity: O(n) - Building a balanced tree from a sorted array.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
+     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
      */
     /**
      * Time Complexity: O(n) - Building a balanced tree from a sorted array.
@@ -8898,7 +8904,7 @@ var dataStructureTyped = (() => {
      * values:
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
-    perfectlyBalance(iterationType = this.options.iterationType) {
+    perfectlyBalance(iterationType = this.iterationType) {
       const sorted = this.dfs((node) => node, "in"), n = sorted.length;
       this.clear();
       if (sorted.length < 1)
@@ -8909,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);
         };
@@ -8925,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]);
             }
@@ -8935,8 +8941,17 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(n) - Visiting each node once.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Balancing Adjustment:
+     * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
+     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
+     *
+     * Use Cases and Efficiency:
+     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
+     * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
+     */
+    /**
+     * Time Complexity: O(n) - Building a balanced tree from a sorted array.
+     * Space Complexity: O(n) - Additional space is required for the sorted array.
      */
     /**
      * Time Complexity: O(n) - Visiting each node once.
@@ -8947,7 +8962,7 @@ var dataStructureTyped = (() => {
      * to check if the AVL tree is balanced. It can have two possible values:
      * @returns a boolean value.
      */
-    isAVLBalanced(iterationType = this.options.iterationType) {
+    isAVLBalanced(iterationType = this.iterationType) {
       var _a, _b;
       if (!this.root)
         return true;
@@ -9005,7 +9020,7 @@ var dataStructureTyped = (() => {
      * than), CP.lt (less than), or CP.eq (equal).
      */
     _compare(a, b) {
-      const compared = this.options.comparator(a, b);
+      const compared = this.comparator(a, b);
       if (compared > 0)
         return "gt" /* gt */;
       else if (compared < 0)
@@ -9451,19 +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(options) {
-      super(options);
-      __publicField(this, "options");
-      if (options) {
-        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
-      } else {
-        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
-      }
+    constructor(elements, options) {
+      super([], options);
+      if (elements)
+        super.addMany(elements);
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
@@ -9477,8 +9491,18 @@ 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(__spreadValues({}, this.options), 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.
@@ -9488,24 +9512,22 @@ var dataStructureTyped = (() => {
      * 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;
     }
     /**
-     * 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.
+     * 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.
      */
     /**
@@ -9535,7 +9557,7 @@ var dataStructureTyped = (() => {
       return deletedResults;
     }
     /**
-     * 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`.
@@ -9544,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);
@@ -9833,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
@@ -9845,22 +9871,24 @@ 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.
-     */
-    constructor(options) {
-      super(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);
       __publicField(this, "Sentinel", new RedBlackTreeNode(NaN));
-      __publicField(this, "options");
       __publicField(this, "_root");
       __publicField(this, "_size", 0);
-      if (options) {
-        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
-      } else {
-        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
-      }
       this._root = this.Sentinel;
+      if (elements)
+        super.addMany(elements);
     }
     get root() {
       return this._root;
@@ -9868,37 +9896,59 @@ 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(__spreadValues({}, this.options), options));
+      return new _RedBlackTree([], __spreadValues({
+        iterationType: this.iterationType,
+        comparator: this.comparator
+      }, options));
     }
     /**
      * 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)
-     *
-     * 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`.
+     * 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(keyOrNode, value) {
+    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;
       }
@@ -9914,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;
           }
         }
@@ -10010,6 +10063,10 @@ var dataStructureTyped = (() => {
       helper(this.root);
       return ans;
     }
+    /**
+     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Space Complexity: O(1)
+     */
     isRealNode(node) {
       return node !== this.Sentinel && node !== void 0;
     }
@@ -10038,11 +10095,11 @@ var dataStructureTyped = (() => {
      * `getNodes` method, which is called within the `getNode` method.
      * @returns a value of type `N`, `null`, or `undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
       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;
     }
     /**
@@ -10093,6 +10150,10 @@ var dataStructureTyped = (() => {
       }
       return y;
     }
+    /**
+     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Space Complexity: O(1)
+     */
     clear() {
       this._root = this.Sentinel;
       this._size = 0;
@@ -10314,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
@@ -10335,24 +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(options = { iterationType: "ITERATIVE" /* ITERATIVE */ }) {
-      super(options);
-      __publicField(this, "options");
+    constructor(elements, options) {
+      super([], options);
       __publicField(this, "_count", 0);
-      if (options) {
-        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
-      } else {
-        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
-      }
+      if (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.
@@ -10367,7 +10434,10 @@ var dataStructureTyped = (() => {
       return new TreeMultimapNode(key, value, count);
     }
     createTree(options) {
-      return new _TreeMultimap(__spreadValues(__spreadValues({}, this.options), options));
+      return new _TreeMultimap([], __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 (AVLTree) has logarithmic time complexity.
@@ -10377,115 +10447,59 @@ var dataStructureTyped = (() => {
      * 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(1) - constant time, as it performs basic pointer assignments.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * 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(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.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * 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.
      */
     /**
      * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
@@ -10498,7 +10512,7 @@ var dataStructureTyped = (() => {
      * values:
      * @returns a boolean value.
      */
-    perfectlyBalance(iterationType = this.options.iterationType) {
+    perfectlyBalance(iterationType = this.iterationType) {
       const sorted = this.dfs((node) => node, "in"), n = sorted.length;
       if (sorted.length < 1)
         return false;
@@ -10509,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);
         };
@@ -10524,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]);
             }
@@ -10534,8 +10548,8 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * 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.
+     * 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 delete method of the superclass (AVLTree) has logarithmic time complexity.
@@ -10587,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;
@@ -10609,8 +10623,8 @@ var dataStructureTyped = (() => {
       return deletedResult;
     }
     /**
-     * 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.
+     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
+     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
      */
     /**
      * The clear() function clears the contents of a data structure and sets the count to zero.
@@ -10635,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;
@@ -10659,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
@@ -10667,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);
@@ -10688,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
@@ -11338,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;
     }
@@ -11369,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) {
@@ -11377,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.
@@ -11444,6 +11472,9 @@ var dataStructureTyped = (() => {
         return false;
       };
       dfs(this.root, 0);
+      if (isDeleted) {
+        this._size--;
+      }
       return isDeleted;
     }
     /**
@@ -11666,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.