data-structure-typed 1.48.0 → 1.48.2

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

@@ -126,7 +126,10 @@ var dataStructureTyped = (() => {
     HashTable: () => HashTable,
     HashTableNode: () => HashTableNode,
     Heap: () => Heap,
+    IterableElementBase: () => IterableElementBase,
+    IterablePairBase: () => IterablePairBase,
     IterationType: () => IterationType,
+    LinkedHashMap: () => LinkedHashMap,
     LinkedListQueue: () => LinkedListQueue,
     MapEdge: () => MapEdge,
     MapGraph: () => MapGraph,
@@ -515,12 +518,534 @@ var dataStructureTyped = (() => {
   };
   var calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
 
+  // src/data-structures/base/iterable-base.ts
+  var IterablePairBase = class {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function is an implementation of the Symbol.iterator method that returns an iterable iterator.
+     * @param {any[]} args - The `args` parameter in the code snippet represents a rest parameter. It
+     * allows the function to accept any number of arguments as an array. In this case, the `args`
+     * parameter is used to pass any additional arguments to the `_getIterator` method.
+     */
+    *[Symbol.iterator](...args) {
+      yield* __yieldStar(this._getIterator(...args));
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function returns an iterator that yields key-value pairs from the object, where the value can
+     * be undefined.
+     */
+    *entries() {
+      for (const item of this) {
+        yield item;
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function returns an iterator that yields the keys of a data structure.
+     */
+    *keys() {
+      for (const item of this) {
+        yield item[0];
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function returns an iterator that yields the values of a collection.
+     */
+    *values() {
+      for (const item of this) {
+        yield item[1];
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `every` function checks if every element in a collection satisfies a given condition.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * `value`, `key`, and `index`. It should return a boolean value indicating whether the condition is
+     * met for the current element in the iteration.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the first argument to the `predicate` function. If `thisArg` is not provided
+     * @returns The `every` method is returning a boolean value. It returns `true` if every element in
+     * the collection satisfies the provided predicate function, and `false` otherwise.
+     */
+    every(predicate, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The "some" function iterates over a collection and returns true if at least one element satisfies
+     * a given predicate.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * `value`, `key`, and `index`. It should return a boolean value indicating whether the condition is
+     * met for the current element in the iteration.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
+     * it will be passed as the first argument to the `predicate` function. If `thisArg` is
+     * @returns a boolean value. It returns true if the predicate function returns true for any pair in
+     * the collection, and false otherwise.
+     */
+    some(predicate, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        if (predicate.call(thisArg, item[1], item[0], index++, this)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `forEach` function iterates over each key-value pair in a collection and executes a callback
+     * function for each pair.
+     * @param callbackfn - The callback function that will be called for each element in the collection.
+     * It takes four parameters: the value of the current element, the key of the current element, the
+     * index of the current element, and the collection itself.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If `thisArg` is provided, it will be
+     * used as the `this` value when calling the callback function. If `thisArg` is not provided, `
+     */
+    forEach(callbackfn, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        const [key, value] = item;
+        callbackfn.call(thisArg, value, key, index++, this);
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `reduce` function iterates over key-value pairs and applies a callback function to each pair,
+     * accumulating a single value.
+     * @param callbackfn - The callback function that will be called for each element in the collection.
+     * It takes four arguments: the current accumulator value, the current value of the element, the key
+     * of the element, and the index of the element in the collection. It should return the updated
+     * accumulator value.
+     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
+     * is the value that will be used as the first argument to the `callbackfn` function when reducing
+     * the elements of the collection.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
+     * all the elements in the collection.
+     */
+    reduce(callbackfn, initialValue) {
+      let accumulator = initialValue;
+      let index = 0;
+      for (const item of this) {
+        const [key, value] = item;
+        accumulator = callbackfn(accumulator, value, key, index++, this);
+      }
+      return accumulator;
+    }
+  };
+  var IterableElementBase = class {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function is an implementation of the Symbol.iterator method that returns an IterableIterator.
+     * @param {any[]} args - The `args` parameter in the code snippet represents a rest parameter. It
+     * allows the function to accept any number of arguments as an array. In this case, the `args`
+     * parameter is used to pass any number of arguments to the `_getIterator` method.
+     */
+    *[Symbol.iterator](...args) {
+      yield* __yieldStar(this._getIterator(...args));
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function returns an iterator that yields all the values in the object.
+     */
+    *values() {
+      for (const item of this) {
+        yield item;
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `every` function checks if every element in the array satisfies a given predicate.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * the current element being processed, its index, and the array it belongs to. It should return a
+     * boolean value indicating whether the element satisfies a certain condition or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `every` method is returning a boolean value. It returns `true` if every element in
+     * the array satisfies the provided predicate function, and `false` otherwise.
+     */
+    every(predicate, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        if (!predicate.call(thisArg, item, index++, this)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The "some" function checks if at least one element in a collection satisfies a given predicate.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * `value`, `index`, and `array`. It should return a boolean value indicating whether the current
+     * element satisfies the condition.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
+     * it will be passed as the `this` value to the `predicate` function. If `thisArg
+     * @returns a boolean value. It returns true if the predicate function returns true for any element
+     * in the collection, and false otherwise.
+     */
+    some(predicate, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        if (predicate.call(thisArg, item, index++, this)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `forEach` function iterates over each element in an array-like object and calls a callback
+     * function for each element.
+     * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
+     * the array. It takes three arguments: the current element being processed, the index of the current
+     * element, and the array that forEach was called upon.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+     * be passed as the `this` value to the `callbackfn` function. If `thisArg
+     */
+    forEach(callbackfn, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        callbackfn.call(thisArg, item, index++, this);
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `reduce` function iterates over the elements of an array-like object and applies a callback
+     * function to reduce them into a single value.
+     * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
+     * the array. It takes four arguments:
+     * @param {U} initialValue - The initialValue parameter is the initial value of the accumulator. It
+     * is the value that the accumulator starts with before the reduction operation begins.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
+     * all the elements in the array and applying the callback function to each element.
+     */
+    reduce(callbackfn, initialValue) {
+      let accumulator = initialValue;
+      let index = 0;
+      for (const item of this) {
+        accumulator = callbackfn(accumulator, item, index++, this);
+      }
+      return accumulator;
+    }
+  };
+
   // src/data-structures/hash/hash-map.ts
-  var HashMap = class _HashMap {
+  var HashMap = class _HashMap extends IterablePairBase {
+    /**
+     * The constructor function initializes a new instance of a class with optional elements and options.
+     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
+     * key-value pairs.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the constructor. In this case, it has one property:
+     */
+    constructor(elements = [], options) {
+      super();
+      __publicField(this, "_store", {});
+      __publicField(this, "_objMap", /* @__PURE__ */ new Map());
+      __publicField(this, "_size", 0);
+      __publicField(this, "_hashFn", (key) => String(key));
+      if (options) {
+        const { hashFn } = options;
+        if (hashFn) {
+          this._hashFn = hashFn;
+        }
+      }
+      if (elements) {
+        this.setMany(elements);
+      }
+    }
+    get size() {
+      return this._size;
+    }
+    isEmpty() {
+      return this.size === 0;
+    }
+    clear() {
+      this._store = {};
+      this._objMap.clear();
+      this._size = 0;
+    }
+    /**
+     * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
+     * the key is not already present.
+     * @param {K} key - The key parameter is the key used to identify the value in the data structure. It
+     * can be of any type, but if it is an object, it will be stored in a Map, otherwise it will be
+     * stored in a regular JavaScript object.
+     * @param {V} value - The value parameter represents the value that you want to associate with the
+     * key in the data structure.
+     */
+    set(key, value) {
+      if (this._isObjKey(key)) {
+        if (!this._objMap.has(key)) {
+          this._size++;
+        }
+        this._objMap.set(key, value);
+      } else {
+        const strKey = this._getNoObjKey(key);
+        if (this._store[strKey] === void 0) {
+          this._size++;
+        }
+        this._store[strKey] = { key, value };
+      }
+    }
+    /**
+     * The function "setMany" sets multiple key-value pairs in a map.
+     * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
+     * key-value pair is represented as an array with two elements: the key and the value.
+     */
+    setMany(elements) {
+      for (const [key, value] of elements)
+        this.set(key, value);
+    }
+    /**
+     * The `get` function retrieves a value from a map based on a given key, either from an object map or
+     * a string map.
+     * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
+     * of any type, but it should be compatible with the key type used when the map was created.
+     * @returns The method `get(key: K)` returns a value of type `V` if the key exists in the `_objMap`
+     * or `_store`, otherwise it returns `undefined`.
+     */
+    get(key) {
+      var _a;
+      if (this._isObjKey(key)) {
+        return this._objMap.get(key);
+      } else {
+        const strKey = this._getNoObjKey(key);
+        return (_a = this._store[strKey]) == null ? void 0 : _a.value;
+      }
+    }
+    /**
+     * The `has` function checks if a given key exists in the `_objMap` or `_store` based on whether it
+     * is an object key or not.
+     * @param {K} key - The parameter "key" is of type K, which means it can be any type.
+     * @returns The `has` method is returning a boolean value.
+     */
+    has(key) {
+      if (this._isObjKey(key)) {
+        return this._objMap.has(key);
+      } else {
+        const strKey = this._getNoObjKey(key);
+        return strKey in this._store;
+      }
+    }
+    /**
+     * The `delete` function removes an element from a map-like data structure based on the provided key.
+     * @param {K} key - The `key` parameter is the key of the element that you want to delete from the
+     * data structure.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the key was
+     * successfully deleted from the map, and `false` if the key was not found in the map.
+     */
+    delete(key) {
+      if (this._isObjKey(key)) {
+        if (this._objMap.has(key)) {
+          this._size--;
+        }
+        return this._objMap.delete(key);
+      } else {
+        const strKey = this._getNoObjKey(key);
+        if (strKey in this._store) {
+          delete this._store[strKey];
+          this._size--;
+          return true;
+        }
+        return false;
+      }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new HashMap by applying a callback function to each
+     * key-value pair in the original HashMap.
+     * @param callbackfn - The callback function that will be called for each key-value pair in the
+     * HashMap. It takes four parameters:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+     * be passed as the `this` value to the `callbackfn` function. If `thisArg
+     * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
+     * the provided callback function.
+     */
+    map(callbackfn, thisArg) {
+      const resultMap = new _HashMap();
+      let index = 0;
+      for (const [key, value] of this) {
+        resultMap.set(key, callbackfn.call(thisArg, value, key, index++, this));
+      }
+      return resultMap;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new HashMap containing key-value pairs from the original HashMap
+     * that satisfy a given predicate function.
+     * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
+     * index, and map. It is used to determine whether an element should be included in the filtered map
+     * or not. The function should return a boolean value - true if the element should be included, and
+     * false otherwise.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `HashMap` object that contains the key-value pairs
+     * from the original `HashMap` that pass the provided `predicate` function.
+     */
+    filter(predicate, thisArg) {
+      const filteredMap = new _HashMap();
+      let index = 0;
+      for (const [key, value] of this) {
+        if (predicate.call(thisArg, value, key, index++, this)) {
+          filteredMap.set(key, value);
+        }
+      }
+      return filteredMap;
+    }
+    print() {
+      console.log([...this.entries()]);
+    }
+    /**
+     * The function returns an iterator that yields key-value pairs from both an object store and an
+     * object map.
+     */
+    *_getIterator() {
+      for (const node of Object.values(this._store)) {
+        yield [node.key, node.value];
+      }
+      for (const node of this._objMap) {
+        yield node;
+      }
+    }
+    _isObjKey(key) {
+      const keyType = typeof key;
+      return (keyType === "object" || keyType === "function") && key !== null;
+    }
+    _getNoObjKey(key) {
+      const keyType = typeof key;
+      let strKey;
+      if (keyType !== "string" && keyType !== "number" && keyType !== "symbol") {
+        strKey = this._hashFn(key);
+      } else {
+        if (keyType === "number") {
+          strKey = key;
+        } else {
+          strKey = key;
+        }
+      }
+      return strKey;
+    }
+  };
+  var LinkedHashMap = class _LinkedHashMap extends IterablePairBase {
     constructor(elements, options = {
       hashFn: (key) => String(key),
       objHashFn: (key) => key
     }) {
+      super();
       __publicField(this, "_noObjMap", {});
       __publicField(this, "_objMap", /* @__PURE__ */ new WeakMap());
       __publicField(this, "_head");
@@ -604,39 +1129,53 @@ var dataStructureTyped = (() => {
      */
     set(key, value) {
       let node;
+      const isNewKey = !this.has(key);
       if (isWeakKey(key)) {
         const hash = this._objHashFn(key);
         node = this._objMap.get(hash);
-        if (node) {
-          node.value = value;
-        } else {
+        if (!node && isNewKey) {
           node = { key: hash, value, prev: this._tail, next: this._sentinel };
           this._objMap.set(hash, node);
+        } else if (node) {
+          node.value = value;
         }
       } else {
         const hash = this._hashFn(key);
         node = this._noObjMap[hash];
-        if (node) {
+        if (!node && isNewKey) {
+          this._noObjMap[hash] = node = { key, value, prev: this._tail, next: this._sentinel };
+        } else if (node) {
           node.value = value;
+        }
+      }
+      if (node && isNewKey) {
+        if (this._size === 0) {
+          this._head = node;
+          this._sentinel.next = node;
         } else {
-          this._noObjMap[hash] = node = {
-            key,
-            value,
-            prev: this._tail,
-            next: this._sentinel
-          };
+          this._tail.next = node;
+          node.prev = this._tail;
         }
+        this._tail = node;
+        this._sentinel.prev = node;
+        this._size++;
       }
-      if (this._size === 0) {
-        this._head = node;
-        this._sentinel.next = node;
+      return this._size;
+    }
+    has(key) {
+      if (isWeakKey(key)) {
+        const hash = this._objHashFn(key);
+        return this._objMap.has(hash);
       } else {
-        this._tail.next = node;
+        const hash = this._hashFn(key);
+        return hash in this._noObjMap;
+      }
+    }
+    setMany(entries) {
+      for (const entry of entries) {
+        const [key, value] = entry;
+        this.set(key, value);
       }
-      this._tail = node;
-      this._sentinel.prev = node;
-      this._size++;
-      return this._size;
     }
     /**
      * Time Complexity: O(1)
@@ -751,36 +1290,38 @@ var dataStructureTyped = (() => {
       this._size = 0;
       this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
     }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the HashMap.
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in a HashMap and executes a callback function on
-     * each element.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * HashMap. It takes three arguments:
-     */
-    forEach(callback) {
-      let index = 0;
-      let node = this._head;
-      while (node !== this._sentinel) {
-        callback([node.key, node.value], index++, this);
-        node = node.next;
+    clone() {
+      const cloned = new _LinkedHashMap([], { hashFn: this._hashFn, objHashFn: this._objHashFn });
+      for (const entry of this) {
+        const [key, value] = entry;
+        cloned.set(key, value);
       }
+      return cloned;
     }
     /**
-     * The `filter` function takes a predicate function and returns a new HashMap containing only the
-     * key-value pairs that satisfy the predicate.
-     * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
-     * `map`.
-     * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
-     * satisfy the given predicate function.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    filter(predicate) {
-      const filteredMap = new _HashMap();
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new `LinkedHashMap` containing key-value pairs from the original
+     * map that satisfy a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+     * `value`, `key`, `index`, and `this`. It should return a boolean value indicating whether the
+     * current element should be included in the filtered map or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is not provided, `this
+     * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
+     * `LinkedHashMap` object that satisfy the given predicate function.
+     */
+    filter(predicate, thisArg) {
+      const filteredMap = new _LinkedHashMap();
       let index = 0;
       for (const [key, value] of this) {
-        if (predicate([key, value], index, this)) {
+        if (predicate.call(thisArg, value, key, index, this)) {
           filteredMap.set(key, value);
         }
         index++;
@@ -788,59 +1329,52 @@ var dataStructureTyped = (() => {
       return filteredMap;
     }
     /**
-     * The `map` function takes a callback function and returns a new HashMap with the values transformed
-     * by the callback.
-     * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
-     * `map`.
-     * @returns a new HashMap object with the values mapped according to the provided callback function.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new `LinkedHashMap` by applying a callback function to
+     * each key-value pair in the original map.
+     * @param callback - The callback parameter is a function that will be called for each key-value pair
+     * in the map. It takes four arguments: the value of the current key-value pair, the key of the
+     * current key-value pair, the index of the current key-value pair, and the map itself. The callback
+     * function should
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If provided, the callback function will
+     * be called with `thisArg` as its `this` value. If not provided, `this` will refer to the current
+     * map
+     * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
+     * function.
      */
-    map(callback) {
-      const mappedMap = new _HashMap();
+    map(callback, thisArg) {
+      const mappedMap = new _LinkedHashMap();
       let index = 0;
       for (const [key, value] of this) {
-        const newValue = callback([key, value], index, this);
+        const newValue = callback.call(thisArg, value, key, index, this);
         mappedMap.set(key, newValue);
         index++;
       }
       return mappedMap;
     }
-    /**
-     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
-     * each element, accumulating a single value.
-     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
-     * element, and map. It is called for each element in the HashMap and is used to accumulate a single
-     * result.
-     * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
-     * is the value that will be passed as the first argument to the `callback` function when reducing
-     * the elements of the map.
-     * @returns The `reduce` function is returning the final value of the accumulator after iterating
-     * over all the elements in the HashMap and applying the callback function to each element.
-     */
-    reduce(callback, initialValue) {
-      let accumulator = initialValue;
-      let index = 0;
-      for (const entry of this) {
-        accumulator = callback(accumulator, entry, index, this);
-        index++;
-      }
-      return accumulator;
+    print() {
+      console.log([...this]);
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the HashMap.
+     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.
      */
-    *[Symbol.iterator]() {
+    *_getIterator() {
       let node = this._head;
       while (node !== this._sentinel) {
         yield [node.key, node.value];
         node = node.next;
       }
     }
-    print() {
-      console.log([...this]);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -879,11 +1413,12 @@ var dataStructureTyped = (() => {
       this.next = void 0;
     }
   };
-  var SinglyLinkedList = class _SinglyLinkedList {
+  var SinglyLinkedList = class _SinglyLinkedList extends IterableElementBase {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
     constructor(elements) {
+      super();
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_length");
@@ -1465,54 +2000,31 @@ var dataStructureTyped = (() => {
       return count;
     }
     /**
-     * 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;
-      }
-    }
-    /**
-     * 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 `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.
-     */
-    forEach(callback) {
-      let index = 0;
-      for (const el of this) {
-        callback(el, index, this);
-        index++;
-      }
-    }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * 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.
-     * @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 SinglyLinkedList class.
-     */
-    filter(callback) {
+     * The `filter` function creates a new SinglyLinkedList by iterating over the elements of the current
+     * list and applying a callback function to each element to determine if it should be included in the
+     * filtered list.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * list. It takes three arguments: the current element, the index of the current element, and the
+     * list itself. The callback function should return a boolean value indicating whether the current
+     * element should be included in the filtered list or not
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `SinglyLinkedList` object that contains the
+     * elements that pass the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
       const filteredList = new _SinglyLinkedList();
       let index = 0;
       for (const current of this) {
-        if (callback(current, index, this)) {
+        if (callback.call(thisArg, current, index, this)) {
           filteredList.push(current);
         }
         index++;
@@ -1524,21 +2036,24 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * 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) {
+     * The `map` function creates a new SinglyLinkedList by applying a callback function to each element
+     * of the original list.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the linked list. It takes three arguments:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` function is returning a new `SinglyLinkedList` object that contains the results
+     * of applying the provided `callback` function to each element in the original list.
+     */
+    map(callback, thisArg) {
       const mappedList = new _SinglyLinkedList();
       let index = 0;
       for (const current of this) {
-        mappedList.push(callback(current, index, this));
+        mappedList.push(callback.call(thisArg, current, index, this));
         index++;
       }
       return mappedList;
@@ -1547,30 +2062,15 @@ var dataStructureTyped = (() => {
      * 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 {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 index = 0;
-      for (const current of this) {
-        accumulator = callback(accumulator, current, index, this);
-        index++;
+    print() {
+      console.log([...this]);
+    }
+    *_getIterator() {
+      let current = this.head;
+      while (current) {
+        yield current.value;
+        current = current.next;
       }
-      return accumulator;
-    }
-    print() {
-      console.log([...this]);
     }
   };
 
@@ -1590,11 +2090,12 @@ var dataStructureTyped = (() => {
       this.prev = void 0;
     }
   };
-  var DoublyLinkedList = class _DoublyLinkedList {
+  var DoublyLinkedList = class _DoublyLinkedList extends IterableElementBase {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
     constructor(elements) {
+      super();
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_length");
@@ -2230,54 +2731,31 @@ var dataStructureTyped = (() => {
       return array;
     }
     /**
-     * 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;
-      }
-    }
-    /**
-     * 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 `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.
-     */
-    forEach(callback) {
-      let index = 0;
-      for (const el of this) {
-        callback(el, index, this);
-        index++;
-      }
-    }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * 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.
-     */
-    filter(callback) {
+     * The `filter` function creates a new DoublyLinkedList by iterating over the elements of the current
+     * list and applying a callback function to each element, returning only the elements for which the
+     * callback function returns true.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the DoublyLinkedList. It takes three arguments: the current element, the index of the current
+     * element, and the DoublyLinkedList itself. The callback function should return a boolean value
+     * indicating whether the current element should be included
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `DoublyLinkedList` object that contains the
+     * elements that pass the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
       const filteredList = new _DoublyLinkedList();
       let index = 0;
       for (const current of this) {
-        if (callback(current, index, this)) {
+        if (callback.call(thisArg, current, index, this)) {
           filteredList.push(current);
         }
         index++;
@@ -2289,21 +2767,27 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * 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 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.
+     * The `map` function creates a new DoublyLinkedList by applying a callback function to each element
+     * in the original list.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * DoublyLinkedList. It takes three arguments: the current element, the index of the current element,
+     * and the DoublyLinkedList itself. The callback function should return a value that will be added to
+     * the new DoublyLinkedList that
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` function is returning a new `DoublyLinkedList` object that contains the results
+     * of applying the provided `callback` function to each element in the original `DoublyLinkedList`
+     * object.
      */
-    map(callback) {
+    map(callback, thisArg) {
       const mappedList = new _DoublyLinkedList();
       let index = 0;
       for (const current of this) {
-        mappedList.push(callback(current, index, this));
+        mappedList.push(callback.call(thisArg, current, index, this));
         index++;
       }
       return mappedList;
@@ -2312,30 +2796,18 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      */
+    print() {
+      console.log([...this]);
+    }
     /**
-     * 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 {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.
+     * The function returns an iterator that iterates over the values of a linked list.
      */
-    reduce(callback, initialValue) {
-      let accumulator = initialValue;
-      let index = 0;
-      for (const current of this) {
-        accumulator = callback(accumulator, current, index, this);
-        index++;
+    *_getIterator() {
+      let current = this.head;
+      while (current) {
+        yield current.value;
+        current = current.next;
       }
-      return accumulator;
-    }
-    print() {
-      console.log([...this]);
     }
   };
 
@@ -2588,7 +3060,7 @@ var dataStructureTyped = (() => {
   };
 
   // src/data-structures/stack/stack.ts
-  var Stack = class _Stack {
+  var Stack = class _Stack extends IterableElementBase {
     /**
      * The constructor initializes an array of elements, which can be provided as an optional parameter.
      * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
@@ -2596,6 +3068,7 @@ var dataStructureTyped = (() => {
      * is provided and is an array, it is assigned to the `_elements
      */
     constructor(elements) {
+      super();
       __publicField(this, "_elements");
       this._elements = [];
       if (elements) {
@@ -2721,92 +3194,78 @@ var dataStructureTyped = (() => {
       return new _Stack(this.elements.slice());
     }
     /**
-     * Custom iterator for the Stack class.
-     * @returns An iterator object.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    *[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.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new stack containing elements from the original stack that satisfy
+     * a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * the current element being iterated over, the index of the current element, and the stack itself.
+     * It should return a boolean value indicating whether the element should be included in the filtered
+     * stack or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Stack` object that contains the elements that
+     * satisfy the given predicate function.
      */
-    forEach(callback) {
-      let index = 0;
-      for (const el of this) {
-        callback(el, index, this);
-        index++;
-      }
-    }
-    filter(predicate) {
+    filter(predicate, thisArg) {
       const newStack = new _Stack();
       let index = 0;
       for (const el of this) {
-        if (predicate(el, index, this)) {
+        if (predicate.call(thisArg, el, index, this)) {
           newStack.push(el);
         }
         index++;
       }
       return newStack;
     }
-    map(callback) {
+    /**
+     * 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 stack,
+     * returning a new stack with the results.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the stack. It takes three arguments:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` method is returning a new `Stack` object.
+     */
+    map(callback, thisArg) {
       const newStack = new _Stack();
       let index = 0;
       for (const el of this) {
-        newStack.push(callback(el, index, this));
+        newStack.push(callback.call(thisArg, 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
-  var LinkedListQueue = class extends SinglyLinkedList {
-    /**
-     * The enqueue function adds a value to the end of an array.
-     * @param {E} value - The value parameter represents the value that you want to add to the queue.
-     */
-    enqueue(value) {
-      this.push(value);
-    }
-    /**
-     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
-     * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
-     */
-    dequeue() {
-      return this.shift();
-    }
-    /**
-     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-     */
-    getFirst() {
-      var _a;
-      return (_a = this.head) == null ? void 0 : _a.value;
-    }
     /**
-     * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     * Custom iterator for the Stack class.
+     * @returns An iterator object.
      */
-    peek() {
-      return this.getFirst();
+    *_getIterator() {
+      for (let i = 0; i < this.elements.length; i++) {
+        yield this.elements[i];
+      }
     }
   };
-  var Queue = class _Queue {
+
+  // src/data-structures/queue/queue.ts
+  var Queue = class _Queue extends IterableElementBase {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
      * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
@@ -2814,6 +3273,7 @@ var dataStructureTyped = (() => {
      * initialized as an empty array.
      */
     constructor(elements) {
+      super();
       __publicField(this, "_nodes");
       __publicField(this, "_offset");
       this._nodes = elements || [];
@@ -3035,31 +3495,6 @@ var dataStructureTyped = (() => {
     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)
@@ -3068,18 +3503,23 @@ var dataStructureTyped = (() => {
      * 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.
+     * The `filter` function creates a new `Queue` object containing elements from the original `Queue`
+     * that satisfy a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * the current element being iterated over, the index of the current element, and the queue itself.
+     * It should return a boolean value indicating whether the element should be included in the filtered
+     * queue or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Queue` object that contains the elements that
+     * satisfy the given predicate function.
      */
-    filter(predicate) {
+    filter(predicate, thisArg) {
       const newDeque = new _Queue([]);
       let index = 0;
       for (const el of this) {
-        if (predicate(el, index, this)) {
+        if (predicate.call(thisArg, el, index, this)) {
           newDeque.push(el);
         }
         index++;
@@ -3094,33 +3534,69 @@ var dataStructureTyped = (() => {
      * 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) {
+     * The `map` function takes a callback function and applies it to each element in the queue,
+     * returning a new queue with the results.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * queue. It takes three arguments: the current element, the index of the current element, and the
+     * queue itself. The callback function should return a new value that will be added to the new queue.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` function is returning a new `Queue` object with the transformed elements.
+     */
+    map(callback, thisArg) {
       const newDeque = new _Queue([]);
       let index = 0;
       for (const el of this) {
-        newDeque.push(callback(el, index, this));
+        newDeque.push(callback.call(thisArg, 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++;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    *_getIterator() {
+      for (const item of this.nodes) {
+        yield item;
       }
-      return accumulator;
+    }
+  };
+  var LinkedListQueue = class extends SinglyLinkedList {
+    /**
+     * The enqueue function adds a value to the end of an array.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
+     */
+    enqueue(value) {
+      this.push(value);
+    }
+    /**
+     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
+     * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
+     */
+    dequeue() {
+      return this.shift();
+    }
+    /**
+     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    getFirst() {
+      var _a;
+      return (_a = this.head) == null ? void 0 : _a.value;
+    }
+    /**
+     * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    peek() {
+      return this.getFirst();
     }
   };
 
   // src/data-structures/queue/deque.ts
-  var Deque = class _Deque {
+  var Deque = class _Deque extends IterableElementBase {
     /**
      * The constructor initializes a data structure with a specified bucket size and populates it with
      * elements from an iterable.
@@ -3131,6 +3607,7 @@ var dataStructureTyped = (() => {
      * stored in each bucket. It determines the size of each bucket in the data structure.
      */
     constructor(elements = [], bucketSize = 1 << 12) {
+      super();
       __publicField(this, "_bucketFirst", 0);
       __publicField(this, "_firstInBucket", 0);
       __publicField(this, "_bucketLast", 0);
@@ -3758,42 +4235,6 @@ var dataStructureTyped = (() => {
       }
       return arr;
     }
-    /**
-     * 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(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)
@@ -3802,18 +4243,23 @@ var dataStructureTyped = (() => {
      * 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 `Deque` object that contains only the elements
-     * that satisfy the given `predicate` function.
+     * The `filter` function creates a new deque containing elements from the original deque that satisfy
+     * a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * the current element being iterated over, the index of the current element, and the deque itself.
+     * It should return a boolean value indicating whether the element should be included in the filtered
+     * deque or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Deque` object that contains the elements that
+     * satisfy the given predicate function.
      */
-    filter(predicate) {
+    filter(predicate, thisArg) {
       const newDeque = new _Deque([], this._bucketSize);
       let index = 0;
       for (const el of this) {
-        if (predicate(el, index, this)) {
+        if (predicate.call(thisArg, el, index, this)) {
           newDeque.push(el);
         }
         index++;
@@ -3828,48 +4274,42 @@ var dataStructureTyped = (() => {
      * 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.
+     * The `map` function creates a new Deque by applying a callback function to each element of the
+     * original Deque.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the deque. It takes three arguments:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns a new Deque object with the mapped values.
      */
-    map(callback) {
+    map(callback, thisArg) {
       const newDeque = new _Deque([], this._bucketSize);
       let index = 0;
       for (const el of this) {
-        newDeque.push(callback(el, index, this));
+        newDeque.push(callback.call(thisArg, el, index, this));
         index++;
       }
       return newDeque;
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
+    print() {
+      console.log([...this]);
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `reduce` function iterates over the elements of a deque and applies a callback function to
-     * each element, accumulating a single value.
-     * @param callback - The `callback` parameter is a function that takes four arguments:
-     * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
-     * is the value that will be passed as the first argument to the `callback` function when reducing
-     * the elements of the deque.
-     * @returns the final value of the accumulator after iterating over all elements in the deque and
-     * applying the callback function to each element.
-     */
-    reduce(callback, initialValue) {
-      let accumulator = initialValue;
-      let index = 0;
-      for (const el of this) {
-        accumulator = callback(accumulator, el, index, this);
-        index++;
+     * The above function is an implementation of the iterator protocol in TypeScript, allowing the
+     * object to be iterated over using a for...of loop.
+     */
+    *_getIterator() {
+      for (let i = 0; i < this.size; ++i) {
+        yield this.getAt(i);
       }
-      return accumulator;
-    }
-    print() {
-      console.log([...this]);
     }
     /**
      * Time Complexity: O(n)
@@ -4100,8 +4540,9 @@ var dataStructureTyped = (() => {
   };
 
   // src/data-structures/heap/heap.ts
-  var Heap = class _Heap {
+  var Heap = class _Heap extends IterableElementBase {
     constructor(elements, options) {
+      super();
       __publicField(this, "options");
       __publicField(this, "_elements", []);
       const defaultComparator = (a, b) => {
@@ -4396,47 +4837,70 @@ 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);
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new Heap object containing elements that pass a given callback
+     * function.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: the current element, the index of the current element, and the
+     * heap itself. The callback function should return a boolean value indicating whether the current
+     * element should be included in the filtered list
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
+      const filteredList = new _Heap();
       let index = 0;
-      for (const el of this) {
-        if (predicate(el, index, this)) {
-          filteredHeap.push(el);
+      for (const current of this) {
+        if (callback.call(thisArg, current, index, this)) {
+          filteredList.push(current);
         }
         index++;
       }
-      return filteredHeap;
+      return filteredList;
     }
-    map(callback, comparator) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new heap by applying a callback function to each element of the
+     * original heap.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * original heap. It takes three arguments: the current element, the index of the current element,
+     * and the original heap itself. The callback function should return a value of type T, which will be
+     * added to the mapped heap.
+     * @param comparator - The `comparator` parameter is a function that is used to compare elements in
+     * the heap. It takes two arguments, `a` and `b`, and returns a negative number if `a` is less than
+     * `b`, a positive number if `a` is greater than `b`, or
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used when you want to bind a
+     * specific object as the context for the callback function. If `thisArg` is not provided,
+     * `undefined` is used as
+     * @returns a new instance of the Heap class, which is created using the mapped elements from the
+     * original Heap.
+     */
+    map(callback, comparator, thisArg) {
       const mappedHeap = new _Heap([], { comparator });
       let index = 0;
       for (const el of this) {
-        mappedHeap.add(callback(el, index, this));
+        mappedHeap.add(callback.call(thisArg, 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)
@@ -4444,6 +4908,11 @@ var dataStructureTyped = (() => {
     print() {
       console.log([...this]);
     }
+    *_getIterator() {
+      for (const element of this.elements) {
+        yield element;
+      }
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -4950,8 +5419,9 @@ var dataStructureTyped = (() => {
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
      */
   };
-  var AbstractGraph = class {
+  var AbstractGraph = class extends IterablePairBase {
     constructor() {
+      super();
       __publicField(this, "_vertices", /* @__PURE__ */ new Map());
     }
     get vertices() {
@@ -5908,46 +6378,67 @@ var dataStructureTyped = (() => {
     getBridges() {
       return this.tarjan(false, true, false, false).bridges;
     }
-    *[Symbol.iterator]() {
-      for (const vertex of this._vertices.values()) {
-        yield [vertex.key, vertex.value];
-      }
-    }
-    forEach(callback) {
-      let index = 0;
-      for (const vertex of this) {
-        callback(vertex, index, this._vertices);
-        index++;
-      }
-    }
-    filter(predicate) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function iterates over key-value pairs in a data structure and returns an array of
+     * pairs that satisfy a given predicate.
+     * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+     * `value`, `key`, `index`, and `this`. It is used to determine whether an element should be included
+     * in the filtered array. The callback function should return `true` if the element should be
+     * included, and `
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
+     * @returns The `filter` method returns an array of key-value pairs `[VertexKey, V | undefined][]`
+     * that satisfy the given predicate function.
+     */
+    filter(predicate, thisArg) {
       const filtered = [];
       let index = 0;
-      for (const entry of this) {
-        if (predicate(entry, index, this._vertices)) {
-          filtered.push(entry);
+      for (const [key, value] of this) {
+        if (predicate.call(thisArg, value, key, index, this)) {
+          filtered.push([key, value]);
         }
         index++;
       }
       return filtered;
     }
-    map(callback) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function iterates over the elements of a collection and applies a callback function to
+     * each element, returning an array of the results.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * map. It takes four arguments:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If `thisArg` is provided, it will be
+     * used as the `this` value when calling the callback function. If `thisArg` is not provided, `
+     * @returns The `map` function is returning an array of type `T[]`.
+     */
+    map(callback, thisArg) {
       const mapped = [];
       let index = 0;
-      for (const entry of this) {
-        mapped.push(callback(entry, index, this._vertices));
+      for (const [key, value] of this) {
+        mapped.push(callback.call(thisArg, value, key, index, this));
         index++;
       }
       return mapped;
     }
-    reduce(callback, initialValue) {
-      let accumulator = initialValue;
-      let index = 0;
-      for (const entry of this) {
-        accumulator = callback(accumulator, entry, index, this._vertices);
-        index++;
+    *_getIterator() {
+      for (const vertex of this._vertices.values()) {
+        yield [vertex.key, vertex.value];
       }
-      return accumulator;
     }
     _addVertexOnly(newVertex) {
       if (this.hasVertex(newVertex)) {
@@ -6931,7 +7422,7 @@ var dataStructureTyped = (() => {
       return "MAL_NODE" /* MAL_NODE */;
     }
   };
-  var BinaryTree = class _BinaryTree {
+  var BinaryTree = class _BinaryTree extends IterablePairBase {
     /**
      * The constructor function initializes a binary tree object with optional elements and options.
      * @param [elements] - An optional iterable of BTNodeExemplar objects. These objects represent the
@@ -6942,6 +7433,7 @@ var dataStructureTyped = (() => {
      * required.
      */
     constructor(elements, options) {
+      super();
       __publicField(this, "iterationType", "ITERATIVE" /* ITERATIVE */);
       __publicField(this, "_root");
       __publicField(this, "_size");
@@ -8220,112 +8712,86 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time complexity: O(n)
-     * Space complexity: O(1)
+     * Space complexity: O(n)
      */
     /**
-     * The `forEach` function iterates over each entry in a tree and calls a callback function with the
-     * entry and the tree as arguments.
-     * @param callback - The callback parameter is a function that will be called for each entry in the
-     * tree. It takes two parameters: entry and tree.
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a new tree object and copies all the nodes from the original tree to
+     * the new tree.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
-    forEach(callback) {
-      for (const entry of this) {
-        callback(entry, this);
-      }
+    clone() {
+      const cloned = this.createTree();
+      this.bfs((node) => cloned.add([node.key, node.value]));
+      return cloned;
     }
     /**
-     * The `filter` function creates a new tree by iterating over the entries of the current tree and
-     * adding the entries that satisfy the given predicate.
-     * @param predicate - The `predicate` parameter is a function that takes two arguments: `entry` and
-     * `tree`.
-     * @returns The `filter` method is returning a new tree object that contains only the entries that
-     * satisfy the given predicate function.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    filter(predicate) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new tree by iterating over the elements of the current tree and
+     * adding only the elements that satisfy the given predicate function.
+     * @param predicate - The `predicate` parameter is a function that takes three arguments: `value`,
+     * `key`, and `index`. It should return a boolean value indicating whether the pair should be
+     * included in the filtered tree or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
+     * it will be passed as the first argument to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new tree object that contains the key-value pairs that
+     * pass the given predicate function.
+     */
+    filter(predicate, thisArg) {
       const newTree = this.createTree();
+      let index = 0;
       for (const [key, value] of this) {
-        if (predicate([key, value], this)) {
+        if (predicate.call(thisArg, value, key, index++, this)) {
           newTree.add([key, value]);
         }
       }
       return newTree;
     }
     /**
-     * The `map` function creates a new tree by applying a callback function to each entry in the current
-     * tree.
-     * @param callback - The callback parameter is a function that takes two arguments: entry and tree.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new tree by applying a callback function to each key-value pair in
+     * the original tree.
+     * @param callback - The callback parameter is a function that will be called for each key-value pair
+     * in the tree. It takes four arguments: the value of the current pair, the key of the current pair,
+     * the index of the current pair, and a reference to the tree itself. The callback function should
+     * return a new
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If you pass a value for `thisArg`, it
+     * will be used as the `this` value when the callback function is called. If you don't pass a value
      * @returns The `map` method is returning a new tree object.
      */
-    map(callback) {
+    map(callback, thisArg) {
       const newTree = this.createTree();
+      let index = 0;
       for (const [key, value] of this) {
-        newTree.add([key, callback([key, value], this)]);
+        newTree.add([key, callback.call(thisArg, value, key, index++, this)]);
       }
       return newTree;
     }
-    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
-    //   const newTree = this.createTree();
-    //   for (const [key, value] of this) {
-    //     newTree.add(key, callback([key, value], this));
-    //   }
-    //   return newTree;
-    // }
-    /**
-     * The `reduce` function iterates over the entries of a tree and applies a callback function to each
-     * entry, accumulating a single value.
-     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
-     * entry, and tree. It is called for each entry in the tree and is used to accumulate a single value
-     * based on the logic defined in the callback function.
-     * @param {T} initialValue - The initialValue parameter is the initial value of the accumulator. It
-     * is the value that will be passed as the first argument to the callback function when reducing the
-     * elements of the tree.
-     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
-     * all the entries in the tree and applying the callback function to each entry.
-     */
-    reduce(callback, initialValue) {
-      let accumulator = initialValue;
-      for (const [key, value] of this) {
-        accumulator = callback(accumulator, [key, value], this);
-      }
-      return accumulator;
-    }
-    /**
-     * The above function is an iterator for a binary tree that can be used to traverse the tree in
-     * either an iterative or recursive manner.
-     * @param node - The `node` parameter represents the current node in the binary tree from which the
-     * iteration starts. It is an optional parameter with a default value of `this.root`, which means
-     * that if no node is provided, the iteration will start from the root of the binary tree.
-     * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
-     * binary tree nodes in a specific order.
-     */
-    *[Symbol.iterator](node = this.root) {
-      if (!node)
-        return;
-      if (this.iterationType === "ITERATIVE" /* ITERATIVE */) {
-        const stack = [];
-        let current = node;
-        while (current || stack.length > 0) {
-          while (current && !isNaN(current.key)) {
-            stack.push(current);
-            current = current.left;
-          }
-          current = stack.pop();
-          if (current && !isNaN(current.key)) {
-            yield [current.key, current.value];
-            current = current.right;
-          }
-        }
-      } else {
-        if (node.left && !isNaN(node.key)) {
-          yield* __yieldStar(this[Symbol.iterator](node.left));
-        }
-        yield [node.key, node.value];
-        if (node.right && !isNaN(node.key)) {
-          yield* __yieldStar(this[Symbol.iterator](node.right));
-        }
-      }
-    }
+    // // 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 `print` function is used to display a binary tree structure in a visually appealing way.
      * @param {BTNKey | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `BTNKey | N | null |
@@ -8355,6 +8821,33 @@ var dataStructureTyped = (() => {
       };
       display(beginRoot);
     }
+    *_getIterator(node = this.root) {
+      if (!node)
+        return;
+      if (this.iterationType === "ITERATIVE" /* ITERATIVE */) {
+        const stack = [];
+        let current = node;
+        while (current || stack.length > 0) {
+          while (current && !isNaN(current.key)) {
+            stack.push(current);
+            current = current.left;
+          }
+          current = stack.pop();
+          if (current && !isNaN(current.key)) {
+            yield [current.key, current.value];
+            current = current.right;
+          }
+        }
+      } else {
+        if (node.left && !isNaN(node.key)) {
+          yield* __yieldStar(this[Symbol.iterator](node.left));
+        }
+        yield [node.key, node.value];
+        if (node.right && !isNaN(node.key)) {
+          yield* __yieldStar(this[Symbol.iterator](node.right));
+        }
+      }
+    }
     _displayAux(node, options) {
       const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
       const emptyDisplayLayout = [["\u2500"], 1, 0, 0];
@@ -10771,6 +11264,22 @@ var dataStructureTyped = (() => {
       super.clear();
       this._count = 0;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a deep copy of a tree object.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone() {
+      const cloned = this.createTree();
+      this.bfs((node) => cloned.add([node.key, node.value], node.count));
+      return cloned;
+    }
     /**
      * 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.
@@ -11492,8 +12001,9 @@ var dataStructureTyped = (() => {
       this.children = /* @__PURE__ */ new Map();
     }
   };
-  var Trie = class _Trie {
+  var Trie = class _Trie extends IterableElementBase {
     constructor(words, caseSensitive = true) {
+      super();
       __publicField(this, "_size");
       __publicField(this, "_caseSensitive");
       __publicField(this, "_root");
@@ -11788,56 +12298,75 @@ 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) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function takes a predicate function and returns a new array containing all the
+     * elements for which the predicate function returns true.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * `word`, `index`, and `this`. It should return a boolean value indicating whether the current
+     * element should be included in the filtered results or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
+     * @returns The `filter` method is returning an array of strings (`string[]`).
+     */
+    filter(predicate, thisArg) {
       const results = [];
       let index = 0;
       for (const word of this) {
-        if (predicate(word, index, this)) {
+        if (predicate.call(thisArg, word, index, this)) {
           results.push(word);
         }
         index++;
       }
       return results;
     }
-    map(callback) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new Trie by applying a callback function to each element in the Trie.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * Trie. It takes three arguments: the current element in the Trie, the index of the current element,
+     * and the Trie itself. The callback function should return a new value for the element.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` function is returning a new Trie object.
+     */
+    map(callback, thisArg) {
       const newTrie = new _Trie();
       let index = 0;
       for (const word of this) {
-        newTrie.add(callback(word, index, this));
+        newTrie.add(callback.call(thisArg, 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;
-    }
     print() {
       console.log([...this]);
     }
+    *_getIterator() {
+      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, ""));
+    }
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.