data-structure-typed 1.47.4 → 1.47.6

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

@@ -182,7 +182,7 @@ var dataStructureTyped = (() => {
       __publicField(this, "next");
       this.key = key;
       this.value = value;
-      this.next = null;
+      this.next = void 0;
     }
   };
   var _HashTable = class _HashTable {
@@ -194,7 +194,7 @@ var dataStructureTyped = (() => {
       this._hashFn = hashFn || this._defaultHashFn;
       this._capacity = Math.max(capacity, _HashTable.DEFAULT_CAPACITY);
       this._size = 0;
-      this._buckets = new Array(this._capacity).fill(null);
+      this._buckets = new Array(this._capacity).fill(void 0);
     }
     get capacity() {
       return this._capacity;
@@ -269,7 +269,7 @@ var dataStructureTyped = (() => {
     delete(key) {
       const index = this._hash(key);
       let currentNode = this._buckets[index];
-      let prevNode = null;
+      let prevNode = void 0;
       while (currentNode) {
         if (currentNode.key === key) {
           if (prevNode) {
@@ -278,13 +278,58 @@ var dataStructureTyped = (() => {
             this._buckets[index] = currentNode.next;
           }
           this._size--;
-          currentNode.next = null;
+          currentNode.next = void 0;
           return;
         }
         prevNode = currentNode;
         currentNode = currentNode.next;
       }
     }
+    *[Symbol.iterator]() {
+      for (const bucket of this._buckets) {
+        let currentNode = bucket;
+        while (currentNode) {
+          yield [currentNode.key, currentNode.value];
+          currentNode = currentNode.next;
+        }
+      }
+    }
+    forEach(callback) {
+      let index = 0;
+      for (const entry of this) {
+        callback(entry, index, this);
+        index++;
+      }
+    }
+    filter(predicate) {
+      const newTable = new _HashTable();
+      let index = 0;
+      for (const [key, value] of this) {
+        if (predicate([key, value], index, this)) {
+          newTable.set(key, value);
+        }
+        index++;
+      }
+      return newTable;
+    }
+    map(callback) {
+      const newTable = new _HashTable();
+      let index = 0;
+      for (const [key, value] of this) {
+        newTable.set(key, callback([key, value], index, this));
+        index++;
+      }
+      return newTable;
+    }
+    reduce(callback, initialValue) {
+      let accumulator = initialValue;
+      let index = 0;
+      for (const entry of this) {
+        accumulator = callback(accumulator, entry, index, this);
+        index++;
+      }
+      return accumulator;
+    }
     /**
      * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
      * capacity of the data structure.
@@ -370,7 +415,7 @@ var dataStructureTyped = (() => {
      */
     _expand() {
       const newCapacity = this._capacity * 2;
-      const newBuckets = new Array(newCapacity).fill(null);
+      const newBuckets = new Array(newCapacity).fill(void 0);
       for (const bucket of this._buckets) {
         let currentNode = bucket;
         while (currentNode) {
@@ -739,10 +784,12 @@ var dataStructureTyped = (() => {
      */
     filter(predicate) {
       const filteredMap = new _HashMap();
+      let index = 0;
       for (const [key, value] of this) {
-        if (predicate([key, value], this)) {
+        if (predicate([key, value], index, this)) {
           filteredMap.set(key, value);
         }
+        index++;
       }
       return filteredMap;
     }
@@ -755,9 +802,11 @@ var dataStructureTyped = (() => {
      */
     map(callback) {
       const mappedMap = new _HashMap();
+      let index = 0;
       for (const [key, value] of this) {
-        const newValue = callback([key, value], this);
+        const newValue = callback([key, value], index, this);
         mappedMap.set(key, newValue);
+        index++;
       }
       return mappedMap;
     }
@@ -775,8 +824,10 @@ var dataStructureTyped = (() => {
      */
     reduce(callback, initialValue) {
       let accumulator = initialValue;
-      for (const element of this) {
-        accumulator = callback(accumulator, element, this);
+      let index = 0;
+      for (const entry of this) {
+        accumulator = callback(accumulator, entry, index, this);
+        index++;
       }
       return accumulator;
     }
@@ -835,13 +886,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;
@@ -1413,58 +1468,42 @@ var dataStructureTyped = (() => {
       return count;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
-     */
-    /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
-     *
-     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
-     * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
-     * represents the value of the current node in the linked list, and the index argument represents the index of the
-     * current node in the linked list.
+     * The function returns an iterator that iterates over the values of a linked list.
      */
-    forEach(callback) {
+    *[Symbol.iterator]() {
       let current = this.head;
-      let index = 0;
       while (current) {
-        callback(current.value, index);
+        yield current.value;
         current = current.next;
-        index++;
       }
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
      *
-     * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
-     * SinglyLinkedList with the transformed values.
-     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
-     * the original SinglyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
-     * SinglyLinkedList).
-     * @returns The `map` function is returning a new instance of `SinglyLinkedList<U>` that contains the mapped values.
+     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+     * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
+     * represents the value of the current node in the linked list, and the index argument represents the index of the
+     * current node in the linked list.
      */
-    map(callback) {
-      const mappedList = new _SinglyLinkedList();
-      let current = this.head;
-      while (current) {
-        mappedList.push(callback(current.value));
-        current = current.next;
+    forEach(callback) {
+      let index = 0;
+      for (const el of this) {
+        callback(el, index, this);
+        index++;
       }
-      return mappedList;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
      *
      * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
      * elements that satisfy the given callback function.
@@ -1474,50 +1513,67 @@ var dataStructureTyped = (() => {
      */
     filter(callback) {
       const filteredList = new _SinglyLinkedList();
-      let current = this.head;
-      while (current) {
-        if (callback(current.value)) {
-          filteredList.push(current.value);
+      let index = 0;
+      for (const current of this) {
+        if (callback(current, index, this)) {
+          filteredList.push(current);
         }
-        current = current.next;
+        index++;
       }
       return filteredList;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
+     *
+     * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
+     * SinglyLinkedList with the transformed values.
+     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+     * the original SinglyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
+     * SinglyLinkedList).
+     * @returns The `map` function is returning a new instance of `SinglyLinkedList<T>` that contains the mapped values.
+     */
+    map(callback) {
+      const mappedList = new _SinglyLinkedList();
+      let index = 0;
+      for (const current of this) {
+        mappedList.push(callback(current, index, this));
+        index++;
+      }
+      return mappedList;
+    }
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
      *
      * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
      * single value.
      * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
      * used to perform a specific operation on each element of the linked list.
-     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
      * point for the reduction operation.
      * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
      * elements in the linked list.
      */
     reduce(callback, initialValue) {
       let accumulator = initialValue;
-      let current = this.head;
-      while (current) {
-        accumulator = callback(accumulator, current.value);
-        current = current.next;
+      let index = 0;
+      for (const current of this) {
+        accumulator = callback(accumulator, current, index, this);
+        index++;
       }
       return accumulator;
     }
-    /**
-     * The function returns an iterator that iterates over the values of a linked list.
-     */
-    *[Symbol.iterator]() {
-      let current = this.head;
-      while (current) {
-        yield current.value;
-        current = current.next;
-      }
+    print() {
+      console.log([...this]);
     }
   };
 
@@ -1541,13 +1597,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;
@@ -1917,6 +1978,45 @@ var dataStructureTyped = (() => {
       }
       return false;
     }
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+     * after which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * itself.
+     * @param {E} newValue - The value that you want to insert into the doubly linked list.
+     * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
+     * existing value or node is not found in the doubly linked list.
+     */
+    insertAfter(existingValueOrNode, newValue) {
+      let existingNode;
+      if (existingValueOrNode instanceof DoublyLinkedListNode) {
+        existingNode = existingValueOrNode;
+      } else {
+        existingNode = this.getNode(existingValueOrNode);
+      }
+      if (existingNode) {
+        const newNode = new DoublyLinkedListNode(newValue);
+        newNode.next = existingNode.next;
+        if (existingNode.next) {
+          existingNode.next.prev = newNode;
+        }
+        newNode.prev = existingNode;
+        existingNode.next = newNode;
+        if (existingNode === this.tail) {
+          this._tail = newNode;
+        }
+        this._length++;
+        return true;
+      }
+      return false;
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -1983,26 +2083,6 @@ var dataStructureTyped = (() => {
       }
       return false;
     }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     *
-     * The `toArray` function converts a linked list into an array.
-     * @returns The `toArray()` method is returning an array of type `E[]`.
-     */
-    toArray() {
-      const array = [];
-      let current = this.head;
-      while (current) {
-        array.push(current.value);
-        current = current.next;
-      }
-      return array;
-    }
     /**
      * The function checks if a variable has a length greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
@@ -2093,6 +2173,25 @@ var dataStructureTyped = (() => {
       }
       return null;
     }
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * The `reverse` function reverses the order of the elements in a doubly linked list.
+     */
+    reverse() {
+      let current = this.head;
+      [this._head, this._tail] = [this.tail, this.head];
+      while (current) {
+        const next = current.next;
+        [current.prev, current.next] = [current.next, current.prev];
+        current = next;
+      }
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
@@ -2101,35 +2200,46 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toArrayBackward()` function returns an array of type `E[]`.
+     * The `toArray` function converts a linked list into an array.
+     * @returns The `toArray()` method is returning an array of type `E[]`.
      */
-    toArrayBackward() {
+    toArray() {
       const array = [];
-      let current = this.tail;
+      let current = this.head;
       while (current) {
         array.push(current.value);
-        current = current.prev;
+        current = current.next;
       }
       return array;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      *
-     * The `reverse` function reverses the order of the elements in a doubly linked list.
+     * The `toReversedArray` function converts a doubly linked list into an array in reverse order.
+     * @returns The `toReversedArray()` function returns an array of type `E[]`.
      */
-    reverse() {
+    toReversedArray() {
+      const array = [];
+      let current = this.tail;
+      while (current) {
+        array.push(current.value);
+        current = current.prev;
+      }
+      return array;
+    }
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
+    *[Symbol.iterator]() {
       let current = this.head;
-      [this._head, this._tail] = [this.tail, this.head];
       while (current) {
-        const next = current.next;
-        [current.prev, current.next] = [current.next, current.prev];
-        current = next;
+        yield current.value;
+        current = current.next;
       }
     }
     /**
@@ -2146,11 +2256,9 @@ var dataStructureTyped = (() => {
      * current node in the linked list.
      */
     forEach(callback) {
-      let current = this.head;
       let index = 0;
-      while (current) {
-        callback(current.value, index);
-        current = current.next;
+      for (const el of this) {
+        callback(el, index, this);
         index++;
       }
     }
@@ -2162,21 +2270,22 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
-     * DoublyLinkedList with the transformed values.
-     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
-     * the original DoublyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
-     * DoublyLinkedList).
-     * @returns The `map` function is returning a new instance of `DoublyLinkedList<U>` that contains the mapped values.
+     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList containing only the
+     * elements that satisfy the given callback function.
+     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
+     * It is used to determine whether a value should be included in the filtered list or not.
+     * @returns The filtered list, which is an instance of the DoublyLinkedList class.
      */
-    map(callback) {
-      const mappedList = new _DoublyLinkedList();
-      let current = this.head;
-      while (current) {
-        mappedList.push(callback(current.value));
-        current = current.next;
+    filter(callback) {
+      const filteredList = new _DoublyLinkedList();
+      let index = 0;
+      for (const current of this) {
+        if (callback(current, index, this)) {
+          filteredList.push(current);
+        }
+        index++;
       }
-      return mappedList;
+      return filteredList;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -2186,22 +2295,21 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList containing only the
-     * elements that satisfy the given callback function.
-     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
-     * It is used to determine whether a value should be included in the filtered list or not.
-     * @returns The filtered list, which is an instance of the DoublyLinkedList class.
+     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
+     * DoublyLinkedList with the transformed values.
+     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+     * the original DoublyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
+     * DoublyLinkedList).
+     * @returns The `map` function is returning a new instance of `DoublyLinkedList<T>` that contains the mapped values.
      */
-    filter(callback) {
-      const filteredList = new _DoublyLinkedList();
-      let current = this.head;
-      while (current) {
-        if (callback(current.value)) {
-          filteredList.push(current.value);
-        }
-        current = current.next;
+    map(callback) {
+      const mappedList = new _DoublyLinkedList();
+      let index = 0;
+      for (const current of this) {
+        mappedList.push(callback(current, index, this));
+        index++;
       }
-      return filteredList;
+      return mappedList;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -2215,68 +2323,22 @@ var dataStructureTyped = (() => {
      * single value.
      * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
      * used to perform a specific operation on each element of the linked list.
-     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
      * point for the reduction operation.
      * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
      * elements in the linked list.
      */
     reduce(callback, initialValue) {
       let accumulator = initialValue;
-      let current = this.head;
-      while (current) {
-        accumulator = callback(accumulator, current.value);
-        current = current.next;
+      let index = 0;
+      for (const current of this) {
+        accumulator = callback(accumulator, current, index, this);
+        index++;
       }
       return accumulator;
     }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
-     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
-     * after which the new value will be inserted. It can be either the value of the existing node or the existing node
-     * itself.
-     * @param {E} newValue - The value that you want to insert into the doubly linked list.
-     * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
-     * existing value or node is not found in the doubly linked list.
-     */
-    insertAfter(existingValueOrNode, newValue) {
-      let existingNode;
-      if (existingValueOrNode instanceof DoublyLinkedListNode) {
-        existingNode = existingValueOrNode;
-      } else {
-        existingNode = this.getNode(existingValueOrNode);
-      }
-      if (existingNode) {
-        const newNode = new DoublyLinkedListNode(newValue);
-        newNode.next = existingNode.next;
-        if (existingNode.next) {
-          existingNode.next.prev = newNode;
-        }
-        newNode.prev = existingNode;
-        existingNode.next = newNode;
-        if (existingNode === this.tail) {
-          this._tail = newNode;
-        }
-        this._length++;
-        return true;
-      }
-      return false;
-    }
-    /**
-     * The function returns an iterator that iterates over the values of a linked list.
-     */
-    *[Symbol.iterator]() {
-      let current = this.head;
-      while (current) {
-        yield current.value;
-        current = current.next;
-      }
+    print() {
+      console.log([...this]);
     }
   };
 
@@ -2538,7 +2600,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;
@@ -2547,6 +2614,13 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
      * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
      */
+    /**
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
+     */
+    get size() {
+      return this.elements.length;
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
      * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
@@ -2566,13 +2640,6 @@ var dataStructureTyped = (() => {
     isEmpty() {
       return this.elements.length === 0;
     }
-    /**
-     * The size() function returns the number of elements in an array.
-     * @returns The size of the elements array.
-     */
-    size() {
-      return this.elements.length;
-    }
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
@@ -2656,6 +2723,58 @@ var dataStructureTyped = (() => {
     clone() {
       return new _Stack(this.elements.slice());
     }
+    /**
+     * Custom iterator for the Stack class.
+     * @returns An iterator object.
+     */
+    *[Symbol.iterator]() {
+      for (let i = 0; i < this.elements.length; i++) {
+        yield this.elements[i];
+      }
+    }
+    /**
+     * Applies a function to each element of the stack.
+     * @param {function(E): void} callback - A function to apply to each element.
+     */
+    forEach(callback) {
+      let index = 0;
+      for (const el of this) {
+        callback(el, index, this);
+        index++;
+      }
+    }
+    filter(predicate) {
+      const newStack = new _Stack();
+      let index = 0;
+      for (const el of this) {
+        if (predicate(el, index, this)) {
+          newStack.push(el);
+        }
+        index++;
+      }
+      return newStack;
+    }
+    map(callback) {
+      const newStack = new _Stack();
+      let index = 0;
+      for (const el of this) {
+        newStack.push(callback(el, index, this));
+        index++;
+      }
+      return newStack;
+    }
+    reduce(callback, initialValue) {
+      let accumulator = initialValue;
+      let index = 0;
+      for (const el of this) {
+        accumulator = callback(accumulator, el, index, this);
+        index++;
+      }
+      return accumulator;
+    }
+    print() {
+      console.log([...this]);
+    }
   };
 
   // src/data-structures/queue/queue.ts
@@ -2907,19 +3026,99 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
      */
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
-     * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+     * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
+     * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+     *
+     * The `clone()` function returns a new Queue object with the same elements as the original Queue.
+     * @returns The `clone()` method is returning a new instance of the `Queue` class.
+     */
+    clone() {
+      return new _Queue(this.nodes.slice(this.offset));
+    }
+    print() {
+      console.log([...this]);
+    }
+    *[Symbol.iterator]() {
+      for (const item of this.nodes) {
+        yield item;
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `forEach` function iterates over each element in a deque and applies a callback function to
+     * each element.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * deque. It takes three parameters:
+     */
+    forEach(callback) {
+      let index = 0;
+      for (const el of this) {
+        callback(el, index, this);
+        index++;
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new deque containing only the elements that satisfy the given
+     * predicate function.
+     * @param predicate - The `predicate` parameter is a function that takes three arguments: `element`,
+     * `index`, and `deque`.
+     * @returns The `filter` method is returning a new `Queue` object that contains only the elements
+     * that satisfy the given `predicate` function.
+     */
+    filter(predicate) {
+      const newDeque = new _Queue([]);
+      let index = 0;
+      for (const el of this) {
+        if (predicate(el, index, this)) {
+          newDeque.push(el);
+        }
+        index++;
+      }
+      return newDeque;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
-     * The `clone()` function returns a new Queue object with the same elements as the original Queue.
-     * @returns The `clone()` method is returning a new instance of the `Queue` class.
+     * The `map` function takes a callback function and applies it to each element in the deque,
+     * returning a new deque with the results.
+     * @param callback - The `callback` parameter is a function that takes three arguments:
+     * @returns The `map` method is returning a new `Queue` object with the transformed elements.
      */
-    clone() {
-      return new _Queue(this.nodes.slice(this.offset));
+    map(callback) {
+      const newDeque = new _Queue([]);
+      let index = 0;
+      for (const el of this) {
+        newDeque.push(callback(el, index, this));
+        index++;
+      }
+      return newDeque;
     }
-    *[Symbol.iterator]() {
-      for (const item of this.nodes) {
-        yield item;
+    reduce(callback, initialValue) {
+      let accumulator = initialValue;
+      let index = 0;
+      for (const el of this) {
+        accumulator = callback(accumulator, el, index, this);
+        index++;
       }
+      return accumulator;
     }
   };
 
@@ -3505,15 +3704,21 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `forEach` function iterates over each element in a deque and applies a callback function to
-     * each element.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * deque. It takes three parameters:
+     * The `find` function iterates over the elements in a deque and returns the first element for which
+     * the callback function returns true, or undefined if no such element is found.
+     * @param callback - A function that takes three parameters: element, index, and deque. It should
+     * return a boolean value indicating whether the element satisfies a certain condition.
+     * @returns The method `find` returns the first element in the deque that satisfies the condition
+     * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
      */
-    forEach(callback) {
+    find(callback) {
       for (let i = 0; i < this.size; ++i) {
-        callback(this.getAt(i), i, this);
+        const element = this.getAt(i);
+        if (callback(element, i, this)) {
+          return element;
+        }
       }
+      return void 0;
     }
     /**
      * Time Complexity: O(n)
@@ -3523,21 +3728,20 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `find` function iterates over the elements in a deque and returns the first element for which
-     * the callback function returns true, or undefined if no such element is found.
-     * @param callback - A function that takes three parameters: element, index, and deque. It should
-     * return a boolean value indicating whether the element satisfies a certain condition.
-     * @returns The method `find` returns the first element in the deque that satisfies the condition
-     * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
+     * The function "indexOf" returns the index of the first occurrence of a given element in an array,
+     * or -1 if the element is not found.
+     * @param {E} element - The "element" parameter represents the element that you want to find the
+     * index of in the data structure.
+     * @returns The indexOf function returns the index of the first occurrence of the specified element
+     * in the data structure. If the element is not found, it returns -1.
      */
-    find(callback) {
+    indexOf(element) {
       for (let i = 0; i < this.size; ++i) {
-        const element = this.getAt(i);
-        if (callback(element, i, this)) {
-          return element;
+        if (this.getAt(i) === element) {
+          return i;
         }
       }
-      return void 0;
+      return -1;
     }
     /**
      * Time Complexity: O(n)
@@ -3559,23 +3763,39 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      *
-     * The `map` function takes a callback function and applies it to each element in the deque,
-     * returning a new deque with the results.
-     * @param callback - The `callback` parameter is a function that takes three arguments:
-     * @returns The `map` method is returning a new `Deque` object with the transformed elements.
+     * The above function is an implementation of the iterator protocol in TypeScript, allowing the
+     * object to be iterated over using a for...of loop.
      */
-    map(callback) {
-      const newDeque = new _Deque([], this._bucketSize);
+    *[Symbol.iterator]() {
       for (let i = 0; i < this.size; ++i) {
-        newDeque.push(callback(this.getAt(i), i, this));
+        yield this.getAt(i);
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `forEach` function iterates over each element in a deque and applies a callback function to
+     * each element.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * deque. It takes three parameters:
+     */
+    forEach(callback) {
+      let index = 0;
+      for (const el of this) {
+        callback(el, index, this);
+        index++;
       }
-      return newDeque;
     }
     /**
      * Time Complexity: O(n)
@@ -3594,11 +3814,34 @@ var dataStructureTyped = (() => {
      */
     filter(predicate) {
       const newDeque = new _Deque([], this._bucketSize);
-      for (let i = 0; i < this.size; ++i) {
-        const element = this.getAt(i);
-        if (predicate(element, i, this)) {
-          newDeque.push(element);
+      let index = 0;
+      for (const el of this) {
+        if (predicate(el, index, this)) {
+          newDeque.push(el);
         }
+        index++;
+      }
+      return newDeque;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function takes a callback function and applies it to each element in the deque,
+     * returning a new deque with the results.
+     * @param callback - The `callback` parameter is a function that takes three arguments:
+     * @returns The `map` method is returning a new `Deque` object with the transformed elements.
+     */
+    map(callback) {
+      const newDeque = new _Deque([], this._bucketSize);
+      let index = 0;
+      for (const el of this) {
+        newDeque.push(callback(el, index, this));
+        index++;
       }
       return newDeque;
     }
@@ -3621,49 +3864,15 @@ var dataStructureTyped = (() => {
      */
     reduce(callback, initialValue) {
       let accumulator = initialValue;
-      for (let i = 0; i < this.size; ++i) {
-        accumulator = callback(accumulator, this.getAt(i), i, this);
+      let index = 0;
+      for (const el of this) {
+        accumulator = callback(accumulator, el, index, this);
+        index++;
       }
       return accumulator;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function "indexOf" returns the index of the first occurrence of a given element in an array,
-     * or -1 if the element is not found.
-     * @param {E} element - The "element" parameter represents the element that you want to find the
-     * index of in the data structure.
-     * @returns The indexOf function returns the index of the first occurrence of the specified element
-     * in the data structure. If the element is not found, it returns -1.
-     */
-    indexOf(element) {
-      for (let i = 0; i < this.size; ++i) {
-        if (this.getAt(i) === element) {
-          return i;
-        }
-      }
-      return -1;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The above function is an implementation of the iterator protocol in TypeScript, allowing the
-     * object to be iterated over using a for...of loop.
-     */
-    *[Symbol.iterator]() {
-      for (let i = 0; i < this.size; ++i) {
-        yield this.getAt(i);
-      }
+    print() {
+      console.log([...this]);
     }
     /**
      * Time Complexity: O(n)
@@ -3895,21 +4104,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.
      */
@@ -3927,10 +4147,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.
@@ -4090,26 +4311,27 @@ var dataStructureTyped = (() => {
      * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
      * @returns An array containing elements traversed in the specified order.
      */
-    dfs(order) {
+    dfs(order = "pre") {
       const result = [];
-      const dfsHelper = (index) => {
+      const _dfs = (index) => {
+        const left = 2 * index + 1, right = left + 1;
         if (index < this.size) {
           if (order === "in") {
-            dfsHelper(2 * index + 1);
+            _dfs(left);
             result.push(this.elements[index]);
-            dfsHelper(2 * index + 2);
+            _dfs(right);
           } else if (order === "pre") {
             result.push(this.elements[index]);
-            dfsHelper(2 * index + 1);
-            dfsHelper(2 * index + 2);
+            _dfs(left);
+            _dfs(right);
           } else if (order === "post") {
-            dfsHelper(2 * index + 1);
-            dfsHelper(2 * index + 2);
+            _dfs(left);
+            _dfs(right);
             result.push(this.elements[index]);
           }
         }
       };
-      dfsHelper(0);
+      _dfs(0);
       return result;
     }
     /**
@@ -4138,7 +4360,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;
     }
@@ -4177,10 +4399,58 @@ var dataStructureTyped = (() => {
       for (let i = Math.floor(this.size / 2); i >= 0; i--)
         this._sinkDown(i, this.elements.length >> 1);
     }
+    *[Symbol.iterator]() {
+      for (const element of this.elements) {
+        yield element;
+      }
+    }
+    forEach(callback) {
+      let index = 0;
+      for (const el of this) {
+        callback(el, index, this);
+        index++;
+      }
+    }
+    filter(predicate) {
+      const filteredHeap = new _Heap([], this.options);
+      let index = 0;
+      for (const el of this) {
+        if (predicate(el, index, this)) {
+          filteredHeap.push(el);
+        }
+        index++;
+      }
+      return filteredHeap;
+    }
+    map(callback, comparator) {
+      const mappedHeap = new _Heap([], { comparator });
+      let index = 0;
+      for (const el of this) {
+        mappedHeap.add(callback(el, index, this));
+        index++;
+      }
+      return mappedHeap;
+    }
+    reduce(callback, initialValue) {
+      let accumulator = initialValue;
+      let index = 0;
+      for (const el of this) {
+        accumulator = callback(accumulator, el, index, this);
+        index++;
+      }
+      return accumulator;
+    }
     /**
      * 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)
@@ -4193,17 +4463,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)
@@ -4218,11 +4484,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;
@@ -4251,7 +4517,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.");
       }
@@ -4420,7 +4686,7 @@ var dataStructureTyped = (() => {
         this._root = void 0;
       } else {
         this._min = z.right;
-        this.consolidate();
+        this._consolidate();
       }
       this._size--;
       return z.element;
@@ -4456,27 +4722,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)
@@ -4531,7 +4797,7 @@ var dataStructureTyped = (() => {
      * @param x
      * @protected
      */
-    link(y, x) {
+    _link(y, x) {
       this.removeFromRoot(y);
       y.left = y;
       y.right = y;
@@ -4550,7 +4816,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;
@@ -4564,7 +4830,7 @@ var dataStructureTyped = (() => {
             x = y;
             y = t;
           }
-          this.link(y, x);
+          this._link(y, x);
           A[d] = void 0;
           d++;
         }
@@ -4580,7 +4846,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");
@@ -4589,13 +4855,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");
@@ -4604,20 +4870,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");
@@ -4626,13 +4892,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");
@@ -4641,7 +4907,7 @@ var dataStructureTyped = (() => {
         }
       }
     }) {
-      super(options);
+      super(elements, options);
     }
   };
 
@@ -5224,7 +5490,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);
@@ -6550,10 +6816,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";
@@ -6660,17 +6926,20 @@ var dataStructureTyped = (() => {
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
-    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.init(elements);
     }
     /**
      * Get the root node of the binary tree.
@@ -6694,13 +6963,8 @@ var dataStructureTyped = (() => {
       return new BinaryTreeNode(key, value);
     }
     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.
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -6756,8 +7020,9 @@ 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(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.
@@ -6805,10 +7070,6 @@ var dataStructureTyped = (() => {
       this.clear();
       return keysOrNodes.length === this.addMany(keysOrNodes, values).length;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -6899,9 +7160,8 @@ var dataStructureTyped = (() => {
       return depth;
     }
     /**
-     * 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)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -6917,7 +7177,7 @@ var dataStructureTyped = (() => {
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return -1;
@@ -6962,7 +7222,7 @@ 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);
       if (!beginRoot)
@@ -7007,6 +7267,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)
@@ -7022,10 +7283,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).
@@ -7051,7 +7308,7 @@ 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);
@@ -7088,10 +7345,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n).
-     */
     /**
      * Time Complexity: O(n)
      *
@@ -7112,15 +7365,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)
@@ -7142,7 +7391,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;
@@ -7194,6 +7443,10 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * The function `ensureNotKey` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
@@ -7208,10 +7461,6 @@ var dataStructureTyped = (() => {
     ensureNotKey(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)
@@ -7234,12 +7483,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.
      */
@@ -7254,10 +7507,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)
@@ -7286,7 +7535,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(log n)
@@ -7302,7 +7551,7 @@ 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) {
+    getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return beginRoot;
@@ -7341,7 +7590,7 @@ 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) {
+    getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return beginRoot;
@@ -7362,7 +7611,7 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -7377,7 +7626,7 @@ var dataStructureTyped = (() => {
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot, iterationType = this.options.iterationType) {
+    isSubtreeBST(beginRoot, iterationType = this.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return true;
@@ -7422,15 +7671,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)
@@ -7453,7 +7698,7 @@ 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) {
+    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
       beginRoot = this.ensureNotKey(beginRoot);
       const ans = [];
       if (!beginRoot)
@@ -7490,6 +7735,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.
@@ -7524,10 +7773,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)
@@ -7650,10 +7895,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -7675,7 +7916,7 @@ 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) {
+    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return [];
@@ -7724,10 +7965,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -7749,7 +7986,7 @@ 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) {
+    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
       beginRoot = this.ensureNotKey(beginRoot);
       const levelsNodes = [];
       if (!beginRoot)
@@ -7837,10 +8074,6 @@ var dataStructureTyped = (() => {
       }
       return y;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(1)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)
@@ -7940,6 +8173,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.
@@ -7968,14 +8205,6 @@ var dataStructureTyped = (() => {
       }
       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.
@@ -7989,6 +8218,14 @@ var dataStructureTyped = (() => {
       }
       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.
@@ -8020,7 +8257,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) {
@@ -8073,6 +8310,18 @@ var dataStructureTyped = (() => {
       };
       display(beginRoot);
     }
+    init(elements) {
+      if (elements) {
+        for (const entryOrKey of elements) {
+          if (Array.isArray(entryOrKey)) {
+            const [key, value] = entryOrKey;
+            this.add(key, value);
+          } else {
+            this.add(entryOrKey);
+          }
+        }
+      }
+    }
     _displayAux(node, options) {
       const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
       const emptyDisplayLayout = [["\u2500"], 1, 0, 0];
@@ -8223,16 +8472,19 @@ var dataStructureTyped = (() => {
      * @param {BSTOptions} [options] - An optional object that contains additional configuration options
      * for the binary search tree.
      */
-    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.init(elements);
     }
     /**
      * Get the root node of the binary tree.
@@ -8252,12 +8504,11 @@ var dataStructureTyped = (() => {
       return new BSTNode(key, value);
     }
     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).
-     * Space Complexity: O(1) - Constant space is used.
-     */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -8332,8 +8583,8 @@ var dataStructureTyped = (() => {
       return inserted;
     }
     /**
-     * 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. In the worst case (unbalanced tree), it can be O(n).
+     * Space Complexity: O(1) - Constant space is used.
      */
     /**
      * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
@@ -8355,7 +8606,7 @@ var dataStructureTyped = (() => {
      * current instance of the binary search tree
      * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.options.iterationType) {
+    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
       function hasNoUndefined(arr) {
         return arr.indexOf(void 0) === -1;
       }
@@ -8423,8 +8674,8 @@ var dataStructureTyped = (() => {
       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.
@@ -8441,7 +8692,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;
@@ -8452,7 +8703,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.
@@ -8498,6 +8749,10 @@ 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.
+     */
     /**
      * The function `ensureNotKey` returns the node corresponding to the given key if it is a node key,
      * otherwise it returns the key itself.
@@ -8510,10 +8765,6 @@ var dataStructureTyped = (() => {
     ensureNotKey(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.
@@ -8537,7 +8788,7 @@ 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) {
+    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return [];
@@ -8613,7 +8864,7 @@ 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) {
+    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = "lt" /* lt */, targetNode = this.root, iterationType = this.iterationType) {
       targetNode = this.ensureNotKey(targetNode);
       const ans = [];
       if (!targetNode)
@@ -8653,17 +8904,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.
@@ -8676,7 +8918,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)
@@ -8713,8 +8955,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.
@@ -8725,7 +8976,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;
@@ -8768,6 +9019,22 @@ var dataStructureTyped = (() => {
       }
       return balanced;
     }
+    /**
+     * Time Complexity: O(n) - Visiting each node once.
+     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     */
+    init(elements) {
+      if (elements) {
+        for (const entryOrKey of elements) {
+          if (Array.isArray(entryOrKey)) {
+            const [key, value] = entryOrKey;
+            this.add(key, value);
+          } else {
+            this.add(entryOrKey);
+          }
+        }
+      }
+    }
     _setRoot(v) {
       if (v) {
         v.parent = void 0;
@@ -8783,7 +9050,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)
@@ -9234,14 +9501,10 @@ var dataStructureTyped = (() => {
      * constructor of the AVLTree class. It allows you to customize the behavior of the AVL tree by providing different
      * options.
      */
-    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)
+        this.init(elements);
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
@@ -9256,12 +9519,11 @@ var dataStructureTyped = (() => {
       return new AVLTreeNode(key, value);
     }
     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.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-     */
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -9283,7 +9545,7 @@ var dataStructureTyped = (() => {
       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.
      */
     /**
@@ -9312,6 +9574,22 @@ var dataStructureTyped = (() => {
       }
       return deletedResults;
     }
+    /**
+     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (BST) has logarithmic time complexity.
+     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     */
+    init(elements) {
+      if (elements) {
+        for (const entryOrKey of elements) {
+          if (Array.isArray(entryOrKey)) {
+            const [key, value] = entryOrKey;
+            this.add(key, value);
+          } else {
+            this.add(entryOrKey);
+          }
+        }
+      }
+    }
     /**
      * The `_swap` function swaps the key, value, and height properties between two nodes in a binary
      * tree.
@@ -9627,18 +9905,14 @@ var dataStructureTyped = (() => {
      * @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);
+    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)
+        this.init(elements);
     }
     get root() {
       return this._root;
@@ -9650,12 +9924,11 @@ var dataStructureTyped = (() => {
       return new RedBlackTreeNode(key, value, color);
     }
     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)
@@ -9788,13 +10061,13 @@ var dataStructureTyped = (() => {
       helper(this.root);
       return ans;
     }
-    isRealNode(node) {
-      return node !== this.Sentinel && node !== void 0;
-    }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
      */
+    isRealNode(node) {
+      return node !== this.Sentinel && node !== void 0;
+    }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -9816,7 +10089,7 @@ 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;
@@ -9871,10 +10144,26 @@ 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;
     }
+    init(elements) {
+      if (elements) {
+        for (const entryOrKey of elements) {
+          if (Array.isArray(entryOrKey)) {
+            const [key, value] = entryOrKey;
+            this.add(key, value);
+          } else {
+            this.add(entryOrKey);
+          }
+        }
+      }
+    }
     _setRoot(v) {
       if (v) {
         v.parent = void 0;
@@ -10119,15 +10408,11 @@ var dataStructureTyped = (() => {
      * @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.init(elements);
     }
     get count() {
       return this._count;
@@ -10145,12 +10430,11 @@ 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.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-     */
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -10229,8 +10513,8 @@ var dataStructureTyped = (() => {
       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(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.
@@ -10262,8 +10546,8 @@ var dataStructureTyped = (() => {
       return inserted;
     }
     /**
-     * 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.
@@ -10276,7 +10560,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;
@@ -10312,8 +10596,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.
@@ -10387,8 +10671,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.
@@ -10397,6 +10681,22 @@ var dataStructureTyped = (() => {
       super.clear();
       this._count = 0;
     }
+    /**
+     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
+     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     */
+    init(elements) {
+      if (elements) {
+        for (const entryOrKey of elements) {
+          if (Array.isArray(entryOrKey)) {
+            const [key, value] = entryOrKey;
+            this.add(key, value);
+          } else {
+            this.add(entryOrKey);
+          }
+        }
+      }
+    }
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
@@ -11114,7 +11414,7 @@ var dataStructureTyped = (() => {
       this.children = /* @__PURE__ */ new Map();
     }
   };
-  var Trie = class {
+  var Trie = class _Trie {
     constructor(words, caseSensitive = true) {
       __publicField(this, "_caseSensitive");
       __publicField(this, "_root");
@@ -11397,6 +11697,53 @@ var dataStructureTyped = (() => {
         dfs(startNode, prefix);
       return words;
     }
+    *[Symbol.iterator]() {
+      function* _dfs(node, path) {
+        if (node.isEnd) {
+          yield path;
+        }
+        for (const [char, childNode] of node.children) {
+          yield* __yieldStar(_dfs(childNode, path + char));
+        }
+      }
+      yield* __yieldStar(_dfs(this.root, ""));
+    }
+    forEach(callback) {
+      let index = 0;
+      for (const word of this) {
+        callback(word, index, this);
+        index++;
+      }
+    }
+    filter(predicate) {
+      const results = [];
+      let index = 0;
+      for (const word of this) {
+        if (predicate(word, index, this)) {
+          results.push(word);
+        }
+        index++;
+      }
+      return results;
+    }
+    map(callback) {
+      const newTrie = new _Trie();
+      let index = 0;
+      for (const word of this) {
+        newTrie.add(callback(word, index, this));
+        index++;
+      }
+      return newTrie;
+    }
+    reduce(callback, initialValue) {
+      let accumulator = initialValue;
+      let index = 0;
+      for (const word of this) {
+        accumulator = callback(accumulator, word, index, this);
+        index++;
+      }
+      return accumulator;
+    }
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.