data-structure-typed 1.46.2 → 1.46.4

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

@@ -100,10 +100,7 @@ var dataStructureTyped = (() => {
     BinaryTreeNode: () => BinaryTreeNode,
     CP: () => CP,
     Character: () => Character,
-    CoordinateMap: () => CoordinateMap,
-    CoordinateSet: () => CoordinateSet,
     Deque: () => Deque,
-    DequeIterator: () => DequeIterator,
     DirectedEdge: () => DirectedEdge,
     DirectedGraph: () => DirectedGraph,
     DirectedVertex: () => DirectedVertex,
@@ -113,7 +110,6 @@ var dataStructureTyped = (() => {
     FibonacciHeap: () => FibonacciHeap,
     FibonacciHeapNode: () => FibonacciHeapNode,
     HashMap: () => HashMap,
-    HashMapIterator: () => HashMapIterator,
     HashTable: () => HashTable,
     HashTableNode: () => HashTableNode,
     Heap: () => Heap,
@@ -144,11 +140,9 @@ var dataStructureTyped = (() => {
     SkipListNode: () => SkipListNode,
     Stack: () => Stack,
     THUNK_SYMBOL: () => THUNK_SYMBOL,
-    TreeMap: () => TreeMap,
     TreeMultimap: () => TreeMultimap,
     TreeMultimapNode: () => TreeMultimapNode,
     TreeNode: () => TreeNode,
-    TreeSet: () => TreeSet,
     Trie: () => Trie,
     TrieNode: () => TrieNode,
     UndirectedEdge: () => UndirectedEdge,
@@ -158,8 +152,8 @@ var dataStructureTyped = (() => {
     arrayRemove: () => arrayRemove,
     calcMinUnitsRequired: () => calcMinUnitsRequired,
     getMSB: () => getMSB,
-    isObjOrFunc: () => isObjOrFunc,
     isThunk: () => isThunk,
+    isWeakKey: () => isWeakKey,
     rangeCheck: () => rangeCheck,
     throwRangeError: () => throwRangeError,
     toThunk: () => toThunk,
@@ -390,110 +384,6 @@ var dataStructureTyped = (() => {
   __publicField(_HashTable, "LOAD_FACTOR", 0.75);
   var HashTable = _HashTable;
 
-  // src/data-structures/hash/coordinate-map.ts
-  var CoordinateMap = class extends Map {
-    constructor(joint) {
-      super();
-      __publicField(this, "_joint", "_");
-      if (joint !== void 0)
-        this._joint = joint;
-    }
-    get joint() {
-      return this._joint;
-    }
-    /**
-     * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
-     * key array with a specified delimiter.
-     * @param {number[]} key - The parameter "key" is an array of numbers.
-     * @returns The `has` method is being overridden to return the result of calling the `has` method of the superclass
-     * (`super.has`) with the `key` array joined together using the `_joint` property.
-     */
-    has(key) {
-      return super.has(key.join(this._joint));
-    }
-    /**
-     * The function overrides the set method of a Map object to convert the key from an array to a string using a specified
-     * delimiter before calling the original set method.
-     * @param {number[]} key - The key parameter is an array of numbers.
-     * @param {V} value - The value parameter is the value that you want to associate with the specified key.
-     * @returns The `set` method is returning the result of calling the `set` method of the superclass
-     * (`super.set(key.join(this._joint), value)`).
-     */
-    set(key, value) {
-      return super.set(key.join(this._joint), value);
-    }
-    /**
-     * The function overrides the get method to join the key array with a specified joint and then calls the super get
-     * method.
-     * @param {number[]} key - An array of numbers
-     * @returns The code is returning the value associated with the specified key in the map.
-     */
-    get(key) {
-      return super.get(key.join(this._joint));
-    }
-    /**
-     * The function overrides the delete method and joins the key array using a specified joint character before calling
-     * the super delete method.
-     * @param {number[]} key - An array of numbers that represents the key to be deleted.
-     * @returns The `delete` method is returning the result of calling the `delete` method on the superclass, with the
-     * `key` array joined together using the `_joint` property.
-     */
-    delete(key) {
-      return super.delete(key.join(this._joint));
-    }
-  };
-
-  // src/data-structures/hash/coordinate-set.ts
-  var CoordinateSet = class extends Set {
-    constructor(joint) {
-      super();
-      __publicField(this, "_joint", "_");
-      if (joint !== void 0)
-        this._joint = joint;
-    }
-    get joint() {
-      return this._joint;
-    }
-    /**
-     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
-     * joining its elements with a specified separator.
-     * @param {number[]} value - The parameter "value" is an array of numbers.
-     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
-     * in the joined value as an argument.
-     */
-    has(value) {
-      return super.has(value.join(this._joint));
-    }
-    /**
-     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
-     * specified delimiter before calling the parent class's "add" function.
-     * @param {number[]} value - An array of numbers
-     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
-     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
-     */
-    add(value) {
-      return super.add(value.join(this._joint));
-    }
-    /**
-     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
-     * array with a specified joint and then calling the delete method of the parent class.
-     * @param {number[]} value - An array of numbers
-     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
-     * `value` array joined together using the `_joint` property.
-     */
-    delete(value) {
-      return super.delete(value.join(this._joint));
-    }
-  };
-
-  // src/data-structures/hash/tree-map.ts
-  var TreeMap = class {
-  };
-
-  // src/data-structures/hash/tree-set.ts
-  var TreeSet = class {
-  };
-
   // src/utils/utils.ts
   var uuidV4 = function() {
     return "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".replace(/[x]/g, function(c) {
@@ -562,220 +452,46 @@ var dataStructureTyped = (() => {
   var throwRangeError = (message = "The value is off-limits.") => {
     throw new RangeError(message);
   };
-  var isObjOrFunc = (input) => {
+  var isWeakKey = (input) => {
     const inputType = typeof input;
     return inputType === "object" && input !== null || inputType === "function";
   };
   var calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
 
-  // src/types/data-structures/binary-tree/binary-tree.ts
-  var IterationType = /* @__PURE__ */ ((IterationType3) => {
-    IterationType3["ITERATIVE"] = "ITERATIVE";
-    IterationType3["RECURSIVE"] = "RECURSIVE";
-    return IterationType3;
-  })(IterationType || {});
-  var FamilyPosition = /* @__PURE__ */ ((FamilyPosition2) => {
-    FamilyPosition2["ROOT"] = "ROOT";
-    FamilyPosition2["LEFT"] = "LEFT";
-    FamilyPosition2["RIGHT"] = "RIGHT";
-    FamilyPosition2["ROOT_LEFT"] = "ROOT_LEFT";
-    FamilyPosition2["ROOT_RIGHT"] = "ROOT_RIGHT";
-    FamilyPosition2["ISOLATED"] = "ISOLATED";
-    FamilyPosition2["MAL_NODE"] = "MAL_NODE";
-    return FamilyPosition2;
-  })(FamilyPosition || {});
-
-  // src/types/data-structures/binary-tree/rb-tree.ts
-  var RBTNColor = /* @__PURE__ */ ((RBTNColor2) => {
-    RBTNColor2[RBTNColor2["RED"] = 1] = "RED";
-    RBTNColor2[RBTNColor2["BLACK"] = 0] = "BLACK";
-    return RBTNColor2;
-  })(RBTNColor || {});
-
-  // src/types/helpers.ts
-  var CP = /* @__PURE__ */ ((CP2) => {
-    CP2["lt"] = "lt";
-    CP2["eq"] = "eq";
-    CP2["gt"] = "gt";
-    return CP2;
-  })(CP || {});
-  var IterateDirection = /* @__PURE__ */ ((IterateDirection2) => {
-    IterateDirection2[IterateDirection2["DEFAULT"] = 0] = "DEFAULT";
-    IterateDirection2[IterateDirection2["REVERSE"] = 1] = "REVERSE";
-    return IterateDirection2;
-  })(IterateDirection || {});
-
   // src/data-structures/hash/hash-map.ts
-  var HashMapIterator = class _HashMapIterator {
-    /**
-     * This is a constructor function for a linked list iterator in a HashMap data structure.
-     * @param node - The `node` parameter is a reference to a `HashMapLinkedNode` object. This object
-     * represents a node in a linked list used in a hash map data structure. It contains a key-value pair
-     * and references to the previous and next nodes in the linked list.
-     * @param sentinel - The `sentinel` parameter is a reference to a special node in a linked list. It
-     * is used to mark the beginning or end of the list and is typically used in data structures like
-     * hash maps or linked lists to simplify operations and boundary checks.
-     * @param hashMap - A HashMap object that stores key-value pairs.
-     * @param {IterateDirection} iterateDirection - The `iterateDirection` parameter is an optional
-     * parameter that specifies the direction in which the iterator should iterate over the elements of
-     * the HashMap. It can take one of the following values:
-     * @returns The constructor does not return anything. It is used to initialize the properties and
-     * methods of the object being created.
-     */
-    constructor(node, sentinel, hashMap, iterateDirection = 0 /* DEFAULT */) {
-      __publicField(this, "hashMap");
-      __publicField(this, "iterateDirection");
-      __publicField(this, "_node");
-      __publicField(this, "_sentinel");
-      this._node = node;
-      this._sentinel = sentinel;
-      this.iterateDirection = iterateDirection;
-      if (this.iterateDirection === 0 /* DEFAULT */) {
-        this.prev = function() {
-          if (this._node.prev === this._sentinel) {
-            throwRangeError();
-          }
-          this._node = this._node.prev;
-          return this;
-        };
-        this.next = function() {
-          if (this._node === this._sentinel) {
-            throwRangeError();
-          }
-          this._node = this._node.next;
-          return this;
-        };
-      } else {
-        this.prev = function() {
-          if (this._node.next === this._sentinel) {
-            throwRangeError();
-          }
-          this._node = this._node.next;
-          return this;
-        };
-        this.next = function() {
-          if (this._node === this._sentinel) {
-            throwRangeError();
-          }
-          this._node = this._node.prev;
-          return this;
-        };
-      }
-      this.hashMap = hashMap;
-    }
+  var HashMap = class _HashMap {
     /**
-     * The above function returns a Proxy object that allows access to the key and value of a node in a
-     * data structure.
-     * @returns The code is returning a Proxy object.
-     */
-    get current() {
-      if (this._node === this._sentinel) {
-        throwRangeError();
-      }
-      return new Proxy([], {
-        get: (target, prop) => {
-          if (prop === "0")
-            return this._node.key;
-          else if (prop === "1")
-            return this._node.value;
-          target[0] = this._node.key;
-          target[1] = this._node.value;
-          return target[prop];
-        },
-        set: (_, prop, newValue) => {
-          if (prop !== "1") {
-            throw new TypeError(`prop should be string '1'`);
-          }
-          this._node.value = newValue;
-          return true;
-        }
-      });
-    }
-    /**
-     * The function checks if a node is accessible.
-     * @returns a boolean value indicating whether the `_node` is not equal to the `_sentinel`.
+     * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
+     * @param options - The `options` parameter is an object that contains the `elements` property. The
+     * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
      */
-    isAccessible() {
-      return this._node !== this._sentinel;
-    }
-    prev() {
-      return this;
-    }
-    next() {
-      return this;
-    }
-    clone() {
-      return new _HashMapIterator(this._node, this._sentinel, this.hashMap, this.iterateDirection);
-    }
-  };
-  var HashMap = class {
-    /**
-     * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
-     * @param {Iterable<[K, V]>} elements - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
-     * V]>`. It is an array of key-value pairs, where each pair is represented as an array `[K, V]`. The
-     * `K` represents the type of the key and `V` represents the
-     */
-    constructor(elements = []) {
-      __publicField(this, "OBJ_KEY_INDEX", Symbol("OBJ_KEY_INDEX"));
-      __publicField(this, "_nodes", []);
-      __publicField(this, "_orgMap", {});
+    constructor(options = {
+      elements: [],
+      hashFn: (key) => String(key),
+      objHashFn: (key) => key
+    }) {
+      __publicField(this, "_noObjMap", {});
+      __publicField(this, "_objMap", /* @__PURE__ */ new WeakMap());
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_sentinel");
+      __publicField(this, "_hashFn");
+      __publicField(this, "_objHashFn");
       __publicField(this, "_size", 0);
-      Object.setPrototypeOf(this._orgMap, null);
       this._sentinel = {};
       this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-      for (const el of elements) {
-        this.set(el[0], el[1]);
+      const { elements, hashFn, objHashFn } = options;
+      this._hashFn = hashFn;
+      this._objHashFn = objHashFn;
+      if (elements) {
+        for (const el of elements) {
+          this.set(el[0], el[1]);
+        }
       }
     }
     get size() {
       return this._size;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new iterator object for a HashMap.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get begin() {
-      return new HashMapIterator(this._head, this._sentinel, this);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-     * end values.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get end() {
-      return new HashMapIterator(this._sentinel, this._sentinel, this);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-     * a HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseBegin() {
-      return new HashMapIterator(this._tail, this._sentinel, this, 1 /* REVERSE */);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-     * HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseEnd() {
-      return new HashMapIterator(this._sentinel, this._sentinel, this, 1 /* REVERSE */);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -802,6 +518,27 @@ var dataStructureTyped = (() => {
         return;
       return [this._tail.key, this._tail.value];
     }
+    /**
+     * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
+     */
+    *begin() {
+      let node = this._head;
+      while (node !== this._sentinel) {
+        yield [node.key, node.value];
+        node = node.next;
+      }
+    }
+    /**
+     * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
+     * key and value.
+     */
+    *reverseBegin() {
+      let node = this._tail;
+      while (node !== this._sentinel) {
+        yield [node.key, node.value];
+        node = node.prev;
+      }
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -812,50 +549,43 @@ var dataStructureTyped = (() => {
      * type, but typically it is a string or symbol.
      * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
      * value associated with the key being set in the data structure.
-     * @param {boolean} isObjectKey - A boolean flag indicating whether the key is an object key or not.
      * @returns the size of the data structure after the key-value pair has been set.
      */
-    set(key, value, isObjectKey = isObjOrFunc(key)) {
-      let newTail;
-      if (isObjectKey) {
-        const index = key[this.OBJ_KEY_INDEX];
-        if (index !== void 0) {
-          this._nodes[index].value = value;
-          return this._size;
-        }
-        Object.defineProperty(key, this.OBJ_KEY_INDEX, {
-          value: this._nodes.length,
-          configurable: true
-        });
-        newTail = {
-          key,
-          value,
-          prev: this._tail,
-          next: this._sentinel
-        };
-        this._nodes.push(newTail);
+    set(key, value) {
+      let node;
+      if (isWeakKey(key)) {
+        const hash = key;
+        node = this._objMap.get(hash);
+        if (node) {
+          node.value = value;
+        } else {
+          node = { key: hash, value, prev: this._tail, next: this._sentinel };
+          this._objMap.set(hash, node);
+        }
       } else {
-        const node = this._orgMap[key];
+        const hash = this._hashFn(key);
+        node = this._noObjMap[hash];
         if (node) {
           node.value = value;
-          return this._size;
+        } else {
+          this._noObjMap[hash] = node = {
+            key,
+            value,
+            prev: this._tail,
+            next: this._sentinel
+          };
         }
-        this._orgMap[key] = newTail = {
-          key,
-          value,
-          prev: this._tail,
-          next: this._sentinel
-        };
       }
       if (this._size === 0) {
-        this._head = newTail;
-        this._sentinel.next = newTail;
+        this._head = node;
+        this._sentinel.next = node;
       } else {
-        this._tail.next = newTail;
+        this._tail.next = node;
       }
-      this._tail = newTail;
-      this._sentinel.prev = newTail;
-      return ++this._size;
+      this._tail = node;
+      this._sentinel.prev = node;
+      this._size++;
+      return this._size;
     }
     /**
      * Time Complexity: O(1)
@@ -865,21 +595,21 @@ var dataStructureTyped = (() => {
      * key directly or by using an index stored in the key object.
      * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
      * of any type, but typically it is a string or symbol.
-     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that
-     * `key` is an object key. If `isObjectKey` is `false`, it means that `key`
      * @returns The value associated with the given key is being returned. If the key is an object key,
      * the value is retrieved from the `_nodes` array using the index stored in the `OBJ_KEY_INDEX`
-     * property of the key. If the key is a string key, the value is retrieved from the `_orgMap` object
+     * property of the key. If the key is a string key, the value is retrieved from the `_noObjMap` object
      * using the key itself. If the key is not found, `undefined` is
      */
-    get(key, isObjectKey = isObjOrFunc(key)) {
-      if (isObjectKey) {
-        const index = key[this.OBJ_KEY_INDEX];
-        return index !== void 0 ? this._nodes[index].value : void 0;
+    get(key) {
+      if (isWeakKey(key)) {
+        const hash = this._objHashFn(key);
+        const node = this._objMap.get(hash);
+        return node ? node.value : void 0;
+      } else {
+        const hash = this._hashFn(key);
+        const node = this._noObjMap[hash];
+        return node ? node.value : void 0;
       }
-      const node = this._orgMap[key];
-      return node ? node.value : void 0;
     }
     /**
      * Time Complexity: O(n), where n is the index.
@@ -900,33 +630,6 @@ var dataStructureTyped = (() => {
       }
       return [node.key, node.value];
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function `getIterator` returns a new instance of `HashMapIterator` based on the provided key
-     * and whether it is an object key or not.
-     * @param {K} key - The `key` parameter is the key used to retrieve the iterator from the HashMap. It
-     * can be of any type, depending on how the HashMap is implemented.
-     * @param {boolean} [isObjectKey] - The `isObjectKey` parameter is an optional boolean parameter that
-     * indicates whether the `key` parameter is an object key. If `isObjectKey` is `true`, it means that
-     * the `key` parameter is an object and needs to be handled differently. If `isObjectKey` is `false`
-     * @returns a new instance of the `HashMapIterator` class.
-     */
-    getIterator(key, isObjectKey) {
-      let node;
-      if (isObjectKey) {
-        const index = key[this.OBJ_KEY_INDEX];
-        if (index === void 0) {
-          node = this._sentinel;
-        } else {
-          node = this._nodes[index];
-        }
-      } else {
-        node = this._orgMap[key] || this._sentinel;
-      }
-      return new HashMapIterator(node, this._sentinel, this);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -934,26 +637,25 @@ var dataStructureTyped = (() => {
      * The `delete` function removes a key-value pair from a map-like data structure.
      * @param {K} key - The `key` parameter is the key that you want to delete from the data structure.
      * It can be of any type, but typically it is a string or an object.
-     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that the
-     * `key` parameter is an object key. If `isObjectKey` is `false`, it means that the
      * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
      * was not found.
      */
-    delete(key, isObjectKey = isObjOrFunc(key)) {
+    delete(key) {
       let node;
-      if (isObjectKey) {
-        const index = key[this.OBJ_KEY_INDEX];
-        if (index === void 0)
+      if (isWeakKey(key)) {
+        const hash = this._objHashFn(key);
+        node = this._objMap.get(hash);
+        if (!node) {
           return false;
-        delete key[this.OBJ_KEY_INDEX];
-        node = this._nodes[index];
-        delete this._nodes[index];
+        }
+        this._objMap.delete(hash);
       } else {
-        node = this._orgMap[key];
-        if (node === void 0)
+        const hash = this._hashFn(key);
+        node = this._noObjMap[hash];
+        if (!node) {
           return false;
-        delete this._orgMap[key];
+        }
+        delete this._noObjMap[hash];
       }
       this._deleteNode(node);
       return true;
@@ -994,9 +696,7 @@ var dataStructureTyped = (() => {
      * The `clear` function clears all the elements in a data structure and resets its properties.
      */
     clear() {
-      this._nodes = [];
-      this._orgMap = {};
-      Object.setPrototypeOf(this._orgMap, null);
+      this._noObjMap = {};
       this._size = 0;
       this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
     }
@@ -1017,6 +717,30 @@ var dataStructureTyped = (() => {
         node = node.next;
       }
     }
+    filter(predicate) {
+      const filteredMap = new _HashMap();
+      for (const [key, value] of this) {
+        if (predicate([key, value], this)) {
+          filteredMap.set(key, value);
+        }
+      }
+      return filteredMap;
+    }
+    map(callback) {
+      const mappedMap = new _HashMap();
+      for (const [key, value] of this) {
+        const newValue = callback([key, value], this);
+        mappedMap.set(key, newValue);
+      }
+      return mappedMap;
+    }
+    reduce(callback, initialValue) {
+      let accumulator = initialValue;
+      for (const element of this) {
+        accumulator = callback(accumulator, element, this);
+      }
+      return accumulator;
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the HashMap.
      * Space Complexity: O(1)
@@ -3161,79 +2885,6 @@ var dataStructureTyped = (() => {
   };
 
   // src/data-structures/queue/deque.ts
-  var DequeIterator = class _DequeIterator {
-    /**
-     * The constructor initializes the index, iterate direction, and prev/next functions for a
-     * DequeIterator object.
-     * @param {number} index - The index parameter represents the current index position of the iterator
-     * within the deque. It is a number that indicates the position of the element that the iterator is
-     * currently pointing to.
-     * @param deque - The `deque` parameter is an instance of the `Deque` class. It represents a
-     * double-ended queue data structure, which allows elements to be added or removed from both ends.
-     * @param iterateDirection - The `iterateDirection` parameter is an optional parameter that specifies
-     * the direction in which the iterator should iterate over the elements of the `deque`. It has a
-     * default value of `IterateDirection.DEFAULT`.
-     * @returns The constructor is not returning anything. It is used to initialize the properties of the
-     * object being created.
-     */
-    constructor(index, deque, iterateDirection = 0 /* DEFAULT */) {
-      __publicField(this, "iterateDirection");
-      __publicField(this, "index");
-      __publicField(this, "deque");
-      this.index = index;
-      this.iterateDirection = iterateDirection;
-      if (this.iterateDirection === 0 /* DEFAULT */) {
-        this.prev = function() {
-          if (this.index === 0) {
-            throwRangeError();
-          }
-          this.index -= 1;
-          return this;
-        };
-        this.next = function() {
-          if (this.index === this.deque.size) {
-            throwRangeError();
-          }
-          this.index += 1;
-          return this;
-        };
-      } else {
-        this.prev = function() {
-          if (this.index === this.deque.size - 1) {
-            throwRangeError();
-          }
-          this.index += 1;
-          return this;
-        };
-        this.next = function() {
-          if (this.index === -1) {
-            throwRangeError();
-          }
-          this.index -= 1;
-          return this;
-        };
-      }
-      this.deque = deque;
-    }
-    get current() {
-      return this.deque.getAt(this.index);
-    }
-    set current(newElement) {
-      this.deque.setAt(this.index, newElement);
-    }
-    isAccessible() {
-      return this.index !== this.deque.size;
-    }
-    prev() {
-      return this;
-    }
-    next() {
-      return this;
-    }
-    clone() {
-      return new _DequeIterator(this.index, this.deque, this.iterateDirection);
-    }
-  };
   var Deque = class _Deque {
     /**
      * The constructor initializes a data structure with a specified bucket size and populates it with
@@ -3367,35 +3018,25 @@ var dataStructureTyped = (() => {
       this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
     }
     /**
-     * The `begin()` function returns a new iterator for a deque starting from the first element.
-     * @returns A new instance of the DequeIterator class is being returned.
-     */
-    begin() {
-      return new DequeIterator(0, this);
-    }
-    /**
-     * The `end()` function returns a new `DequeIterator` object with the size and reference to the
-     * current deque.
-     * @returns A new instance of the DequeIterator class is being returned.
-     */
-    end() {
-      return new DequeIterator(this.size, this);
-    }
-    /**
-     * The reverseBegin function returns a new DequeIterator object that starts at the last element of
-     * the deque and iterates in reverse direction.
-     * @returns A new instance of the DequeIterator class is being returned.
+     * The below function is a generator that yields elements from a collection one by one.
      */
-    reverseBegin() {
-      return new DequeIterator(this.size - 1, this, 1 /* REVERSE */);
+    *begin() {
+      let index = 0;
+      while (index < this.size) {
+        yield this.getAt(index);
+        index++;
+      }
     }
     /**
-     * The reverseEnd() function returns a new DequeIterator object that iterates over the elements of a
-     * Deque in reverse order.
-     * @returns A new instance of the DequeIterator class is being returned.
+     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
+     * the last element.
      */
-    reverseEnd() {
-      return new DequeIterator(-1, this, 1 /* REVERSE */);
+    *reverseBegin() {
+      let index = this.size - 1;
+      while (index >= 0) {
+        yield this.getAt(index);
+        index--;
+      }
     }
     /**
      * Time Complexity - Amortized O(1) (possible reallocation)
@@ -3705,46 +3346,6 @@ var dataStructureTyped = (() => {
       this.cut(index - 1);
       return this.size;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function deletes an element from a deque using an iterator and returns the next iterator.
-     * @param iter - The parameter `iter` is of type `DequeIterator<E>`. It represents an iterator object
-     * that is used to iterate over elements in a deque (double-ended queue).
-     * @returns the updated iterator after deleting an element from the deque.
-     */
-    deleteByIterator(iter) {
-      const index = iter.index;
-      this.deleteAt(index);
-      iter = iter.next();
-      return iter;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function `findIterator` searches for an element in a deque and returns an iterator pointing to
-     * the element if found, otherwise it returns an iterator pointing to the end of the deque.
-     * @param {E} element - The `element` parameter is the element that you want to find in the deque.
-     * @returns The method `findIterator(element: E)` returns a `DequeIterator<E>` object.
-     */
-    findIterator(element) {
-      for (let i = 0; i < this.size; ++i) {
-        if (this.getAt(i) === element) {
-          return new DequeIterator(i, this);
-        }
-      }
-      return this.end();
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -6909,6 +6510,43 @@ var dataStructureTyped = (() => {
     }
   };
 
+  // src/types/data-structures/binary-tree/binary-tree.ts
+  var IterationType = /* @__PURE__ */ ((IterationType3) => {
+    IterationType3["ITERATIVE"] = "ITERATIVE";
+    IterationType3["RECURSIVE"] = "RECURSIVE";
+    return IterationType3;
+  })(IterationType || {});
+  var FamilyPosition = /* @__PURE__ */ ((FamilyPosition2) => {
+    FamilyPosition2["ROOT"] = "ROOT";
+    FamilyPosition2["LEFT"] = "LEFT";
+    FamilyPosition2["RIGHT"] = "RIGHT";
+    FamilyPosition2["ROOT_LEFT"] = "ROOT_LEFT";
+    FamilyPosition2["ROOT_RIGHT"] = "ROOT_RIGHT";
+    FamilyPosition2["ISOLATED"] = "ISOLATED";
+    FamilyPosition2["MAL_NODE"] = "MAL_NODE";
+    return FamilyPosition2;
+  })(FamilyPosition || {});
+
+  // src/types/data-structures/binary-tree/rb-tree.ts
+  var RBTNColor = /* @__PURE__ */ ((RBTNColor2) => {
+    RBTNColor2[RBTNColor2["RED"] = 1] = "RED";
+    RBTNColor2[RBTNColor2["BLACK"] = 0] = "BLACK";
+    return RBTNColor2;
+  })(RBTNColor || {});
+
+  // src/types/helpers.ts
+  var CP = /* @__PURE__ */ ((CP2) => {
+    CP2["lt"] = "lt";
+    CP2["eq"] = "eq";
+    CP2["gt"] = "gt";
+    return CP2;
+  })(CP || {});
+  var IterateDirection = /* @__PURE__ */ ((IterateDirection2) => {
+    IterateDirection2[IterateDirection2["DEFAULT"] = 0] = "DEFAULT";
+    IterateDirection2[IterateDirection2["REVERSE"] = 1] = "REVERSE";
+    return IterateDirection2;
+  })(IterateDirection || {});
+
   // src/data-structures/binary-tree/binary-tree.ts
   var BinaryTreeNode = class {
     /**