data-structure-typed 1.47.3 → 1.47.5

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;
     }
@@ -1413,58 +1464,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,51 +1509,65 @@ 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;
-      }
-    }
   };
 
   // src/data-structures/linked-list/doubly-linked-list.ts
@@ -1917,6 +1966,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 +2071,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 +2161,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 +2188,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 +2244,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 +2258,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 +2283,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,69 +2311,20 @@ 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;
-      }
-    }
   };
 
   // src/data-structures/linked-list/skip-linked-list.ts
@@ -2547,6 +2594,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 +2620,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 +2703,55 @@ var dataStructureTyped = (() => {
     clone() {
       return new _Stack(this.elements.slice());
     }
+    /**
+     * Custom iterator for the Stack class.
+     * @returns An iterator object.
+     */
+    *[Symbol.iterator]() {
+      for (let i = this.elements.length - 1; i >= 0; 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;
+    }
   };
 
   // src/data-structures/queue/queue.ts
@@ -2921,6 +3017,83 @@ var dataStructureTyped = (() => {
         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 `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.
+     */
+    map(callback) {
+      const newDeque = new _Queue([]);
+      let index = 0;
+      for (const el of this) {
+        newDeque.push(callback(el, index, this));
+        index++;
+      }
+      return newDeque;
+    }
+    reduce(callback, initialValue) {
+      let accumulator = initialValue;
+      let index = 0;
+      for (const el of this) {
+        accumulator = callback(accumulator, el, index, this);
+        index++;
+      }
+      return accumulator;
+    }
   };
 
   // src/data-structures/queue/deque.ts
@@ -3505,15 +3678,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 +3702,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 +3737,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 +3788,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,50 +3838,13 @@ 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);
-      }
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4090,26 +4270,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;
     }
     /**
@@ -4177,6 +4358,47 @@ 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({ comparator: this.comparator });
+      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)
@@ -11114,7 +11336,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 +11619,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.