data-structure-typed 1.48.1 → 1.48.3

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

@@ -108,6 +108,7 @@ var dataStructureTyped = (() => {
     AbstractVertex: () => AbstractVertex,
     BST: () => BST,
     BSTNode: () => BSTNode,
+    BSTVariant: () => BSTVariant,
     BinaryIndexedTree: () => BinaryIndexedTree,
     BinaryTree: () => BinaryTree,
     BinaryTreeNode: () => BinaryTreeNode,
@@ -126,6 +127,8 @@ var dataStructureTyped = (() => {
     HashTable: () => HashTable,
     HashTableNode: () => HashTableNode,
     Heap: () => Heap,
+    IterableElementBase: () => IterableElementBase,
+    IterablePairBase: () => IterablePairBase,
     IterationType: () => IterationType,
     LinkedHashMap: () => LinkedHashMap,
     LinkedListQueue: () => LinkedListQueue,
@@ -516,8 +519,317 @@ 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
@@ -527,6 +839,7 @@ var dataStructureTyped = (() => {
      * 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);
@@ -639,95 +952,13 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * The function returns an iterator that yields key-value pairs from both an object store and an
-     * object map.
-     */
-    *[Symbol.iterator]() {
-      for (const node of Object.values(this._store)) {
-        yield [node.key, node.value];
-      }
-      for (const node of this._objMap) {
-        yield node;
-      }
-    }
-    /**
-     * The function returns an iterator that yields key-value pairs from the object.
-     */
-    *entries() {
-      for (const item of this) {
-        yield item;
-      }
-    }
-    /**
-     * The function `keys()` returns an iterator that yields all the keys of the object.
-     */
-    *keys() {
-      for (const [key] of this) {
-        yield key;
-      }
-    }
-    *values() {
-      for (const [, value] of this) {
-        yield value;
-      }
-    }
-    /**
-     * The `every` function checks if every element in a HashMap satisfies 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 test each element in the map against a condition. If the predicate
-     * function returns false for any element, the every() method will return false. If the predicate
-     * function returns true for all
-     * @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 method is returning a boolean value. It returns true if the predicate function
-     * returns true for every element in the map, and false otherwise.
-     */
-    every(predicate, thisArg) {
-      let index = 0;
-      for (const [key, value] of this) {
-        if (!predicate.call(thisArg, value, key, index++, this)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    /**
-     * The "some" function checks if at least one element in a HashMap satisfies a given predicate.
-     * @param predicate - The `predicate` parameter is a function that takes four arguments: `value`,
-     * `key`, `index`, and `map`. It is used to determine whether a specific condition is met for a given
-     * key-value pair in the `HashMap`.
-     * @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 a boolean value. It returns true if the predicate function returns true for any element
-     * in the map, and false otherwise.
-     */
-    some(predicate, thisArg) {
-      let index = 0;
-      for (const [key, value] of this) {
-        if (predicate.call(thisArg, value, key, index++, this)) {
-          return true;
-        }
-      }
-      return false;
-    }
-    /**
-     * The `forEach` function iterates over the elements of a HashMap and applies a callback function to
-     * each element.
-     * @param callbackfn - A 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 inside the `callbackfn` function. If `thisArg
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    forEach(callbackfn, thisArg) {
-      let index = 0;
-      for (const [key, value] of this) {
-        callbackfn.call(thisArg, value, key, index++, this);
-      }
-    }
     /**
+     * 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
@@ -747,6 +978,13 @@ var dataStructureTyped = (() => {
       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,
@@ -769,27 +1007,20 @@ var dataStructureTyped = (() => {
       }
       return filteredMap;
     }
+    print() {
+      console.log([...this.entries()]);
+    }
     /**
-     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
-     * each element, accumulating a single value.
-     * @param callbackfn - The callback function that will be called for each element in the HashMap. It
-     * takes five parameters:
-     * @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 of the callback function when reducing the
-     * elements of the map.
-     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
-     * all the elements in the `HashMap`.
+     * The function returns an iterator that yields key-value pairs from both an object store and an
+     * object map.
      */
-    reduce(callbackfn, initialValue) {
-      let accumulator = initialValue;
-      let index = 0;
-      for (const [key, value] of this) {
-        accumulator = callbackfn(accumulator, value, key, index++, this);
+    *_getIterator() {
+      for (const node of Object.values(this._store)) {
+        yield [node.key, node.value];
+      }
+      for (const node of this._objMap) {
+        yield node;
       }
-      return accumulator;
-    }
-    print() {
-      console.log([...this.entries()]);
     }
     _isObjKey(key) {
       const keyType = typeof key;
@@ -810,11 +1041,12 @@ var dataStructureTyped = (() => {
       return strKey;
     }
   };
-  var LinkedHashMap = class _LinkedHashMap {
+  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");
@@ -946,18 +1178,6 @@ var dataStructureTyped = (() => {
         this.set(key, value);
       }
     }
-    keys() {
-      const keys = [];
-      for (const [key] of this)
-        keys.push(key);
-      return keys;
-    }
-    values() {
-      const values = [];
-      for (const [, value] of this)
-        values.push(value);
-      return values;
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -1080,35 +1300,29 @@ var dataStructureTyped = (() => {
       return cloned;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in a LinkedHashMap 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
-     * LinkedHashMap. It takes three arguments:
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    forEach(callback) {
-      let index = 0;
-      let node = this._head;
-      while (node !== this._sentinel) {
-        callback([node.key, node.value], index++, this);
-        node = node.next;
-      }
-    }
     /**
-     * The `filter` function takes a predicate function and returns a new LinkedHashMap 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 LinkedHashMap object that contains the key-value pairs from the original LinkedHashMap that
-     * satisfy the given predicate function.
+     * 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) {
+    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++;
@@ -1116,42 +1330,38 @@ var dataStructureTyped = (() => {
       return filteredMap;
     }
     /**
-     * The `map` function takes a callback function and returns a new LinkedHashMap 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 LinkedHashMap object with the values mapped according to the provided callback function.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    map(callback) {
+    /**
+     * 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, 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 LinkedHashMap 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 LinkedHashMap 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 LinkedHashMap 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 LinkedHashMap.
@@ -1159,16 +1369,13 @@ var dataStructureTyped = (() => {
      *
      * 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)
@@ -1207,11 +1414,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");
@@ -1793,54 +2001,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.
+     * 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) {
+    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++;
@@ -1852,21 +2037,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.
+     * 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) {
+    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;
@@ -1875,31 +2063,16 @@ 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++;
-      }
-      return accumulator;
-    }
     print() {
       console.log([...this]);
     }
+    *_getIterator() {
+      let current = this.head;
+      while (current) {
+        yield current.value;
+        current = current.next;
+      }
+    }
   };
 
   // src/data-structures/linked-list/doubly-linked-list.ts
@@ -1918,11 +2091,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");
@@ -2558,54 +2732,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.
+     * 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) {
+    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++;
@@ -2617,54 +2768,48 @@ 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;
-    }
-    /**
-     * 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++;
-      }
-      return accumulator;
+      return mappedList;
     }
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
+     */
     print() {
       console.log([...this]);
     }
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
+    *_getIterator() {
+      let current = this.head;
+      while (current) {
+        yield current.value;
+        current = current.next;
+      }
+    }
   };
 
   // src/data-structures/linked-list/skip-linked-list.ts
@@ -2916,7 +3061,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
@@ -2924,6 +3069,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) {
@@ -3049,92 +3195,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
@@ -3142,6 +3274,7 @@ var dataStructureTyped = (() => {
      * initialized as an empty array.
      */
     constructor(elements) {
+      super();
       __publicField(this, "_nodes");
       __publicField(this, "_offset");
       this._nodes = elements || [];
@@ -3363,31 +3496,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)
@@ -3396,18 +3504,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++;
@@ -3422,33 +3535,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.
+     * 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) {
+    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.
@@ -3459,6 +3608,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);
@@ -4086,42 +4236,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)
@@ -4130,18 +4244,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++;
@@ -4156,48 +4275,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.
+     * The above function is an implementation of the iterator protocol in TypeScript, allowing the
+     * object to be iterated over using a for...of loop.
      */
-    reduce(callback, initialValue) {
-      let accumulator = initialValue;
-      let index = 0;
-      for (const el of this) {
-        accumulator = callback(accumulator, el, index, this);
-        index++;
+    *_getIterator() {
+      for (let i = 0; i < this.size; ++i) {
+        yield this.getAt(i);
       }
-      return accumulator;
-    }
-    print() {
-      console.log([...this]);
     }
     /**
      * Time Complexity: O(n)
@@ -4428,8 +4541,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) => {
@@ -4724,47 +4838,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)
@@ -4772,6 +4909,11 @@ var dataStructureTyped = (() => {
     print() {
       console.log([...this]);
     }
+    *_getIterator() {
+      for (const element of this.elements) {
+        yield element;
+      }
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -5278,8 +5420,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() {
@@ -6236,46 +6379,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)) {
@@ -7206,6 +7370,11 @@ var dataStructureTyped = (() => {
   })(RBTNColor || {});
 
   // src/types/common.ts
+  var BSTVariant = /* @__PURE__ */ ((BSTVariant2) => {
+    BSTVariant2["MIN"] = "MIN";
+    BSTVariant2["MAX"] = "MAX";
+    return BSTVariant2;
+  })(BSTVariant || {});
   var CP = /* @__PURE__ */ ((CP2) => {
     CP2["lt"] = "lt";
     CP2["eq"] = "eq";
@@ -7259,7 +7428,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
@@ -7270,20 +7439,28 @@ var dataStructureTyped = (() => {
      * required.
      */
     constructor(elements, options) {
+      super();
       __publicField(this, "iterationType", "ITERATIVE" /* ITERATIVE */);
+      __publicField(this, "_extractor", (key) => Number(key));
       __publicField(this, "_root");
       __publicField(this, "_size");
       __publicField(this, "_defaultOneParamCallback", (node) => node.key);
       if (options) {
-        const { iterationType } = options;
+        const { iterationType, extractor } = options;
         if (iterationType) {
           this.iterationType = iterationType;
         }
+        if (extractor) {
+          this._extractor = extractor;
+        }
       }
       this._size = 0;
       if (elements)
         this.addMany(elements);
     }
+    get extractor() {
+      return this._extractor;
+    }
     get root() {
       return this._root;
     }
@@ -7292,7 +7469,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
-     * @param {BTNKey} key - The key for the new node.
+     * @param {K} key - The key for the new node.
      * @param {V} value - The value for the new node.
      * @returns {N} - The newly created BinaryTreeNode.
      */
@@ -7311,7 +7488,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V,N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the class N.
      */
     isNode(exemplar) {
@@ -7320,7 +7497,7 @@ var dataStructureTyped = (() => {
     /**
      * The function `exemplarToNode` converts an exemplar of a binary tree node into an actual node
      * object.
-     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing the exemplar parameter of the
+     * @param exemplar - BTNodeExemplar<K, V,N> - A generic type representing the exemplar parameter of the
      * function. It can be any type.
      * @returns a value of type `N` (which represents a node), or `null`, or `undefined`.
      */
@@ -7341,7 +7518,7 @@ var dataStructureTyped = (() => {
         }
       } else if (this.isNode(exemplar)) {
         node = exemplar;
-      } else if (this.isNodeKey(exemplar)) {
+      } else if (this.isNotNodeInstance(exemplar)) {
         node = this.createNode(exemplar);
       } else {
         return;
@@ -7350,7 +7527,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param kne - BTNodeExemplar<V, N> - A generic type representing a node in a binary tree. It has
+     * @param kne - BTNodeExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
      * two type parameters V and N, representing the value and node type respectively.
      * @returns a boolean value.
      */
@@ -7416,7 +7593,7 @@ var dataStructureTyped = (() => {
      * The function `addMany` takes in an iterable of `BTNodeExemplar` objects, adds each object to the
      * current instance, and returns an array of the inserted nodes.
      * @param nodes - The `nodes` parameter is an iterable (such as an array or a set) of
-     * `BTNodeExemplar<V, N>` objects.
+     * `BTNodeExemplar<K, V,N>` objects.
      * @returns The function `addMany` returns an array of values, where each value is either of type
      * `N`, `null`, or `undefined`.
      */
@@ -7511,11 +7688,11 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function calculates the depth of a given node in a binary tree.
-     * @param {BTNKey | N | null | undefined} distNode - The `distNode` parameter represents the node in
-     * the binary tree whose depth we want to find. It can be of type `BTNKey`, `N`, `null`, or
+     * @param {K | N | null | undefined} distNode - The `distNode` parameter represents the node in
+     * the binary tree whose depth we want to find. It can be of type `K`, `N`, `null`, or
      * `undefined`.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
-     * from which we want to calculate the depth. It can be either a `BTNKey` (binary tree node key) or
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
      * `N` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
      * @returns the depth of the `distNode` relative to the `beginRoot`.
      */
@@ -7542,9 +7719,9 @@ var dataStructureTyped = (() => {
      *
      * The function `getHeight` calculates the maximum height of a binary tree using either recursive or
      * iterative traversal.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node of the binary tree from which we want to calculate the height. It can be of type
-     * `BTNKey`, `N`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
+     * `K`, `N`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
      * @param iterationType - The `iterationType` parameter is used to determine whether to calculate the
      * height of the tree using a recursive approach or an iterative approach. It can have two possible
      * values:
@@ -7588,9 +7765,9 @@ var dataStructureTyped = (() => {
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node of the binary tree from which we want to calculate the minimum height. It can be of
-     * type `BTNKey`, `N`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
+     * type `K`, `N`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
      * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
@@ -7648,8 +7825,8 @@ var dataStructureTyped = (() => {
      *
      * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
      * height of the tree.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for calculating the height and minimum height of a binary tree. It can be either a `BTNKey` (a key
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for calculating the height and minimum height of a binary tree. It can be either a `K` (a key
      * value of a binary tree node), `N` (a node of a binary tree), `null`, or `undefined`. If
      * @returns a boolean value.
      */
@@ -7674,7 +7851,7 @@ var dataStructureTyped = (() => {
      * matches the identifier. If set to true, the function will stop iterating once it finds a matching
      * node and return that node. If set to false (default), the function will continue iterating and
      * return all nodes that match the identifier.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node for the traversal. It can be either a key, a node object, or `null`/`undefined`. If
      * it is `null` or `undefined`, an empty array will be returned.
      * @param iterationType - The `iterationType` parameter determines the type of iteration used to
@@ -7730,8 +7907,8 @@ var dataStructureTyped = (() => {
      * the binary tree. It is used to filter the nodes based on certain conditions. The `callback`
      * function should return a boolean value indicating whether the node should be included in the
      * result or not.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for the search in the binary tree. It can be specified as a `BTNKey` (a unique identifier for a
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
      * node in the binary tree), a node object (`N`), or `null`/`undefined` to start the search from
      * @param iterationType - The `iterationType` parameter is a variable that determines the type of
      * iteration to be performed on the binary tree. It is used to specify whether the iteration should
@@ -7756,7 +7933,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
      * function should take a single parameter of type `N` (the type of the nodes in the binary tree) and
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
      * for searching the binary tree. It can be either a key value, a node object, or `null`/`undefined`.
      * If `null` or `undefined` is passed, the search will start from the root of the binary tree.
      * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
@@ -7780,7 +7957,7 @@ var dataStructureTyped = (() => {
      *
      * The function `getNodeByKey` searches for a node in a binary tree by its key, using either
      * recursive or iterative iteration.
-     * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
      * It is used to find the node with the matching key value.
      * @param iterationType - The `iterationType` parameter is used to determine whether the search for
      * the node with the given key should be performed iteratively or recursively. It has two possible
@@ -7823,7 +8000,7 @@ var dataStructureTyped = (() => {
     /**
      * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
-     * @param {BTNKey | N | null | undefined} key - The `key` parameter can be of type `BTNKey`, `N`,
+     * @param {K | N | null | undefined} key - The `key` parameter can be of type `K`, `N`,
      * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be used when searching for a node by key. It has a default value of
@@ -7832,7 +8009,7 @@ var dataStructureTyped = (() => {
      * itself if it is not a valid node key.
      */
     ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
-      return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
+      return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
      * Time Complexity: O(n)
@@ -7847,8 +8024,8 @@ var dataStructureTyped = (() => {
      * the binary tree. It is used to determine whether a node matches the given identifier. The callback
      * function should return a value that can be compared to the identifier to determine if it is a
      * match.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for the search in the binary tree. It can be specified as a `BTNKey` (a unique identifier for a
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
      * node), a node object of type `N`, or `null`/`undefined` to start the search from the root of
      * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
      * be performed when searching for a node in the binary tree. It is an optional parameter with a
@@ -7886,8 +8063,8 @@ var dataStructureTyped = (() => {
      *
      * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
      * structure, with the option to reverse the order of the nodes.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node from which you want to find the path to the root. It can be of type `BTNKey`, `N`,
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node from which you want to find the path to the root. It can be of type `K`, `N`,
      * `null`, or `undefined`.
      * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
      * resulting path should be reversed or not. If `isReverse` is set to `true`, the path will be
@@ -7916,8 +8093,8 @@ var dataStructureTyped = (() => {
      *
      * The function `getLeftMost` returns the leftmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for finding the leftmost node in a binary tree. It can be either a `BTNKey` (a key value), `N` (a
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for finding the leftmost node in a binary tree. It can be either a `K` (a key value), `N` (a
      * node), `null`, or `undefined`. If not provided, it defaults to `this.root`,
      * @param iterationType - The `iterationType` parameter is used to determine the type of iteration to
      * be performed when finding the leftmost node in a binary tree. It can have two possible values:
@@ -7954,8 +8131,8 @@ var dataStructureTyped = (() => {
      *
      * The function `getRightMost` returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node from which we want to find the rightmost node. It can be of type `BTNKey`, `N`,
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node from which we want to find the rightmost node. It can be of type `K`, `N`,
      * `null`, or `undefined`. If not provided, it defaults to `this.root`, which is a property of the
      * current object.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
@@ -7992,7 +8169,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `isSubtreeBST` checks if a given binary tree is a valid binary search tree.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the root
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the root
      * node of the binary search tree (BST) that you want to check if it is a subtree of another BST.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when checking if a subtree is a binary search tree (BST). It can have two
@@ -8007,9 +8184,10 @@ var dataStructureTyped = (() => {
         const dfs = (cur, min, max) => {
           if (!cur)
             return true;
-          if (cur.key <= min || cur.key >= max)
+          const numKey = this.extractor(cur.key);
+          if (numKey <= min || numKey >= max)
             return false;
-          return dfs(cur.left, min, cur.key) && dfs(cur.right, cur.key, max);
+          return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
         };
         return dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
       } else {
@@ -8021,9 +8199,10 @@ var dataStructureTyped = (() => {
             curr = curr.left;
           }
           curr = stack.pop();
-          if (!curr || prev >= curr.key)
+          const numKey = this.extractor(curr.key);
+          if (!curr || prev >= numKey)
             return false;
-          prev = curr.key;
+          prev = numKey;
           curr = curr.right;
         }
         return true;
@@ -8058,8 +8237,8 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the subtree traversal. It takes a single parameter, which is the current node being traversed, and
      * returns a value of any type.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node or key from which the subtree traversal should begin. It can be of type `BTNKey`,
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node or key from which the subtree traversal should begin. It can be of type `K`,
      * `N`, `null`, or `undefined`. If not provided, the `root` property of the current object is used as
      * the default value.
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
@@ -8138,13 +8317,13 @@ var dataStructureTyped = (() => {
       return this.isRealNode(node) || node === null;
     }
     /**
-     * The function "isNodeKey" checks if a potential key is a number.
+     * The function "isNotNodeInstance" checks if a potential key is a number.
      * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
-    isNodeKey(potentialKey) {
-      return typeof potentialKey === "number";
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof BinaryTreeNode);
     }
     /**
      * Time complexity: O(n)
@@ -8158,7 +8337,7 @@ var dataStructureTyped = (() => {
      * `null`, or `undefined`, and returns a value of any type. The default value for this parameter is
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
      * nodes are traversed during the depth-first search. It can have one of the following values:
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
      * for the depth-first search traversal. It can be specified as a key, a node object, or
      * `null`/`undefined`. If not provided, the `beginRoot` will default to the root node of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
@@ -8277,7 +8456,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the breadth-first search traversal. It takes a single parameter, which is the current node being
      * visited, and returns a value of any type.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node for the breadth-first search traversal. It can be specified as a key, a node object,
      * or `null`/`undefined` to indicate the root of the tree. If not provided, the `root` property of
      * the class is used as
@@ -8348,9 +8527,9 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the tree. It takes a single parameter, which can be of type `N`, `null`, or `undefined`, and
      * returns a value of any type.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node for traversing the tree. It can be either a node object (`N`), a key value
-     * (`BTNKey`), `null`, or `undefined`. If not provided, it defaults to the root node of the tree.
+     * (`K`), `null`, or `undefined`. If not provided, it defaults to the root node of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
      * performed on the tree. It can have two possible values:
      * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
@@ -8407,7 +8586,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function `getPredecessor` returns the predecessor node of a given node in a binary tree.
-     * @param {BTNKey | N | null | undefined} node - The `node` parameter can be of type `BTNKey`, `N`,
+     * @param {K | N | null | undefined} node - The `node` parameter can be of type `K`, `N`,
      * `null`, or `undefined`.
      * @returns The function `getPredecessor` returns a value of type `N | undefined`.
      */
@@ -8429,7 +8608,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function `getSuccessor` returns the next node in a binary tree given a current node.
-     * @param {BTNKey | N | null} [x] - The parameter `x` can be of type `BTNKey`, `N`, or `null`.
+     * @param {K | N | null} [x] - The parameter `x` can be of type `K`, `N`, or `null`.
      * @returns the successor of the given node or key. The successor is the node that comes immediately
      * after the given node in the inorder traversal of the binary tree.
      */
@@ -8458,7 +8637,7 @@ var dataStructureTyped = (() => {
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
      * determines the order in which the nodes of a binary tree are traversed. It can have one of the
      * following values:
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
      * for the traversal. It can be specified as a key, a node object, or `null`/`undefined` to indicate
      * the root of the tree. If no value is provided, the default value is the root of the tree.
      * @returns The function `morris` returns an array of values that are the result of invoking the
@@ -8546,43 +8725,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     *
-     * The function "keys" returns an array of keys from a given object.
-     * @returns an array of BTNKey objects.
-     */
-    keys() {
-      const keys = [];
-      for (const entry of this) {
-        keys.push(entry[0]);
-      }
-      return keys;
-    }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     *
-     * The function "values" returns an array of values from a map-like object.
-     * @returns The `values()` method is returning an array of values (`V`) from the entries in the
-     * object.
-     */
-    values() {
-      const values = [];
-      for (const entry of this) {
-        values.push(entry[1]);
-      }
-      return values;
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -8601,116 +8743,73 @@ var dataStructureTyped = (() => {
       return cloned;
     }
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(1)
-     */
-    /**
-     * The `forEach` function iterates over each entry in a tree and calls a callback function with the
-     * entry and the tree as arguments.
-     * @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)
      */
-    forEach(callback) {
-      for (const entry of this) {
-        callback(entry, this);
-      }
-    }
     /**
-     * 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)
+     *
+     * 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) {
+    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: [K, 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 |
+     * @param {K | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * following types:
      * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
@@ -8737,6 +8836,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(this.extractor(current.key))) {
+            stack.push(current);
+            current = current.left;
+          }
+          current = stack.pop();
+          if (current && !isNaN(this.extractor(current.key))) {
+            yield [current.key, current.value];
+            current = current.right;
+          }
+        }
+      } else {
+        if (node.left && !isNaN(this.extractor(node.key))) {
+          yield* __yieldStar(this[Symbol.iterator](node.left));
+        }
+        yield [node.key, node.value];
+        if (node.right && !isNaN(this.extractor(node.key))) {
+          yield* __yieldStar(this[Symbol.iterator](node.right));
+        }
+      }
+    }
     _displayAux(node, options) {
       const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
       const emptyDisplayLayout = [["\u2500"], 1, 0, 0];
@@ -8744,10 +8870,10 @@ var dataStructureTyped = (() => {
         return emptyDisplayLayout;
       } else if (node === void 0 && !isShowUndefined) {
         return emptyDisplayLayout;
-      } else if (node !== null && node !== void 0 && isNaN(node.key) && !isShowRedBlackNIL) {
+      } else if (node !== null && node !== void 0 && isNaN(this.extractor(node.key)) && !isShowRedBlackNIL) {
         return emptyDisplayLayout;
       } else if (node !== null && node !== void 0) {
-        const key = node.key, line = isNaN(key) ? "S" : key.toString(), width = line.length;
+        const key = node.key, line = isNaN(this.extractor(key)) ? "S" : this.extractor(key).toString(), width = line.length;
         return _buildNodeDisplay(line, width, this._displayAux(node.left, options), this._displayAux(node.right, options));
       } else {
         const line = node === void 0 ? "U" : "N", width = line.length;
@@ -8825,7 +8951,7 @@ var dataStructureTyped = (() => {
      * If the parent node is null, the function also returns undefined.
      */
     _addTo(newNode, parent) {
-      if (this.isNodeKey(parent))
+      if (this.isNotNodeInstance(parent))
         parent = this.getNode(parent);
       if (parent) {
         if (parent.left === void 0) {
@@ -8917,11 +9043,11 @@ var dataStructureTyped = (() => {
     constructor(elements, options) {
       super([], options);
       __publicField(this, "_root");
-      __publicField(this, "comparator", (a, b) => a - b);
+      __publicField(this, "_variant", "MIN" /* MIN */);
       if (options) {
-        const { comparator } = options;
-        if (comparator) {
-          this.comparator = comparator;
+        const { variant } = options;
+        if (variant) {
+          this._variant = variant;
         }
       }
       this._root = void 0;
@@ -8931,9 +9057,12 @@ var dataStructureTyped = (() => {
     get root() {
       return this._root;
     }
+    get variant() {
+      return this._variant;
+    }
     /**
      * The function creates a new binary search tree node with the given key and value.
-     * @param {BTNKey} key - The key parameter is the key value that will be associated with
+     * @param {K} key - The key parameter is the key value that will be associated with
      * the new node. It is used to determine the position of the node in the binary search tree.
      * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It
      * represents the value associated with the node in a binary search tree.
@@ -8952,12 +9081,12 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _BST([], __spreadValues({
         iterationType: this.iterationType,
-        comparator: this.comparator
+        variant: this.variant
       }, options));
     }
     /**
      * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
      */
     isNode(exemplar) {
@@ -8966,7 +9095,7 @@ var dataStructureTyped = (() => {
     /**
      * The function `exemplarToNode` takes an exemplar and returns a corresponding node if the exemplar
      * is valid, otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a variable `node` which is of type `N` or `undefined`.
      */
     exemplarToNode(exemplar) {
@@ -8982,7 +9111,7 @@ var dataStructureTyped = (() => {
         } else {
           node = this.createNode(key, value);
         }
-      } else if (this.isNodeKey(exemplar)) {
+      } else if (this.isNotNodeInstance(exemplar)) {
         node = this.createNode(exemplar);
       } else {
         return;
@@ -9079,17 +9208,17 @@ var dataStructureTyped = (() => {
       sorted = realBTNExemplars.sort((a, b) => {
         let aR, bR;
         if (this.isEntry(a))
-          aR = a[0];
+          aR = this.extractor(a[0]);
         else if (this.isRealNode(a))
-          aR = a.key;
+          aR = this.extractor(a.key);
         else
-          aR = a;
+          aR = this.extractor(a);
         if (this.isEntry(b))
-          bR = b[0];
+          bR = this.extractor(b[0]);
         else if (this.isRealNode(b))
-          bR = b.key;
+          bR = this.extractor(b.key);
         else
-          bR = b;
+          bR = this.extractor(b);
         return aR - bR;
       });
       const _dfs = (arr) => {
@@ -9125,34 +9254,31 @@ var dataStructureTyped = (() => {
       }
       return inserted;
     }
-    /**
-     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
-     */
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
-     *
-     * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
-     * leftmost node if the comparison result is greater than.
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `BTNKey`, `N`, or `undefined`. It represents the starting point for finding the last key in
-     * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed. It can have one of the following values:
-     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
-     * the key of the leftmost node if the comparison result is greater than, and the key of the
-     * rightmost node otherwise. If no node is found, it returns 0.
-     */
-    lastKey(beginRoot = this.root, iterationType = this.iterationType) {
-      var _a, _b, _c, _d, _e, _f;
-      if (this._compare(0, 1) === "lt" /* lt */)
-        return (_b = (_a = this.getRightMost(beginRoot, iterationType)) == null ? void 0 : _a.key) != null ? _b : 0;
-      else if (this._compare(0, 1) === "gt" /* gt */)
-        return (_d = (_c = this.getLeftMost(beginRoot, iterationType)) == null ? void 0 : _c.key) != null ? _d : 0;
-      else
-        return (_f = (_e = this.getRightMost(beginRoot, iterationType)) == null ? void 0 : _e.key) != null ? _f : 0;
-    }
+    // /**
+    //  * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
+    //  * Space Complexity: O(n) - Additional space is required for the sorted array.
+    //  */
+    //
+    // /**
+    //  * Time Complexity: O(log n) - Average case for a balanced tree.
+    //  * Space Complexity: O(1) - Constant space is used.
+    //  *
+    //  * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
+    //  * leftmost node if the comparison result is greater than.
+    //  * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
+    //  * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
+    //  * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
+    //  * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+    //  * be performed. It can have one of the following values:
+    //  * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
+    //  * the key of the leftmost node if the comparison result is greater than, and the key of the
+    //  * rightmost node otherwise. If no node is found, it returns 0.
+    //  */
+    // lastKey(beginRoot: BSTNodeKeyOrNode<K,N> = this.root, iterationType = this.iterationType): K {
+    //   if (this._compare(0, 1) === CP.lt) return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
+    //   else if (this._compare(0, 1) === CP.gt) return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
+    //   else return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
+    // }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.
@@ -9163,7 +9289,7 @@ var dataStructureTyped = (() => {
      *
      * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
      * either recursive or iterative methods.
-     * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
      * It is used to identify the node that we want to retrieve.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when searching for a node in the binary tree. It can have two possible
@@ -9208,14 +9334,14 @@ var dataStructureTyped = (() => {
     /**
      * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
      * otherwise it returns the key itself.
-     * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
+     * @param {K | N | undefined} key - The `key` parameter can be of type `K`, `N`, or
      * `undefined`.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
     ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
-      return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
+      return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
@@ -9233,7 +9359,7 @@ var dataStructureTyped = (() => {
      * first node that matches the identifier. If set to true, the function will return an array
      * containing only the first matching node. If set to false (default), the function will continue
      * searching for all nodes that match the identifier and return an array containing
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
      * for the traversal. It can be either a key value or a node object. If it is undefined, the
      * traversal will start from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
@@ -9308,7 +9434,7 @@ var dataStructureTyped = (() => {
      * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It is of type
      * `CP`, which is a custom type representing the comparison operator. The possible values for
      * `lesserOrGreater` are
-     * @param {BTNKey | N | undefined} targetNode - The `targetNode` parameter represents the node in the
+     * @param {K | N | undefined} targetNode - The `targetNode` parameter represents the node in the
      * binary tree that you want to traverse from. It can be specified either by its key, by the node
      * object itself, or it can be left undefined to start the traversal from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
@@ -9480,19 +9606,16 @@ var dataStructureTyped = (() => {
     /**
      * The function compares two values using a comparator function and returns whether the first value
      * is greater than, less than, or equal to the second value.
-     * @param {BTNKey} a - The parameter "a" is of type BTNKey.
-     * @param {BTNKey} b - The parameter "b" in the above code represents a BTNKey.
+     * @param {K} a - The parameter "a" is of type K.
+     * @param {K} b - The parameter "b" in the above code represents a K.
      * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater
      * than), CP.lt (less than), or CP.eq (equal).
      */
     _compare(a, b) {
-      const compared = this.comparator(a, b);
-      if (compared > 0)
-        return "gt" /* gt */;
-      else if (compared < 0)
-        return "lt" /* lt */;
-      else
-        return "eq" /* eq */;
+      const extractedA = this.extractor(a);
+      const extractedB = this.extractor(b);
+      const compared = this.variant === "MIN" /* MIN */ ? extractedA - extractedB : extractedB - extractedA;
+      return compared > 0 ? "gt" /* gt */ : compared < 0 ? "lt" /* lt */ : "eq" /* eq */;
     }
   };
 
@@ -9933,7 +10056,7 @@ var dataStructureTyped = (() => {
   var AVLTree = class _AVLTree extends BST {
     /**
      * The constructor function initializes an AVLTree object with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
      * objects. It represents a collection of elements that will be added to the AVL tree during
      * initialization.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
@@ -9947,7 +10070,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
-     * @param {BTNKey} key - The key parameter is the key value that will be associated with
+     * @param {K} key - The key parameter is the key value that will be associated with
      * the new node. It is used to determine the position of the node in the binary search tree.
      * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It is of
      * type `V`, which means it can be any value that is assignable to the `value` property of the
@@ -9967,12 +10090,12 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _AVLTree([], __spreadValues({
         iterationType: this.iterationType,
-        comparator: this.comparator
+        variant: this.variant
       }, options));
     }
     /**
      * The function checks if an exemplar is an instance of AVLTreeNode.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
      */
     isNode(exemplar) {
@@ -10033,9 +10156,9 @@ var dataStructureTyped = (() => {
     /**
      * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
      * tree.
-     * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node that
-     * needs to be swapped with the destination node. It can be of type `BTNKey`, `N`, or `undefined`.
-     * @param {BTNKey | N  | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node that
+     * needs to be swapped with the destination node. It can be of type `K`, `N`, or `undefined`.
+     * @param {K | N  | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
@@ -10347,7 +10470,7 @@ var dataStructureTyped = (() => {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -10372,7 +10495,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
-     * @param {BTNKey} key - The key parameter is the key value associated with the node. It is used to
+     * @param {K} key - The key parameter is the key value associated with the node. It is used to
      * identify and compare nodes in the Red-Black Tree.
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
      * associated with the node. It is of type `V`, which is a generic type that can be replaced with any
@@ -10395,12 +10518,12 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _RedBlackTree([], __spreadValues({
         iterationType: this.iterationType,
-        comparator: this.comparator
+        variant: this.variant
       }, options));
     }
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
@@ -10410,7 +10533,7 @@ var dataStructureTyped = (() => {
     /**
      * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
      * otherwise it returns undefined.
-     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing an exemplar of a binary tree
+     * @param exemplar - BTNodeExemplar<K, V, N> - A generic type representing an exemplar of a binary tree
      * node. It can be either a node itself, an entry (key-value pair), a node key, or any other value
      * that is not a valid exemplar.
      * @returns a variable `node` which is of type `N | undefined`.
@@ -10428,7 +10551,7 @@ var dataStructureTyped = (() => {
         } else {
           node = this.createNode(key, value, 1 /* RED */);
         }
-      } else if (this.isNodeKey(exemplar)) {
+      } else if (this.isNotNodeInstance(exemplar)) {
         node = this.createNode(exemplar, void 0, 1 /* RED */);
       } else {
         return;
@@ -10584,7 +10707,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
      * function should take a single parameter of type `N` (the type of the nodes in the binary tree) and
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter is the starting point for
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is the starting point for
      * searching for a node in a binary tree. It can be either a key value or a node object. If it is not
      * provided, the search will start from the root of the binary tree.
      * @param iterationType - The `iterationType` parameter is a variable that determines the type of
@@ -10891,7 +11014,7 @@ var dataStructureTyped = (() => {
   var TreeMultimapNode = class extends AVLTreeNode {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
-     * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
+     * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
      * of the binary tree node.
      * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
      * tree node. If no value is provided, it will be `undefined`.
@@ -10920,7 +11043,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function creates a new BSTNode with the given key, value, and count.
-     * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
+     * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
      * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
@@ -10933,12 +11056,12 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _TreeMultimap([], __spreadValues({
         iterationType: this.iterationType,
-        comparator: this.comparator
+        variant: this.variant
       }, options));
     }
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
@@ -10947,7 +11070,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`, where `V` represents
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where `V` represents
      * the value type and `N` represents the node type.
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
      * times the node should be created. If not provided, it defaults to 1.
@@ -10966,7 +11089,7 @@ var dataStructureTyped = (() => {
         } else {
           node = this.createNode(key, value, count);
         }
-      } else if (this.isNodeKey(exemplar)) {
+      } else if (this.isNotNodeInstance(exemplar)) {
         node = this.createNode(exemplar, void 0, count);
       } else {
         return;
@@ -11178,9 +11301,9 @@ var dataStructureTyped = (() => {
      * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
      * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
      * `undefined` if there is no node to add.
-     * @param {BTNKey | N | undefined} parent - The `parent` parameter represents the parent node to
+     * @param {K | N | undefined} parent - The `parent` parameter represents the parent node to
      * which the new node will be added as a child. It can be either a node object (`N`) or a key value
-     * (`BTNKey`).
+     * (`K`).
      * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
      * added, or `undefined` if no node was added.
      */
@@ -11210,9 +11333,9 @@ var dataStructureTyped = (() => {
     }
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-     * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
-     * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
-     * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
+     * which the values will be swapped. It can be of type `K`, `N`, or `undefined`.
+     * @param {K | N | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
@@ -11890,8 +12013,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");
@@ -12186,56 +12310,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.