data-structure-typed 1.50.2 → 1.50.4

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

@@ -102,6 +102,8 @@ var dataStructureTyped = (() => {
   var src_exports = {};
   __export(src_exports, {
     AVLTree: () => AVLTree,
+    AVLTreeMultiMap: () => AVLTreeMultiMap,
+    AVLTreeMultiMapNode: () => AVLTreeMultiMapNode,
     AVLTreeNode: () => AVLTreeNode,
     AbstractEdge: () => AbstractEdge,
     AbstractGraph: () => AbstractGraph,
@@ -152,8 +154,8 @@ var dataStructureTyped = (() => {
     SkipListNode: () => SkipListNode,
     Stack: () => Stack,
     THUNK_SYMBOL: () => THUNK_SYMBOL,
-    TreeMultimap: () => TreeMultimap,
-    TreeMultimapNode: () => TreeMultimapNode,
+    TreeMultiMap: () => TreeMultiMap,
+    TreeMultiMapNode: () => TreeMultiMapNode,
     TreeNode: () => TreeNode,
     Trie: () => Trie,
     TrieNode: () => TrieNode,
@@ -755,6 +757,22 @@ var dataStructureTyped = (() => {
         this.setMany(rawCollection);
       }
     }
+    /**
+     * The function returns the store object, which is a dictionary of HashMapStoreItem objects.
+     * @returns The store property is being returned. It is a dictionary-like object with string keys and
+     * values of type HashMapStoreItem<K, V>.
+     */
+    get store() {
+      return this._store;
+    }
+    /**
+     * The function returns the object map.
+     * @returns The `objMap` property is being returned, which is a `Map` object with keys of type
+     * `object` and values of type `V`.
+     */
+    get objMap() {
+      return this._objMap;
+    }
     /**
      * The function returns the value of the _toEntryFn property.
      * @returns The function being returned is `this._toEntryFn`.
@@ -762,22 +780,22 @@ var dataStructureTyped = (() => {
     get toEntryFn() {
       return this._toEntryFn;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
+    get size() {
+      return this._size;
+    }
     /**
      * The hasFn function is a function that takes in an item and returns a boolean
      * indicating whether the item is contained within the hash table.
      *
      * @return The hash function
      */
-    get hasFn() {
+    get hashFn() {
       return this._hashFn;
     }
-    /**
-     * The function returns the size of an object.
-     * @returns The size of the object, which is a number.
-     */
-    get size() {
-      return this._size;
-    }
     /**
      * The function checks if a given element is an array with exactly two elements.
      * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
@@ -814,13 +832,13 @@ var dataStructureTyped = (() => {
      */
     set(key, value) {
       if (this._isObjKey(key)) {
-        if (!this._objMap.has(key)) {
+        if (!this.objMap.has(key)) {
           this._size++;
         }
-        this._objMap.set(key, value);
+        this.objMap.set(key, value);
       } else {
         const strKey = this._getNoObjKey(key);
-        if (this._store[strKey] === void 0) {
+        if (this.store[strKey] === void 0) {
           this._size++;
         }
         this._store[strKey] = { key, value };
@@ -861,7 +879,7 @@ var dataStructureTyped = (() => {
     get(key) {
       var _a;
       if (this._isObjKey(key)) {
-        return this._objMap.get(key);
+        return this.objMap.get(key);
       } else {
         const strKey = this._getNoObjKey(key);
         return (_a = this._store[strKey]) == null ? void 0 : _a.value;
@@ -875,10 +893,10 @@ var dataStructureTyped = (() => {
      */
     has(key) {
       if (this._isObjKey(key)) {
-        return this._objMap.has(key);
+        return this.objMap.has(key);
       } else {
         const strKey = this._getNoObjKey(key);
-        return strKey in this._store;
+        return strKey in this.store;
       }
     }
     /**
@@ -890,20 +908,24 @@ var dataStructureTyped = (() => {
      */
     delete(key) {
       if (this._isObjKey(key)) {
-        if (this._objMap.has(key)) {
+        if (this.objMap.has(key)) {
           this._size--;
         }
-        return this._objMap.delete(key);
+        return this.objMap.delete(key);
       } else {
         const strKey = this._getNoObjKey(key);
-        if (strKey in this._store) {
-          delete this._store[strKey];
+        if (strKey in this.store) {
+          delete this.store[strKey];
           this._size--;
           return true;
         }
         return false;
       }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     /**
      * The clone function creates a new HashMap with the same key-value pairs as
      * this one. The clone function is useful for creating a copy of an existing
@@ -912,7 +934,7 @@ var dataStructureTyped = (() => {
      * @return A new hashmap with the same values as this one
      */
     clone() {
-      return new _HashMap(this, { hashFn: this._hashFn, toEntryFn: this.toEntryFn });
+      return new _HashMap(this, { hashFn: this.hashFn, toEntryFn: this.toEntryFn });
     }
     /**
      * Time Complexity: O(n)
@@ -940,10 +962,6 @@ var dataStructureTyped = (() => {
       }
       return resultMap;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -986,22 +1004,34 @@ var dataStructureTyped = (() => {
      * object map.
      */
     *_getIterator() {
-      for (const node of Object.values(this._store)) {
+      for (const node of Object.values(this.store)) {
         yield [node.key, node.value];
       }
-      for (const node of this._objMap) {
+      for (const node of this.objMap) {
         yield node;
       }
     }
+    /**
+     * The function checks if a given key is an object or a function.
+     * @param {any} key - The parameter "key" can be of any type.
+     * @returns a boolean value.
+     */
     _isObjKey(key) {
       const keyType = typeof key;
       return (keyType === "object" || keyType === "function") && key !== null;
     }
+    /**
+     * The function `_getNoObjKey` takes a key and returns a string representation of the key, handling
+     * different types of keys.
+     * @param {K} key - The `key` parameter is of type `K`, which represents the type of the key being
+     * passed to the `_getNoObjKey` function.
+     * @returns a string value.
+     */
     _getNoObjKey(key) {
       const keyType = typeof key;
       let strKey;
       if (keyType !== "string" && keyType !== "number" && keyType !== "symbol") {
-        strKey = this._hashFn(key);
+        strKey = this.hashFn(key);
       } else {
         if (keyType === "number") {
           strKey = key;
@@ -1024,11 +1054,13 @@ var dataStructureTyped = (() => {
      */
     constructor(rawCollection = [], options) {
       super();
+      __publicField(this, "_sentinel");
+      __publicField(this, "_hashFn", (key) => String(key));
+      __publicField(this, "_objHashFn", (key) => key);
       __publicField(this, "_noObjMap", {});
       __publicField(this, "_objMap", /* @__PURE__ */ new WeakMap());
       __publicField(this, "_head");
       __publicField(this, "_tail");
-      __publicField(this, "_sentinel");
       __publicField(this, "_toEntryFn", (rawElement) => {
         if (this.isEntry(rawElement)) {
           return rawElement;
@@ -1039,8 +1071,6 @@ var dataStructureTyped = (() => {
         }
       });
       __publicField(this, "_size", 0);
-      __publicField(this, "_hashFn", (key) => String(key));
-      __publicField(this, "_objHashFn", (key) => key);
       this._sentinel = {};
       this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
       if (options) {
@@ -1060,6 +1090,51 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    /**
+     * The function returns the hash function used for generating a hash value for a given key.
+     * @returns The hash function that takes a key of type K and returns a string.
+     */
+    get hashFn() {
+      return this._hashFn;
+    }
+    /**
+     * The function returns the object hash function.
+     * @returns The function `objHashFn` is being returned.
+     */
+    get objHashFn() {
+      return this._objHashFn;
+    }
+    /**
+     * The function returns a record of HashMapLinkedNode objects with string keys.
+     * @returns The method is returning a Record object, which is a TypeScript type that represents an
+     * object with string keys and values that are HashMapLinkedNode objects with keys of type K and
+     * values of type V or undefined.
+     */
+    get noObjMap() {
+      return this._noObjMap;
+    }
+    /**
+     * The function returns the WeakMap object used to map objects to HashMapLinkedNode instances.
+     * @returns The `objMap` property is being returned.
+     */
+    get objMap() {
+      return this._objMap;
+    }
+    /**
+     * The function returns the head node of a HashMapLinkedNode.
+     * @returns The method `getHead()` is returning a `HashMapLinkedNode` object with key type `K` and
+     * value type `V | undefined`.
+     */
+    get head() {
+      return this._head;
+    }
+    /**
+     * The function returns the tail node of a HashMapLinkedNode.
+     * @returns The `_tail` property of type `HashMapLinkedNode<K, V | undefined>` is being returned.
+     */
+    get tail() {
+      return this._tail;
+    }
     /**
      * The function returns the value of the _toEntryFn property.
      * @returns The function being returned is `this._toEntryFn`.
@@ -1074,6 +1149,10 @@ var dataStructureTyped = (() => {
     get size() {
       return this._size;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -1085,8 +1164,12 @@ var dataStructureTyped = (() => {
     get first() {
       if (this._size === 0)
         return;
-      return [this._head.key, this._head.value];
+      return [this.head.key, this.head.value];
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -1098,13 +1181,13 @@ var dataStructureTyped = (() => {
     get last() {
       if (this._size === 0)
         return;
-      return [this._tail.key, this._tail.value];
+      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;
+      let node = this.head;
       while (node !== this._sentinel) {
         yield [node.key, node.value];
         node = node.next;
@@ -1115,12 +1198,16 @@ var dataStructureTyped = (() => {
      * key and value.
      */
     *reverseBegin() {
-      let node = this._tail;
+      let node = this.tail;
       while (node !== this._sentinel) {
         yield [node.key, node.value];
         node = node.prev;
       }
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -1137,19 +1224,19 @@ var dataStructureTyped = (() => {
       let node;
       const isNewKey = !this.has(key);
       if (isWeakKey(key)) {
-        const hash = this._objHashFn(key);
-        node = this._objMap.get(hash);
+        const hash = this.objHashFn(key);
+        node = this.objMap.get(hash);
         if (!node && isNewKey) {
-          node = { key: hash, value, prev: this._tail, next: this._sentinel };
-          this._objMap.set(hash, node);
+          node = { key: hash, value, prev: this.tail, next: this._sentinel };
+          this.objMap.set(hash, node);
         } else if (node) {
           node.value = value;
         }
       } else {
-        const hash = this._hashFn(key);
-        node = this._noObjMap[hash];
+        const hash = this.hashFn(key);
+        node = this.noObjMap[hash];
         if (!node && isNewKey) {
-          this._noObjMap[hash] = node = { key, value, prev: this._tail, next: this._sentinel };
+          this.noObjMap[hash] = node = { key, value, prev: this.tail, next: this._sentinel };
         } else if (node) {
           node.value = value;
         }
@@ -1159,8 +1246,8 @@ var dataStructureTyped = (() => {
           this._head = node;
           this._sentinel.next = node;
         } else {
-          this._tail.next = node;
-          node.prev = this._tail;
+          this.tail.next = node;
+          node.prev = this.tail;
         }
         this._tail = node;
         this._sentinel.prev = node;
@@ -1192,13 +1279,17 @@ var dataStructureTyped = (() => {
      */
     has(key) {
       if (isWeakKey(key)) {
-        const hash = this._objHashFn(key);
-        return this._objMap.has(hash);
+        const hash = this.objHashFn(key);
+        return this.objMap.has(hash);
       } else {
-        const hash = this._hashFn(key);
-        return hash in this._noObjMap;
+        const hash = this.hashFn(key);
+        return hash in this.noObjMap;
       }
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -1214,89 +1305,109 @@ var dataStructureTyped = (() => {
      */
     get(key) {
       if (isWeakKey(key)) {
-        const hash = this._objHashFn(key);
-        const node = this._objMap.get(hash);
+        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];
+        const hash = this.hashFn(key);
+        const node = this.noObjMap[hash];
         return node ? node.value : void 0;
       }
     }
     /**
-     * Time Complexity: O(n), where n is the index.
-     * Space Complexity: O(1)
-     *
-     * The function `at` retrieves the key-value pair at a specified index in a linked list.
-     * @param {number} index - The index parameter is a number that represents the position of the
-     * element we want to retrieve from the data structure.
-     * @returns The method `at(index: number)` is returning an array containing the key-value pair at
-     * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
-     * where `K` is the key and `V` is the value.
-     */
+       * Time Complexity: O(n)
+       * Space Complexity: O(1)
+       * /
+    
+       /**
+       * Time Complexity: O(n)
+       * Space Complexity: O(1)
+       *
+       * The function `at` retrieves the key-value pair at a specified index in a linked list.
+       * @param {number} index - The index parameter is a number that represents the position of the
+       * element we want to retrieve from the data structure.
+       * @returns The method `at(index: number)` is returning an array containing the key-value pair at
+       * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
+       * where `K` is the key and `V` is the value.
+       */
     at(index) {
       rangeCheck(index, 0, this._size - 1);
-      let node = this._head;
+      let node = this.head;
       while (index--) {
         node = node.next;
       }
       return node.value;
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * 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.
-     * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
-     * was not found.
-     */
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       * /
+    
+       /**
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       *
+       * 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.
+       * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
+       * was not found.
+       */
     delete(key) {
       let node;
       if (isWeakKey(key)) {
-        const hash = this._objHashFn(key);
-        node = this._objMap.get(hash);
+        const hash = this.objHashFn(key);
+        node = this.objMap.get(hash);
         if (!node) {
           return false;
         }
-        this._objMap.delete(hash);
+        this.objMap.delete(hash);
       } else {
-        const hash = this._hashFn(key);
-        node = this._noObjMap[hash];
+        const hash = this.hashFn(key);
+        node = this.noObjMap[hash];
         if (!node) {
           return false;
         }
-        delete this._noObjMap[hash];
+        delete this.noObjMap[hash];
       }
       this._deleteNode(node);
       return true;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `deleteAt` function deletes a node at a specified index in a linked list.
-     * @param {number} index - The index parameter represents the position at which the node should be
-     * deleted in the linked list.
-     * @returns The size of the list after deleting the element at the specified index.
-     */
+       * Time Complexity: O(n)
+       * Space Complexity: O(1)
+       * /
+    
+       /**
+       * Time Complexity: O(n)
+       * Space Complexity: O(1)
+       *
+       * The `deleteAt` function deletes a node at a specified index in a linked list.
+       * @param {number} index - The index parameter represents the position at which the node should be
+       * deleted in the linked list.
+       * @returns The size of the list after deleting the element at the specified index.
+       */
     deleteAt(index) {
       rangeCheck(index, 0, this._size - 1);
-      let node = this._head;
+      let node = this.head;
       while (index--) {
         node = node.next;
       }
       return this._deleteNode(node);
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function checks if a data structure is empty by comparing its size to zero.
-     * @returns The method is returning a boolean value indicating whether the size of the object is 0 or
-     * not.
-     */
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       * /
+    
+       /**
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       *
+       * The function checks if a data structure is empty by comparing its size to zero.
+       * @returns The method is returning a boolean value indicating whether the size of the object is 0 or
+       * not.
+       */
     isEmpty() {
       return this._size === 0;
     }
@@ -1310,11 +1421,16 @@ var dataStructureTyped = (() => {
       return Array.isArray(rawElement) && rawElement.length === 2;
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `clear` function clears all the entries in a data structure and resets its properties.
-     */
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       * /
+    
+       /**
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       *
+       * The `clear` function clears all the entries in a data structure and resets its properties.
+       */
     clear() {
       this._noObjMap = {};
       this._size = 0;
@@ -1334,7 +1450,7 @@ var dataStructureTyped = (() => {
      * of the original `LinkedHashMap` object.
      */
     clone() {
-      const cloned = new _LinkedHashMap([], { hashFn: this._hashFn, objHashFn: this._objHashFn });
+      const cloned = new _LinkedHashMap([], { hashFn: this.hashFn, objHashFn: this.objHashFn });
       for (const entry of this) {
         const [key, value] = entry;
         cloned.set(key, value);
@@ -1342,20 +1458,25 @@ var dataStructureTyped = (() => {
       return cloned;
     }
     /**
-     * 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.
-     */
+       * Time Complexity: O(n)
+       * Space Complexity: O(n)
+       * /
+    
+       /**
+       * Time Complexity: O(n)
+       * Space Complexity: O(n)
+       *
+       * The `filter` function creates a new `LinkedHashMap` containing key-value pairs from the original
+       * map that satisfy a given predicate function.
+       * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+       * `value`, `key`, `index`, and `this`. It should return a boolean value indicating whether the
+       * current element should be included in the filtered map or not.
+       * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+       * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+       * specific object as the context for the `predicate` function. If `thisArg` is not provided, `this
+       * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
+       * `LinkedHashMap` object that satisfy the given predicate function.
+       */
     filter(predicate, thisArg) {
       const filteredMap = new _LinkedHashMap();
       let index = 0;
@@ -1368,22 +1489,27 @@ var dataStructureTyped = (() => {
       return filteredMap;
     }
     /**
-     * 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.
-     */
+       * Time Complexity: O(n)
+       * Space Complexity: O(n)
+       * /
+    
+       /**
+       * Time Complexity: O(n)
+       * Space Complexity: O(n)
+       *
+       * The `map` function in TypeScript creates a new `LinkedHashMap` by applying a callback function to
+       * each key-value pair in the original map.
+       * @param callback - The callback parameter is a function that will be called for each key-value pair
+       * in the map. It takes four arguments: the value of the current key-value pair, the key of the
+       * current key-value pair, the index of the current key-value pair, and the map itself. The callback
+       * function should
+       * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+       * specify the value of `this` within the callback function. If provided, the callback function will
+       * be called with `thisArg` as its `this` value. If not provided, `this` will refer to the current
+       * map
+       * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
+       * function.
+       */
     map(callback, thisArg) {
       const mappedMap = new _LinkedHashMap();
       let index = 0;
@@ -1413,19 +1539,29 @@ var dataStructureTyped = (() => {
       return this.set(key, value);
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     * where n is the number of entries in the LinkedHashMap.
-     *
-     * The above function is an iterator that yields key-value pairs from a linked list.
-     */
+       * Time Complexity: O(n)
+       * Space Complexity: O(1)
+       * where n is the number of entries in the LinkedHashMap.
+       * /
+    
+       /**
+       * Time Complexity: O(n)
+       * Space Complexity: O(1)
+       * where n is the number of entries in the LinkedHashMap.
+       *
+       * The above function is an iterator that yields key-value pairs from a linked list.
+       */
     *_getIterator() {
-      let node = this._head;
+      let node = this.head;
       while (node !== this._sentinel) {
         yield [node.key, node.value];
         node = node.next;
       }
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -1440,10 +1576,10 @@ var dataStructureTyped = (() => {
       const { prev, next } = node;
       prev.next = next;
       next.prev = prev;
-      if (node === this._head) {
+      if (node === this.head) {
         this._head = next;
       }
-      if (node === this._tail) {
+      if (node === this.tail) {
         this._tail = prev;
       }
       this._size -= 1;
@@ -1459,10 +1595,41 @@ var dataStructureTyped = (() => {
      * will be stored in the node of a linked list.
      */
     constructor(value) {
-      __publicField(this, "value");
-      __publicField(this, "next");
-      this.value = value;
-      this.next = void 0;
+      __publicField(this, "_value");
+      __publicField(this, "_next");
+      this._value = value;
+      this._next = void 0;
+    }
+    /**
+     * The function returns the value of a protected variable.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value() {
+      return this._value;
+    }
+    /**
+     * The above function sets the value of a variable.
+     * @param {E} value - The parameter "value" is of type E, which means it can be any type.
+     */
+    set value(value) {
+      this._value = value;
+    }
+    /**
+     * The `next` function returns the next node in a singly linked list.
+     * @returns The `next` property is being returned. It can be either a `SinglyLinkedListNode<E>`
+     * object or `undefined`.
+     */
+    get next() {
+      return this._next;
+    }
+    /**
+     * The "next" property of a SinglyLinkedListNode is set to the provided value.
+     * @param {SinglyLinkedListNode<E> | undefined} value - The `value` parameter is of type
+     * `SinglyLinkedListNode<E> | undefined`. This means that it can accept either a
+     * `SinglyLinkedListNode` object or `undefined` as its value.
+     */
+    set next(value) {
+      this._next = value;
     }
   };
   var SinglyLinkedList = class _SinglyLinkedList extends IterableElementBase {
@@ -2103,7 +2270,7 @@ var dataStructureTyped = (() => {
       return filteredList;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
@@ -2149,12 +2316,60 @@ var dataStructureTyped = (() => {
      * is defined as a generic type "E".
      */
     constructor(value) {
-      __publicField(this, "value");
-      __publicField(this, "next");
-      __publicField(this, "prev");
-      this.value = value;
-      this.next = void 0;
-      this.prev = void 0;
+      __publicField(this, "_value");
+      __publicField(this, "_next");
+      __publicField(this, "_prev");
+      this._value = value;
+      this._next = void 0;
+      this._prev = void 0;
+    }
+    /**
+     * The function returns the value of a protected variable.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value() {
+      return this._value;
+    }
+    /**
+     * The above function sets the value of a variable.
+     * @param {E} value - The parameter "value" is of type E, which means it can be any type.
+     */
+    set value(value) {
+      this._value = value;
+    }
+    /**
+     * The "next" function returns the next node in a doubly linked list.
+     * @returns The `next` property is being returned. It can be either a `DoublyLinkedListNode<E>`
+     * object or `undefined`.
+     */
+    get next() {
+      return this._next;
+    }
+    /**
+     * The "next" property of a DoublyLinkedListNode is set to the provided value.
+     * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
+     * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
+     * `DoublyLinkedListNode` object or `undefined` as its value.
+     */
+    set next(value) {
+      this._next = value;
+    }
+    /**
+     * The `prev` function returns the previous node in a doubly linked list.
+     * @returns The `prev` property of the `DoublyLinkedListNode` class is being returned. It can either
+     * be a `DoublyLinkedListNode` object or `undefined`.
+     */
+    get prev() {
+      return this._prev;
+    }
+    /**
+     * The function sets the previous node of a doubly linked list node.
+     * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
+     * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
+     * `DoublyLinkedListNode` object or `undefined` as its value.
+     */
+    set prev(value) {
+      this._prev = value;
     }
   };
   var DoublyLinkedList = class _DoublyLinkedList extends IterableElementBase {
@@ -2201,12 +2416,12 @@ var dataStructureTyped = (() => {
       return this._size;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      * where n is the number of elements in the linked list.
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `get first` function returns the first node in a doubly linked list, or undefined if the list is empty.
@@ -2221,7 +2436,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `get last` function returns the last node in a doubly linked list, or undefined if the list is empty.
@@ -2232,11 +2447,11 @@ var dataStructureTyped = (() => {
       return (_a = this.tail) == null ? void 0 : _a.value;
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the size of the input array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
@@ -2298,7 +2513,7 @@ var dataStructureTyped = (() => {
       return removedNode.value;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -2324,7 +2539,7 @@ var dataStructureTyped = (() => {
       return removedNode.value;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -2457,12 +2672,12 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      * where n is the number of elements in the linked list.
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
      * The `addBefore` function inserts a new value before an existing value or node in a doubly linked list.
@@ -2498,11 +2713,11 @@ var dataStructureTyped = (() => {
       return false;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
      * The `addAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
@@ -2566,7 +2781,11 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes a node from a doubly linked list based on either the node itself or its value.
@@ -2603,6 +2822,9 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a variable has a size greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
      */
@@ -2614,6 +2836,9 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `clear` function resets the linked list by setting the head, tail, and size to undefined and 0 respectively.
      */
     clear() {
@@ -2649,7 +2874,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -2674,7 +2899,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -2749,9 +2974,9 @@ var dataStructureTyped = (() => {
       return new _DoublyLinkedList(this.values());
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -2781,8 +3006,8 @@ var dataStructureTyped = (() => {
       return filteredList;
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n)
@@ -2840,7 +3065,7 @@ var dataStructureTyped = (() => {
       return this.pop();
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -2855,7 +3080,7 @@ var dataStructureTyped = (() => {
       return this.shift();
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -2926,7 +3151,7 @@ var dataStructureTyped = (() => {
       return this._head;
     }
     /**
-     * The function returns the value of the private variable _level.
+     * The function returns the value of the protected variable _level.
      * @returns The level property of the object.
      */
     get level() {
@@ -2941,7 +3166,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function returns the probability value.
-     * @returns The probability value stored in the private variable `_probability` is being returned.
+     * @returns The probability value stored in the protected variable `_probability` is being returned.
      */
     get probability() {
       return this._probability;
@@ -3179,10 +3404,6 @@ var dataStructureTyped = (() => {
     get elements() {
       return this._elements;
     }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
-     * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
-     */
     /**
      * The size() function returns the number of elements in an array.
      * @returns The size of the elements array.
@@ -3191,8 +3412,12 @@ var dataStructureTyped = (() => {
       return this.elements.length;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
-     * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The function "fromArray" creates a new Stack object from an array of elements.
      * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
@@ -3210,12 +3435,12 @@ var dataStructureTyped = (() => {
       return this.elements.length === 0;
     }
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `peek` function returns the last element of an array, or undefined if the array is empty.
      * @returns The `peek()` function returns the last element of the `_elements` array, or `undefined` if the array is empty.
@@ -3226,12 +3451,12 @@ var dataStructureTyped = (() => {
       return this.elements[this.elements.length - 1];
     }
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The push function adds an element to the stack and returns the updated stack.
      * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
@@ -3242,12 +3467,12 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `pop` function removes and returns the last element from an array, or returns undefined if the array is empty.
      * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
@@ -3291,18 +3516,25 @@ var dataStructureTyped = (() => {
       return this.elements.slice();
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear function clears the elements array.
      */
     clear() {
       this._elements = [];
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
-     * Space Complexity: O(n), as it creates a new stack.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
-     * Space Complexity: O(n), as it creates a new stack.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
@@ -3368,6 +3600,13 @@ var dataStructureTyped = (() => {
       return newStack;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * Custom iterator for the Stack class.
      * @returns An iterator object.
      */
@@ -3404,7 +3643,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The offset function returns the offset of the current page.
-     * @return The value of the private variable _offset
+     * @return The value of the protected variable _offset
      */
     get offset() {
       return this._offset;
@@ -3417,8 +3656,12 @@ var dataStructureTyped = (() => {
       return this.elements.length - this.offset;
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
      * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
@@ -3428,12 +3671,12 @@ var dataStructureTyped = (() => {
       return this.size > 0 ? this.elements[this.offset] : void 0;
     }
     /**
-     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
      * @returns The method `get last()` returns the last element of the `_elements` array if the array is not empty. If the
@@ -3443,10 +3686,13 @@ var dataStructureTyped = (() => {
       return this.size > 0 ? this.elements[this.elements.length - 1] : void 0;
     }
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
      * @static
@@ -3458,12 +3704,12 @@ var dataStructureTyped = (() => {
       return new _Queue(elements);
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The push function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
      * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
@@ -3474,12 +3720,12 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
      * necessary to optimize performance.
@@ -3515,12 +3761,12 @@ var dataStructureTyped = (() => {
       return spliced.length === 1;
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `peek` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
      * @returns The `peek()` method returns the first element of the data structure, represented by the `_elements` array at
@@ -3530,12 +3776,12 @@ var dataStructureTyped = (() => {
       return this.first;
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
      * @returns The method `peekLast()` returns the last element of the `_elements` array if the array is not empty. If the
@@ -3545,12 +3791,12 @@ var dataStructureTyped = (() => {
       return this.last;
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The enqueue function adds a value to the end of a queue.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
@@ -3559,12 +3805,12 @@ var dataStructureTyped = (() => {
       return this.push(value);
     }
     /**
-     * Time Complexity: O(n) - same as shift().
-     * Space Complexity: O(1) - same as shift().
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - same as shift().
-     * Space Complexity: O(1) - same as shift().
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * 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 a value of type E or undefined.
@@ -3573,12 +3819,12 @@ var dataStructureTyped = (() => {
       return this.shift();
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * @param index
      */
@@ -3586,12 +3832,12 @@ var dataStructureTyped = (() => {
       return this.elements[index];
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function checks if a data structure is empty by comparing its size to zero.
      * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
@@ -3600,12 +3846,12 @@ var dataStructureTyped = (() => {
       return this.size === 0;
     }
     /**
-     * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
-     * Space Complexity: O(n) - where n is the number of elements in the queue.
+     * Time Complexity: O(1)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
-     * Space Complexity: O(n) - where n is the number of elements in the queue.
+     * Time Complexity: O(1)
+     * Space Complexity: O(n)
      *
      * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
      * @returns An array of type E is being returned.
@@ -3614,6 +3860,13 @@ var dataStructureTyped = (() => {
       return this.elements.slice(this.offset);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear function resets the elements array and offset to their initial values.
      */
     clear() {
@@ -3697,6 +3950,12 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `_getIterator` returns an iterable iterator for the elements in the class.
+     */
     *_getIterator() {
       for (const item of this.elements) {
         yield item;
@@ -3765,12 +4024,12 @@ var dataStructureTyped = (() => {
      */
     constructor(elements = [], options) {
       super();
+      __publicField(this, "_bucketSize", 1 << 12);
       __publicField(this, "_bucketFirst", 0);
       __publicField(this, "_firstInBucket", 0);
       __publicField(this, "_bucketLast", 0);
       __publicField(this, "_lastInBucket", 0);
       __publicField(this, "_bucketCount", 0);
-      __publicField(this, "_bucketSize", 1 << 12);
       __publicField(this, "_buckets", []);
       __publicField(this, "_size", 0);
       if (options) {
@@ -3809,9 +4068,45 @@ var dataStructureTyped = (() => {
     get bucketSize() {
       return this._bucketSize;
     }
+    /**
+     * The function returns the value of the protected variable `_bucketFirst`.
+     * @returns The value of the `_bucketFirst` property.
+     */
+    get bucketFirst() {
+      return this._bucketFirst;
+    }
+    /**
+     * The function returns the value of the protected variable _firstInBucket.
+     * @returns The method is returning the value of the variable `_firstInBucket`, which is of type
+     * `number`.
+     */
+    get firstInBucket() {
+      return this._firstInBucket;
+    }
+    /**
+     * The function returns the value of the protected variable `_bucketLast`.
+     * @returns The value of the `_bucketLast` property, which is a number.
+     */
+    get bucketLast() {
+      return this._bucketLast;
+    }
+    /**
+     * The function returns the value of the protected variable _lastInBucket.
+     * @returns The method is returning the value of the variable `_lastInBucket`, which is of type
+     * `number`.
+     */
+    get lastInBucket() {
+      return this._lastInBucket;
+    }
+    /**
+     * The function returns the number of buckets.
+     * @returns The number of buckets.
+     */
+    get bucketCount() {
+      return this._bucketCount;
+    }
     /**
      * The buckets function returns the buckets property of the object.
-     *
      * @return The buckets property
      */
     get buckets() {
@@ -3968,13 +4263,27 @@ var dataStructureTyped = (() => {
       return element;
     }
     /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function checks if the size of an object is equal to zero and returns a boolean value.
+     * @returns A boolean value indicating whether the size of the object is 0 or not.
      */
     isEmpty() {
       return this.size === 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function resets the state of the object by initializing all variables to their default
      * values.
      */
@@ -4119,6 +4428,25 @@ var dataStructureTyped = (() => {
         return newDeque;
       }
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
+     *
+     * The `cutRest` function cuts the elements from a specified position in a deque and returns a new
+     * deque with the cut elements.
+     * @param {number} pos - The `pos` parameter represents the position from which to cut the Deque. It
+     * is a number that indicates the index of the element in the Deque where the cut should start.
+     * @param [isCutSelf=false] - isCutSelf is a boolean parameter that determines whether the original
+     * Deque should be modified or a new Deque should be created. If isCutSelf is true, the original
+     * Deque will be modified by cutting off elements starting from the specified position. If isCutSelf
+     * is false, a new De
+     * @returns The function `cutRest` returns either the modified original deque (`this`) or a new deque
+     * (`newDeque`) depending on the value of the `isCutSelf` parameter.
+     */
     cutRest(pos, isCutSelf = false) {
       if (isCutSelf) {
         if (pos < 0) {
@@ -4140,11 +4468,11 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
      *
      * The `deleteAt` function removes an element at a specified position in an array-like data
      * structure.
@@ -4430,8 +4758,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n) - Due to potential resizing.
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
+     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
+     * Space Complexity: O(n) - Due to potential resizing.
      *
      * The addLast function adds an element to the end of an array.
      * @param {E} element - The element parameter represents the element that you want to add to the end of the
@@ -4441,12 +4769,12 @@ var dataStructureTyped = (() => {
       return this.push(element);
     }
     /**
-     * Time Complexity: O(1) - Removes the first element.
-     * Space Complexity: O(1) - In-place operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function "pollLast" removes and returns the last element of an array.
      * @returns The last element of the array is being returned.
@@ -4455,34 +4783,49 @@ var dataStructureTyped = (() => {
       return this.pop();
     }
     /**
-     * Time Complexity: O(1).
-     * Space Complexity: O(n) - Due to potential resizing.
-     *
-     * The "addFirst" function adds an element to the beginning of an array.
-     * @param {E} element - The parameter "element" represents the element that you want to add to the
-     * beginning of the data structure.
-     */
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       * /
+    
+       /**
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       *
+       * The "addFirst" function adds an element to the beginning of an array.
+       * @param {E} element - The parameter "element" represents the element that you want to add to the
+       * beginning of the data structure.
+       */
     addFirst(element) {
       return this.unshift(element);
     }
     /**
-     * Time Complexity: O(1) - Removes the first element.
-     * Space Complexity: O(1) - In-place operation.
-     *
-     * The function "pollFirst" removes and returns the first element of an array.
-     * @returns The method `pollFirst()` is returning the first element of the array after removing it
-     * from the beginning. If the array is empty, it will return `undefined`.
-     */
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       * /
+    
+       /**
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       *
+       * The function "pollFirst" removes and returns the first element of an array.
+       * @returns The method `pollFirst()` is returning the first element of the array after removing it
+       * from the beginning. If the array is empty, it will return `undefined`.
+       */
     pollFirst() {
       return this.shift();
     }
     /**
-     * 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.
-     */
+       * 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.
+       */
     *_getIterator() {
       for (let i = 0; i < this.size; ++i) {
         yield this.at(i);
@@ -4660,6 +5003,10 @@ var dataStructureTyped = (() => {
       }
       return value;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -4684,11 +5031,11 @@ var dataStructureTyped = (() => {
       this._elements = [];
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the elements array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the elements array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * Clear and add elements of the heap
@@ -4699,11 +5046,11 @@ var dataStructureTyped = (() => {
       return this.fix();
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * Use a comparison function to check whether a binary heap contains a specific element.
@@ -4714,11 +5061,12 @@ var dataStructureTyped = (() => {
       return this.elements.includes(element);
     }
     /**
-     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Time Complexity:  O(n)
      * Space Complexity: O(1)
+     * The worst-case  O(n) This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
      */
     /**
-     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Time Complexity:  O(n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes an element from an array-like data structure, maintaining the order
@@ -4744,12 +5092,13 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
-     * Space Complexity: O(h), where h is the height of the heap.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     * where log n is the height of the heap.
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
-     * Space Complexity: O(h), where h is the height of the heap.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      *
      * Depth-first search (DFS) method, different traversal orders can be selected。
      * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
@@ -4830,12 +5179,12 @@ var dataStructureTyped = (() => {
       return visitedNode;
     }
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * Fix the entire heap to maintain heap properties.
      */
@@ -4918,7 +5267,7 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -4941,6 +5290,10 @@ var dataStructureTyped = (() => {
       this.elements[index] = element;
       return true;
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -5151,11 +5504,11 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -5165,11 +5518,11 @@ var dataStructureTyped = (() => {
       return this.pop();
     }
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -6185,200 +6538,18 @@ var dataStructureTyped = (() => {
       return { costs, predecessor };
     }
     /**
-       * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-       * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-       * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-       * Tarjan can find cycles in directed or undirected graph
-       * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-       * Tarjan solve the bi-connected components of undirected graphs;
-       * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
-       * /
-    
-       /**
-       * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-       * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-       *
-       * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-       * Tarjan can find cycles in directed or undirected graph
-       * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-       * Tarjan solve the bi-connected components of undirected graphs;
-       * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
-       * The `tarjan` function is used to perform various graph analysis tasks such as finding articulation points, bridges,
-       * strongly connected components (SCCs), and cycles in a graph.
-       * @param {boolean} [needCutVertexes] - A boolean value indicating whether or not to calculate and return the
-       * articulation points in the graph. Articulation points are the vertexMap in a graph whose removal would increase the
-       * number of connected components in the graph.
-       * @param {boolean} [needBridges] - A boolean flag indicating whether the algorithm should find and return the bridges
-       * (edgeMap whose removal would increase the number of connected components in the graph).
-       * @param {boolean} [needSCCs] - A boolean value indicating whether the Strongly Connected Components (SCCs) of the
-       * graph are needed. If set to true, the function will calculate and return the SCCs of the graph. If set to false, the
-       * SCCs will not be calculated or returned.
-       * @param {boolean} [needCycles] - A boolean flag indicating whether the algorithm should find cycles in the graph. If
-       * set to true, the algorithm will return a map of cycles, where the keys are the low values of the SCCs and the values
-       * are arrays of vertexMap that form cycles within the SCCs.
-       * @returns The function `tarjan` returns an object with the following properties:
-       */
-    tarjan(needCutVertexes = false, needBridges = false, needSCCs = true, needCycles = false) {
-      const defaultConfig = false;
-      if (needCutVertexes === void 0)
-        needCutVertexes = defaultConfig;
-      if (needBridges === void 0)
-        needBridges = defaultConfig;
-      if (needSCCs === void 0)
-        needSCCs = defaultConfig;
-      if (needCycles === void 0)
-        needCycles = defaultConfig;
-      const dfnMap = /* @__PURE__ */ new Map();
-      const lowMap = /* @__PURE__ */ new Map();
-      const vertexMap = this._vertexMap;
-      vertexMap.forEach((v) => {
-        dfnMap.set(v, -1);
-        lowMap.set(v, Infinity);
-      });
-      const [root] = vertexMap.values();
-      const cutVertexes = [];
-      const bridges = [];
-      let dfn = 0;
-      const dfs = (cur, parent) => {
-        dfn++;
-        dfnMap.set(cur, dfn);
-        lowMap.set(cur, dfn);
-        const neighbors = this.getNeighbors(cur);
-        let childCount = 0;
-        for (const neighbor of neighbors) {
-          if (neighbor !== parent) {
-            if (dfnMap.get(neighbor) === -1) {
-              childCount++;
-              dfs(neighbor, cur);
-            }
-            const childLow = lowMap.get(neighbor);
-            const curLow = lowMap.get(cur);
-            if (curLow !== void 0 && childLow !== void 0) {
-              lowMap.set(cur, Math.min(curLow, childLow));
-            }
-            const curFromMap = dfnMap.get(cur);
-            if (childLow !== void 0 && curFromMap !== void 0) {
-              if (needCutVertexes) {
-                if (cur === root && childCount >= 2 || cur !== root && childLow >= curFromMap) {
-                  cutVertexes.push(cur);
-                }
-              }
-              if (needBridges) {
-                if (childLow > curFromMap) {
-                  const edgeCurToNeighbor = this.getEdge(cur, neighbor);
-                  if (edgeCurToNeighbor) {
-                    bridges.push(edgeCurToNeighbor);
-                  }
-                }
-              }
-            }
+     * O(V+E+C)
+     * O(V+C)
+     */
+    getCycles(isInclude2Cycle = false) {
+      const cycles = [];
+      const visited = /* @__PURE__ */ new Set();
+      const dfs = (vertex, currentPath, visited2) => {
+        if (visited2.has(vertex)) {
+          if ((!isInclude2Cycle && currentPath.length > 2 || isInclude2Cycle && currentPath.length >= 2) && currentPath[0] === vertex.key) {
+            cycles.push([...currentPath]);
           }
-        }
-      };
-      dfs(root, void 0);
-      let SCCs = /* @__PURE__ */ new Map();
-      const getSCCs = () => {
-        const SCCs2 = /* @__PURE__ */ new Map();
-        lowMap.forEach((low, vertex) => {
-          var _a;
-          if (!SCCs2.has(low)) {
-            SCCs2.set(low, [vertex]);
-          } else {
-            (_a = SCCs2.get(low)) == null ? void 0 : _a.push(vertex);
-          }
-        });
-        return SCCs2;
-      };
-      if (needSCCs) {
-        SCCs = getSCCs();
-      }
-      const cycles = /* @__PURE__ */ new Map();
-      if (needCycles) {
-        const visitedMap = /* @__PURE__ */ new Map();
-        const stack = [];
-        const findCyclesDFS = (cur, parent) => {
-          visitedMap.set(cur, true);
-          stack.push(cur);
-          const neighbors = this.getNeighbors(cur);
-          for (const neighbor of neighbors) {
-            if (!visitedMap.get(neighbor)) {
-              findCyclesDFS(neighbor, cur);
-            } else if (stack.includes(neighbor) && neighbor !== parent) {
-              const cycleStartIndex = stack.indexOf(neighbor);
-              const cycle = stack.slice(cycleStartIndex);
-              const cycleLow = Math.min(...cycle.map((v) => dfnMap.get(v) || Infinity));
-              cycles.set(cycleLow, cycle);
-            }
-          }
-          stack.pop();
-        };
-        vertexMap.forEach((v) => {
-          if (!visitedMap.get(v)) {
-            findCyclesDFS(v, void 0);
-          }
-        });
-      }
-      return { dfnMap, lowMap, bridges, cutVertexes, SCCs, cycles };
-    }
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-     */
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-     *
-     * The function returns a map that associates each vertex object with its corresponding depth-first
-     * number.
-     * @returns A Map object with keys of type VO and values of type number.
-     */
-    getDFNMap() {
-      return this.tarjan(false, false, false, false).dfnMap;
-    }
-    /**
-     * The function returns a Map object that contains the low values of each vertex in a Tarjan
-     * algorithm.
-     * @returns The method `getLowMap()` is returning a `Map` object with keys of type `VO` and values of
-     * type `number`.
-     */
-    getLowMap() {
-      return this.tarjan(false, false, false, false).lowMap;
-    }
-    /**
-     * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
-     * @returns an array of VO objects, specifically the cut vertexes.
-     */
-    getCutVertexes() {
-      return this.tarjan(true, false, false, false).cutVertexes;
-    }
-    /**
-     * The function "getSCCs" returns a map of strongly connected components (SCCs) using the Tarjan
-     * algorithm.
-     * @returns a map where the keys are numbers and the values are arrays of VO objects.
-     */
-    getSCCs() {
-      return this.tarjan(false, false, true, false).SCCs;
-    }
-    /**
-     * The function "getBridges" returns an array of bridges using the Tarjan algorithm.
-     * @returns the bridges found using the Tarjan algorithm.
-     */
-    getBridges() {
-      return this.tarjan(false, true, false, false).bridges;
-    }
-    /**
-     * O(V+E+C)
-     * O(V+C)
-     */
-    getCycles(isInclude2Cycle = false) {
-      const cycles = [];
-      const visited = /* @__PURE__ */ new Set();
-      const dfs = (vertex, currentPath, visited2) => {
-        if (visited2.has(vertex)) {
-          if ((!isInclude2Cycle && currentPath.length > 2 || isInclude2Cycle && currentPath.length >= 2) && currentPath[0] === vertex.key) {
-            cycles.push([...currentPath]);
-          }
-          return;
+          return;
         }
         visited2.add(vertex);
         currentPath.push(vertex.key);
@@ -7011,6 +7182,21 @@ var dataStructureTyped = (() => {
     isEmpty() {
       return this.vertexMap.size === 0 && this.inEdgeMap.size === 0 && this.outEdgeMap.size === 0;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the vertex map, in-edge map, and out-edge map.
+     */
+    clear() {
+      this._vertexMap = /* @__PURE__ */ new Map();
+      this._inEdgeMap = /* @__PURE__ */ new Map();
+      this._outEdgeMap = /* @__PURE__ */ new Map();
+    }
     /**
      * The clone function creates a new DirectedGraph object with the same vertices and edges as the original.
      *
@@ -7023,6 +7209,95 @@ var dataStructureTyped = (() => {
       cloned.outEdgeMap = new Map(this.outEdgeMap);
       return cloned;
     }
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
+     */
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
+     *
+     * The function `tarjan` implements the Tarjan's algorithm to find strongly connected components in a
+     * graph.
+     * @returns The function `tarjan()` returns an object with three properties: `dfnMap`, `lowMap`, and
+     * `SCCs`.
+     */
+    tarjan() {
+      const dfnMap = /* @__PURE__ */ new Map();
+      const lowMap = /* @__PURE__ */ new Map();
+      const SCCs = /* @__PURE__ */ new Map();
+      let time = 0;
+      const stack = [];
+      const inStack = /* @__PURE__ */ new Set();
+      const dfs = (vertex) => {
+        dfnMap.set(vertex, time);
+        lowMap.set(vertex, time);
+        time++;
+        stack.push(vertex);
+        inStack.add(vertex);
+        const neighbors = this.getNeighbors(vertex);
+        for (const neighbor of neighbors) {
+          if (!dfnMap.has(neighbor)) {
+            dfs(neighbor);
+            lowMap.set(vertex, Math.min(lowMap.get(vertex), lowMap.get(neighbor)));
+          } else if (inStack.has(neighbor)) {
+            lowMap.set(vertex, Math.min(lowMap.get(vertex), dfnMap.get(neighbor)));
+          }
+        }
+        if (dfnMap.get(vertex) === lowMap.get(vertex)) {
+          const SCC = [];
+          let poppedVertex;
+          do {
+            poppedVertex = stack.pop();
+            inStack.delete(poppedVertex);
+            SCC.push(poppedVertex);
+          } while (poppedVertex !== vertex);
+          SCCs.set(SCCs.size, SCC);
+        }
+      };
+      for (const vertex of this.vertexMap.values()) {
+        if (!dfnMap.has(vertex)) {
+          dfs(vertex);
+        }
+      }
+      return { dfnMap, lowMap, SCCs };
+    }
+    /**
+     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
+     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
+     */
+    /**
+     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
+     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
+     *
+     * The function returns a map that associates each vertex object with its corresponding depth-first
+     * number.
+     * @returns A Map object with keys of type VO and values of type number.
+     */
+    getDFNMap() {
+      return this.tarjan().dfnMap;
+    }
+    /**
+     * The function returns a Map object that contains the low values of each vertex in a Tarjan
+     * algorithm.
+     * @returns The method `getLowMap()` is returning a `Map` object with keys of type `VO` and values of
+     * type `number`.
+     */
+    getLowMap() {
+      return this.tarjan().lowMap;
+    }
+    /**
+     * The function "getSCCs" returns a map of strongly connected components (SCCs) using the Tarjan
+     * algorithm.
+     * @returns a map where the keys are numbers and the values are arrays of VO objects.
+     */
+    getSCCs() {
+      return this.tarjan().SCCs;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -7089,8 +7364,8 @@ var dataStructureTyped = (() => {
      */
     constructor(v1, v2, weight, value) {
       super(weight, value);
-      __publicField(this, "vertexMap");
-      this.vertexMap = [v1, v2];
+      __publicField(this, "endpoints");
+      this.endpoints = [v1, v2];
     }
   };
   var UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
@@ -7141,7 +7416,7 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `getEdge` returns the first edge that connects two vertexMap, or undefined if no such edge exists.
+     * The function `getEdge` returns the first edge that connects two endpoints, or undefined if no such edge exists.
      * @param {VO | VertexKey | undefined} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `undefined`, or `VertexKey` (a string or number representing the ID of a vertex).
      * @param {VO | VertexKey | undefined} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
@@ -7155,7 +7430,7 @@ var dataStructureTyped = (() => {
         const vertex1 = this._getVertex(v1);
         const vertex2 = this._getVertex(v2);
         if (vertex1 && vertex2) {
-          edgeMap = (_a = this._edgeMap.get(vertex1)) == null ? void 0 : _a.filter((e) => e.vertexMap.includes(vertex2.key));
+          edgeMap = (_a = this._edgeMap.get(vertex1)) == null ? void 0 : _a.filter((e) => e.endpoints.includes(vertex2.key));
         }
       }
       return edgeMap ? edgeMap[0] || void 0 : void 0;
@@ -7172,7 +7447,7 @@ var dataStructureTyped = (() => {
      * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
      * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
      * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-     * @returns the removed edge (EO) if it exists, or undefined if either of the vertexMap (VO) does not exist.
+     * @returns the removed edge (EO) if it exists, or undefined if either of the endpoints (VO) does not exist.
      */
     deleteEdgeBetween(v1, v2) {
       const vertex1 = this._getVertex(v1);
@@ -7183,11 +7458,11 @@ var dataStructureTyped = (() => {
       const v1Edges = this._edgeMap.get(vertex1);
       let removed = void 0;
       if (v1Edges) {
-        removed = arrayRemove(v1Edges, (e) => e.vertexMap.includes(vertex2.key))[0] || void 0;
+        removed = arrayRemove(v1Edges, (e) => e.endpoints.includes(vertex2.key))[0] || void 0;
       }
       const v2Edges = this._edgeMap.get(vertex2);
       if (v2Edges) {
-        arrayRemove(v2Edges, (e) => e.vertexMap.includes(vertex1.key));
+        arrayRemove(v2Edges, (e) => e.endpoints.includes(vertex1.key));
       }
       return removed;
     }
@@ -7199,7 +7474,7 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(E), where E is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `deleteEdge` deletes an edge between two vertexMap in a graph.
+     * The function `deleteEdge` deletes an edge between two endpoints in a graph.
      * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
      * either an edge object or a vertex key.
      * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
@@ -7218,8 +7493,8 @@ var dataStructureTyped = (() => {
           return;
         }
       } else {
-        oneSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[0]);
-        otherSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[1]);
+        oneSide = this._getVertex(edgeOrOneSideVertexKey.endpoints[0]);
+        otherSide = this._getVertex(edgeOrOneSideVertexKey.endpoints[1]);
       }
       if (oneSide && otherSide) {
         return this.deleteEdgeBetween(oneSide, otherSide);
@@ -7256,7 +7531,7 @@ var dataStructureTyped = (() => {
           const neighborEdges = this._edgeMap.get(neighbor);
           if (neighborEdges) {
             const restEdges = neighborEdges.filter((edge) => {
-              return !edge.vertexMap.includes(vertexKey);
+              return !edge.endpoints.includes(vertexKey);
             });
             this._edgeMap.set(neighbor, restEdges);
           }
@@ -7337,7 +7612,7 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
      * Space Complexity: O(|E|)
      *
-     * The function "getNeighbors" returns an array of neighboring vertexMap for a given vertex or vertex ID.
+     * The function "getNeighbors" returns an array of neighboring endpoints for a given vertex or vertex ID.
      * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
      * @returns an array of vertexMap (VO[]).
@@ -7348,7 +7623,7 @@ var dataStructureTyped = (() => {
       if (vertex) {
         const neighborEdges = this.edgesOf(vertex);
         for (const edge of neighborEdges) {
-          const neighbor = this._getVertex(edge.vertexMap.filter((e) => e !== vertex.key)[0]);
+          const neighbor = this._getVertex(edge.endpoints.filter((e) => e !== vertex.key)[0]);
           if (neighbor) {
             neighbors.push(neighbor);
           }
@@ -7364,18 +7639,18 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function "getEndsOfEdge" returns the vertexMap at the ends of an edge if the edge exists in the graph, otherwise
+     * The function "getEndsOfEdge" returns the endpoints at the ends of an edge if the edge exists in the graph, otherwise
      * it returns undefined.
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertexMap `[VO, VO]` if the edge exists in the
+     * @returns The function `getEndsOfEdge` returns an array containing two endpoints `[VO, VO]` if the edge exists in the
      * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge) {
-      if (!this.hasEdge(edge.vertexMap[0], edge.vertexMap[1])) {
+      if (!this.hasEdge(edge.endpoints[0], edge.endpoints[1])) {
         return void 0;
       }
-      const v1 = this._getVertex(edge.vertexMap[0]);
-      const v2 = this._getVertex(edge.vertexMap[1]);
+      const v1 = this._getVertex(edge.endpoints[0]);
+      const v2 = this._getVertex(edge.endpoints[1]);
       if (v1 && v2) {
         return [v1, v2];
       } else {
@@ -7389,6 +7664,20 @@ var dataStructureTyped = (() => {
     isEmpty() {
       return this.vertexMap.size === 0 && this.edgeMap.size === 0;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the vertex and edge maps to empty maps.
+     */
+    clear() {
+      this._vertexMap = /* @__PURE__ */ new Map();
+      this._edgeMap = /* @__PURE__ */ new Map();
+    }
     /**
      * The clone function creates a new UndirectedGraph object and copies the
      * vertexMap and edgeMap from this graph to the new one. This is done by
@@ -7408,6 +7697,96 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *   Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  1. Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time
+     *
+     * The function `tarjan` implements the Tarjan's algorithm to find bridges and cut vertices in a
+     * graph.
+     * @returns The function `tarjan()` returns an object with the following properties:
+     */
+    tarjan() {
+      const dfnMap = /* @__PURE__ */ new Map();
+      const lowMap = /* @__PURE__ */ new Map();
+      const bridges = [];
+      const cutVertices = [];
+      let time = 0;
+      const dfs = (vertex, parent) => {
+        dfnMap.set(vertex, time);
+        lowMap.set(vertex, time);
+        time++;
+        const neighbors = this.getNeighbors(vertex);
+        let childCount = 0;
+        for (const neighbor of neighbors) {
+          if (!dfnMap.has(neighbor)) {
+            childCount++;
+            dfs(neighbor, vertex);
+            lowMap.set(vertex, Math.min(lowMap.get(vertex), lowMap.get(neighbor)));
+            if (lowMap.get(neighbor) > dfnMap.get(vertex)) {
+              const edge = this.getEdge(vertex, neighbor);
+              if (edge) {
+                bridges.push(edge);
+              }
+            }
+            if (parent !== void 0 && lowMap.get(neighbor) >= dfnMap.get(vertex)) {
+              cutVertices.push(vertex);
+            }
+          } else if (neighbor !== parent) {
+            lowMap.set(vertex, Math.min(lowMap.get(vertex), dfnMap.get(neighbor)));
+          }
+        }
+        if (parent === void 0 && childCount > 1) {
+          cutVertices.push(vertex);
+        }
+      };
+      for (const vertex of this.vertexMap.values()) {
+        if (!dfnMap.has(vertex)) {
+          dfs(vertex, void 0);
+        }
+      }
+      return {
+        dfnMap,
+        lowMap,
+        bridges,
+        cutVertices
+      };
+    }
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  1. Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time
+     */
+    /**
+     * The function "getBridges" returns an array of bridges in a graph using the Tarjan's algorithm.
+     * @returns The function `getBridges()` is returning the bridges found using the Tarjan's algorithm.
+     */
+    getBridges() {
+      return this.tarjan().bridges;
+    }
+    /**
+     * The function "getCutVertices" returns an array of cut vertices using the Tarjan's algorithm.
+     * @returns the cut vertices found using the Tarjan's algorithm.
+     */
+    getCutVertices() {
+      return this.tarjan().cutVertices;
+    }
+    /**
+     * The function returns the dfnMap property of the result of the tarjan() function.
+     * @returns the `dfnMap` property of the result of calling the `tarjan()` function.
+     */
+    getDFNMap() {
+      return this.tarjan().dfnMap;
+    }
+    /**
+     * The function returns the lowMap property of the result of the tarjan() function.
+     * @returns the lowMap property of the result of calling the tarjan() function.
+     */
+    getLowMap() {
+      return this.tarjan().lowMap;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -7417,7 +7796,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     _addEdge(edge) {
-      for (const end of edge.vertexMap) {
+      for (const end of edge.endpoints) {
         const endVertex = this._getVertex(end);
         if (endVertex === void 0)
           return false;
@@ -7579,7 +7958,7 @@ var dataStructureTyped = (() => {
     /**
      * The constructor function initializes an object with a key and an optional value.
      * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
-     * constructor. It is used to set the value of the "key" property of the object being created.
+     * constructor. It is used to set the key property of the object being created.
      * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
      * value associated with the key in the constructor.
      */
@@ -9263,18 +9642,37 @@ var dataStructureTyped = (() => {
       this._left = void 0;
       this._right = void 0;
     }
+    /**
+     * The function returns the value of the `_left` property.
+     * @returns The `_left` property of the current object is being returned.
+     */
     get left() {
       return this._left;
     }
+    /**
+     * The function sets the left child of a node and updates the parent reference of the child.
+     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be an
+     * instance of the `NODE` class or `undefined`.
+     */
     set left(v) {
       if (v) {
         v.parent = this;
       }
       this._left = v;
     }
+    /**
+     * The function returns the right node of a binary tree or undefined if there is no right node.
+     * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
+     * `undefined`.
+     */
     get right() {
       return this._right;
     }
+    /**
+     * The function sets the right child of a node and updates the parent reference of the child.
+     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be a
+     * `NODE` object or `undefined`.
+     */
     set right(v) {
       if (v) {
         v.parent = this;
@@ -9284,10 +9682,10 @@ var dataStructureTyped = (() => {
   };
   var BST = class _BST extends BinaryTree {
     /**
-     * This is the constructor function for a binary search tree class in TypeScript, which initializes
-     * the tree with optional keysOrNodesOrEntries and options.
-     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
-     * binary search tree.
+     * This is the constructor function for a TypeScript class that initializes a binary search tree with
+     * optional keys or nodes or entries and options.
+     * @param keysOrNodesOrEntries - An iterable object that contains keys, nodes, or entries. It is used
+     * to initialize the binary search tree with the provided keys, nodes, or entries.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
@@ -9304,19 +9702,27 @@ var dataStructureTyped = (() => {
       if (keysOrNodesOrEntries)
         this.addMany(keysOrNodesOrEntries);
     }
+    /**
+     * The function returns the root node of a tree structure.
+     * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
+     */
     get root() {
       return this._root;
     }
+    /**
+     * The function returns the value of the _variant property.
+     * @returns The value of the `_variant` property.
+     */
     get variant() {
       return this._variant;
     }
     /**
-     * The function creates a new binary search tree node with the given key and value.
-     * @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.
-     * @returns a new instance of the BSTNode class with the specified key and value.
+     * The function creates a new BSTNode with the given key and value and returns it.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
+     * being created.
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
+     * value associated with the key in the node being created.
+     * @returns The method is returning a new instance of the BSTNode class, casted as the NODE type.
      */
     createNode(key, value) {
       return new BSTNode(key, value);
@@ -9324,9 +9730,10 @@ var dataStructureTyped = (() => {
     /**
      * The function creates a new binary search tree with the specified options.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
-     * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which is a type
-     * that defines various options for creating a binary search tree.
-     * @returns a new instance of the BST class with the specified options.
+     * behavior of the `createTree` method. It is of type `Partial<BSTOptions<K>>`, which means it is a
+     * partial object of type `BSTOptions<K>`.
+     * @returns a new instance of the BST class, with the provided options merged with the default
+     * options. The returned value is casted as TREE.
      */
     createTree(options) {
       return new _BST([], __spreadValues({
@@ -9816,11 +10223,9 @@ var dataStructureTyped = (() => {
           const compared = this._compare(cur.key, targetKey);
           if (compared === lesserOrGreater)
             ans.push(callback(cur));
-          if (!cur.left && !cur.right)
-            return;
-          if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
+          if (this.isRealNode(cur.left))
             _traverse(cur.left);
-          if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
+          if (this.isRealNode(cur.right))
             _traverse(cur.right);
         };
         _traverse(this.root);
@@ -9829,13 +10234,13 @@ var dataStructureTyped = (() => {
         const queue = new Queue([this.root]);
         while (queue.size > 0) {
           const cur = queue.shift();
-          if (cur) {
+          if (this.isRealNode(cur)) {
             const compared = this._compare(cur.key, targetKey);
             if (compared === lesserOrGreater)
               ans.push(callback(cur));
-            if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
+            if (this.isRealNode(cur.left))
               queue.push(cur.left);
-            if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
+            if (this.isRealNode(cur.right))
               queue.push(cur.right);
           }
         }
@@ -9957,6 +10362,11 @@ var dataStructureTyped = (() => {
       }
       return balanced;
     }
+    /**
+     * The function sets the root property of an object and updates the parent property of the new root.
+     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. This means that it
+     * can either be an object of type `NODE` or it can be `undefined`.
+     */
     _setRoot(v) {
       if (v) {
         v.parent = void 0;
@@ -9999,18 +10409,40 @@ var dataStructureTyped = (() => {
       this._msb = getMSB(max);
       this._negativeCount = frequency < 0 ? max : 0;
     }
+    /**
+     * The function returns the frequency map of numbers.
+     * @returns The `_freqMap` property, which is a record with number keys and number values, is being
+     * returned.
+     */
     get freqMap() {
       return this._freqMap;
     }
+    /**
+     * The function returns the value of the _msb property.
+     * @returns The `_msb` property of the object.
+     */
     get msb() {
       return this._msb;
     }
+    /**
+     * The function returns the value of the _negativeCount property.
+     * @returns The method is returning the value of the variable `_negativeCount`, which is of type
+     * `number`.
+     */
     get negativeCount() {
       return this._negativeCount;
     }
+    /**
+     * The above function returns the value of the protected variable `_freq`.
+     * @returns The frequency value stored in the protected variable `_freq`.
+     */
     get freq() {
       return this._freq;
     }
+    /**
+     * The above function returns the maximum value.
+     * @returns The maximum value stored in the variable `_max`.
+     */
     get max() {
       return this._max;
     }
@@ -10243,60 +10675,177 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/binary-tree/segment-tree.ts
   var SegmentTreeNode = class {
-    constructor(start, end, sum, value) {
-      __publicField(this, "start", 0);
-      __publicField(this, "end", 0);
-      __publicField(this, "value");
-      __publicField(this, "sum", 0);
-      __publicField(this, "left");
-      __publicField(this, "right");
-      this.start = start;
-      this.end = end;
-      this.sum = sum;
-      this.value = value || void 0;
-    }
-  };
-  var SegmentTree = class {
     /**
-     * The constructor initializes the values, start, end, and root properties of an object.
-     * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
-     * @param {number} [start] - The `start` parameter is the index of the first element in the `values` array that should
-     * be included in the range. If no value is provided for `start`, it defaults to 0, which means the range starts from
-     * the beginning of the array.
-     * @param {number} [end] - The "end" parameter is the index of the last element in the "values" array that should be
-     * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
+     * The constructor initializes the properties of a SegmentTreeNode object.
+     * @param {number} start - The `start` parameter represents the starting index of the segment covered
+     * by this node in a segment tree.
+     * @param {number} end - The `end` parameter represents the end index of the segment covered by this
+     * node in a segment tree.
+     * @param {number} sum - The `sum` parameter represents the sum of the values in the range covered by
+     * the segment tree node.
+     * @param {SegmentTreeNodeVal | undefined} [value] - The `value` parameter is an optional parameter
+     * of type `SegmentTreeNodeVal`. It represents the value associated with the segment tree node.
      */
-    constructor(values, start, end) {
-      __publicField(this, "_values", []);
+    constructor(start, end, sum, value) {
       __publicField(this, "_start", 0);
-      __publicField(this, "_end");
-      __publicField(this, "_root");
-      start = start || 0;
-      end = end || values.length - 1;
-      this._values = values;
+      __publicField(this, "_end", 0);
+      __publicField(this, "_value");
+      __publicField(this, "_sum", 0);
+      __publicField(this, "_left");
+      __publicField(this, "_right");
       this._start = start;
       this._end = end;
-      if (values.length > 0) {
-        this._root = this.build(start, end);
-      } else {
-        this._root = void 0;
-        this._values = [];
-      }
-    }
-    get values() {
-      return this._values;
+      this._sum = sum;
+      this._value = value || void 0;
     }
+    /**
+     * The function returns the value of the protected variable _start.
+     * @returns The start value, which is of type number.
+     */
     get start() {
       return this._start;
     }
+    /**
+     * The above function sets the value of the "start" property.
+     * @param {number} value - The value parameter is of type number.
+     */
+    set start(value) {
+      this._start = value;
+    }
+    /**
+     * The function returns the value of the protected variable `_end`.
+     * @returns The value of the protected property `_end`.
+     */
     get end() {
       return this._end;
     }
-    get root() {
-      return this._root;
+    /**
+     * The above function sets the value of the "end" property.
+     * @param {number} value - The value parameter is a number that represents the new value for the end
+     * property.
+     */
+    set end(value) {
+      this._end = value;
     }
     /**
-     * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
+     * The function returns the value of a segment tree node.
+     * @returns The value being returned is either a `SegmentTreeNodeVal` object or `undefined`.
+     */
+    get value() {
+      return this._value;
+    }
+    /**
+     * The function sets the value of a segment tree node.
+     * @param {SegmentTreeNodeVal | undefined} value - The `value` parameter is of type
+     * `SegmentTreeNodeVal` or `undefined`.
+     */
+    set value(value) {
+      this._value = value;
+    }
+    /**
+     * The function returns the value of the sum property.
+     * @returns The method is returning the value of the variable `_sum`.
+     */
+    get sum() {
+      return this._sum;
+    }
+    /**
+     * The above function sets the value of the sum property.
+     * @param {number} value - The parameter "value" is of type "number".
+     */
+    set sum(value) {
+      this._sum = value;
+    }
+    /**
+     * The function returns the left child of a segment tree node.
+     * @returns The `left` property of the `SegmentTreeNode` object is being returned. It is of type
+     * `SegmentTreeNode` or `undefined`.
+     */
+    get left() {
+      return this._left;
+    }
+    /**
+     * The function sets the value of the left property of a SegmentTreeNode object.
+     * @param {SegmentTreeNode | undefined} value - The value parameter is of type SegmentTreeNode or
+     * undefined.
+     */
+    set left(value) {
+      this._left = value;
+    }
+    /**
+     * The function returns the right child of a segment tree node.
+     * @returns The `getRight()` method is returning a value of type `SegmentTreeNode` or `undefined`.
+     */
+    get right() {
+      return this._right;
+    }
+    /**
+     * The function sets the right child of a segment tree node.
+     * @param {SegmentTreeNode | undefined} value - The `value` parameter is of type `SegmentTreeNode |
+     * undefined`. This means that it can accept either a `SegmentTreeNode` object or `undefined` as its
+     * value.
+     */
+    set right(value) {
+      this._right = value;
+    }
+  };
+  var SegmentTree = class {
+    /**
+     * The constructor initializes the values, start, end, and root properties of an object.
+     * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
+     * @param {number} [start] - The `start` parameter is the index of the first element in the `values` array that should
+     * be included in the range. If no value is provided for `start`, it defaults to 0, which means the range starts from
+     * the beginning of the array.
+     * @param {number} [end] - The "end" parameter is the index of the last element in the "values" array that should be
+     * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
+     */
+    constructor(values, start, end) {
+      __publicField(this, "_values", []);
+      __publicField(this, "_start", 0);
+      __publicField(this, "_end");
+      __publicField(this, "_root");
+      start = start || 0;
+      end = end || values.length - 1;
+      this._values = values;
+      this._start = start;
+      this._end = end;
+      if (values.length > 0) {
+        this._root = this.build(start, end);
+      } else {
+        this._root = void 0;
+        this._values = [];
+      }
+    }
+    /**
+     * The function returns an array of numbers.
+     * @returns An array of numbers is being returned.
+     */
+    get values() {
+      return this._values;
+    }
+    /**
+     * The function returns the value of the protected variable _start.
+     * @returns The start value, which is of type number.
+     */
+    get start() {
+      return this._start;
+    }
+    /**
+     * The function returns the value of the protected variable `_end`.
+     * @returns The value of the protected property `_end`.
+     */
+    get end() {
+      return this._end;
+    }
+    /**
+     * The function returns the root node of a segment tree.
+     * @returns The `root` property of the class `SegmentTreeNode` or `undefined` if it is not defined.
+     */
+    get root() {
+      return this._root;
+    }
+    /**
+     * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
      * the sum of values to each segment.
      * @param {number} start - The `start` parameter represents the starting index of the segment or range for which we are
      * building the segment tree.
@@ -10407,10 +10956,33 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/binary-tree/avl-tree.ts
   var AVLTreeNode = class extends BSTNode {
+    /**
+     * The constructor function initializes a new instance of a class with a key and an optional value,
+     * and sets the height property to 0.
+     * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
+     * constructor. It is used to initialize the key property of the object being created.
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
+     * value associated with the key in the constructor.
+     */
     constructor(key, value) {
       super(key, value);
-      __publicField(this, "height");
-      this.height = 0;
+      __publicField(this, "_height");
+      this._height = 0;
+    }
+    /**
+     * The function returns the value of the height property.
+     * @returns The height of the object.
+     */
+    get height() {
+      return this._height;
+    }
+    /**
+     * The above function sets the value of the height property.
+     * @param {number} value - The value parameter is a number that represents the new height value to be
+     * set.
+     */
+    set height(value) {
+      this._height = value;
     }
   };
   var AVLTree = class _AVLTree extends BST {
@@ -10817,6 +11389,15 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    /**
+     * The function replaces an old node with a new node while preserving the height of the old node.
+     * @param {NODE} oldNode - The `oldNode` parameter is the node that you want to replace with the
+     * `newNode`.
+     * @param {NODE} newNode - The `newNode` parameter is the new node that will replace the `oldNode` in
+     * the data structure.
+     * @returns the result of calling the `_replaceNode` method on the superclass, passing in the
+     * `oldNode` and `newNode` as arguments.
+     */
     _replaceNode(oldNode, newNode) {
       newNode.height = oldNode.height;
       return super._replaceNode(oldNode, newNode);
@@ -10825,10 +11406,35 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/binary-tree/rb-tree.ts
   var RedBlackTreeNode = class extends BSTNode {
+    /**
+     * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
+     * color.
+     * @param {K} key - The key parameter is of type K and represents the key of the node in the
+     * Red-Black Tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the Red-Black Tree Node. It is not required and can be omitted when
+     * creating a new instance of the Red-Black Tree Node.
+     * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
+     * Tree Node. It is an optional parameter with a default value of `RBTNColor.BLACK`.
+     */
     constructor(key, value, color = 0 /* BLACK */) {
       super(key, value);
-      __publicField(this, "color");
-      this.color = color;
+      __publicField(this, "_color");
+      this._color = color;
+    }
+    /**
+     * The function returns the color value of a variable.
+     * @returns The color value stored in the protected variable `_color`.
+     */
+    get color() {
+      return this._color;
+    }
+    /**
+     * The function sets the color property to the specified value.
+     * @param {RBTNColor} value - The value parameter is of type RBTNColor.
+     */
+    set color(value) {
+      this._color = value;
     }
   };
   var RedBlackTree = class _RedBlackTree extends BST {
@@ -10845,16 +11451,31 @@ var dataStructureTyped = (() => {
      */
     constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
-      __publicField(this, "Sentinel", new RedBlackTreeNode(NaN));
+      __publicField(this, "_Sentinel", new RedBlackTreeNode(NaN));
       __publicField(this, "_root");
       __publicField(this, "_size", 0);
-      this._root = this.Sentinel;
+      this._root = this._Sentinel;
       if (keysOrNodesOrEntries)
         super.addMany(keysOrNodesOrEntries);
     }
+    /**
+     * The function returns the value of the `_Sentinel` property.
+     * @returns The method is returning the value of the `_Sentinel` property.
+     */
+    get Sentinel() {
+      return this._Sentinel;
+    }
+    /**
+     * The function returns the root node.
+     * @returns The root node of the data structure.
+     */
     get root() {
       return this._root;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size() {
       return this._size;
     }
@@ -10922,8 +11543,14 @@ var dataStructureTyped = (() => {
     isNode(keyOrNodeOrEntry) {
       return keyOrNodeOrEntry instanceof RedBlackTreeNode;
     }
+    /**
+     * The function checks if a given node is a real node in a Red-Black Tree.
+     * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
+     * it can either be of type `NODE` or `undefined`.
+     * @returns a boolean value.
+     */
     isRealNode(node) {
-      if (node === this.Sentinel || node === void 0)
+      if (node === this._Sentinel || node === void 0)
         return false;
       return node instanceof RedBlackTreeNode;
     }
@@ -10948,11 +11575,11 @@ var dataStructureTyped = (() => {
       const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
       if (newNode === void 0)
         return false;
-      newNode.left = this.Sentinel;
-      newNode.right = this.Sentinel;
+      newNode.left = this._Sentinel;
+      newNode.right = this._Sentinel;
       let y = void 0;
       let x = this.root;
-      while (x !== this.Sentinel) {
+      while (x !== this._Sentinel) {
         y = x;
         if (x) {
           if (newNode.key < x.key) {
@@ -11012,9 +11639,9 @@ var dataStructureTyped = (() => {
       if (identifier === null)
         return ans;
       const helper = (node) => {
-        let z = this.Sentinel;
+        let z = this._Sentinel;
         let x, y;
-        while (node !== this.Sentinel) {
+        while (node !== this._Sentinel) {
           if (node && callback(node) === identifier) {
             z = node;
           }
@@ -11024,16 +11651,16 @@ var dataStructureTyped = (() => {
             node = node == null ? void 0 : node.left;
           }
         }
-        if (z === this.Sentinel) {
+        if (z === this._Sentinel) {
           this._size--;
           return;
         }
         y = z;
         let yOriginalColor = y.color;
-        if (z.left === this.Sentinel) {
+        if (z.left === this._Sentinel) {
           x = z.right;
           this._rbTransplant(z, z.right);
-        } else if (z.right === this.Sentinel) {
+        } else if (z.right === this._Sentinel) {
           x = z.left;
           this._rbTransplant(z, z.left);
         } else {
@@ -11097,8 +11724,14 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The "clear" function sets the root node to the sentinel node and resets the size to 0.
+     */
     clear() {
-      this._root = this.Sentinel;
+      this._root = this._Sentinel;
       this._size = 0;
     }
     /**
@@ -11125,6 +11758,12 @@ var dataStructureTyped = (() => {
       }
       return y;
     }
+    /**
+     * The function sets the root node of a tree structure and updates the parent property of the new
+     * root node.
+     * @param {NODE} v - The parameter "v" is of type "NODE", which represents a node in a data
+     * structure.
+     */
     _setRoot(v) {
       if (v) {
         v.parent = void 0;
@@ -11146,7 +11785,7 @@ var dataStructureTyped = (() => {
       if (x.right) {
         const y = x.right;
         x.right = y.left;
-        if (y.left !== this.Sentinel) {
+        if (y.left !== this._Sentinel) {
           if (y.left)
             y.left.parent = x;
         }
@@ -11178,7 +11817,7 @@ var dataStructureTyped = (() => {
       if (x.left) {
         const y = x.left;
         x.left = y.right;
-        if (y.right !== this.Sentinel) {
+        if (y.right !== this._Sentinel) {
           if (y.right)
             y.right.parent = x;
         }
@@ -11208,12 +11847,12 @@ var dataStructureTyped = (() => {
      */
     _fixInsert(k) {
       let u;
-      while (k.parent && k.parent.color === 1) {
+      while (k.parent && k.parent.color === 1 /* RED */) {
         if (k.parent.parent && k.parent === k.parent.parent.right) {
           u = k.parent.parent.left;
-          if (u && u.color === 1) {
-            u.color = 0 /* BLACK */;
+          if (u && u.color === 1 /* RED */) {
             k.parent.color = 0 /* BLACK */;
+            u.color = 0 /* BLACK */;
             k.parent.parent.color = 1 /* RED */;
             k = k.parent.parent;
           } else {
@@ -11221,15 +11860,17 @@ var dataStructureTyped = (() => {
               k = k.parent;
               this._rightRotate(k);
             }
-            k.parent.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
+            if (k.parent.color === 1 /* RED */) {
+              k.parent.color = 0 /* BLACK */;
+              k.parent.parent.color = 1 /* RED */;
+            }
             this._leftRotate(k.parent.parent);
           }
         } else {
           u = k.parent.parent.right;
-          if (u && u.color === 1) {
-            u.color = 0 /* BLACK */;
+          if (u && u.color === 1 /* RED */) {
             k.parent.color = 0 /* BLACK */;
+            u.color = 0 /* BLACK */;
             k.parent.parent.color = 1 /* RED */;
             k = k.parent.parent;
           } else {
@@ -11237,8 +11878,10 @@ var dataStructureTyped = (() => {
               k = k.parent;
               this._leftRotate(k);
             }
-            k.parent.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
+            if (k.parent.color === 1 /* RED */) {
+              k.parent.color = 0 /* BLACK */;
+              k.parent.parent.color = 1 /* RED */;
+            }
             this._rightRotate(k.parent.parent);
           }
         }
@@ -11357,8 +12000,8 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/data-structures/binary-tree/tree-multimap.ts
-  var TreeMultimapNode = class extends AVLTreeNode {
+  // src/data-structures/binary-tree/avl-tree-multi-map.ts
+  var AVLTreeMultiMapNode = class extends AVLTreeNode {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -11371,11 +12014,26 @@ var dataStructureTyped = (() => {
      */
     constructor(key, value, count = 1) {
       super(key, value);
-      __publicField(this, "count");
+      __publicField(this, "_count", 1);
       this.count = count;
     }
+    /**
+     * The function returns the value of the protected variable _count.
+     * @returns The count property of the object, which is of type number.
+     */
+    get count() {
+      return this._count;
+    }
+    /**
+     * The above function sets the value of the count property.
+     * @param {number} value - The value parameter is of type number, which means it can accept any
+     * numeric value.
+     */
+    set count(value) {
+      this._count = value;
+    }
   };
-  var TreeMultimap = class _TreeMultimap extends AVLTree {
+  var AVLTreeMultiMap = class _AVLTreeMultiMap extends AVLTree {
     constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
@@ -11383,6 +12041,11 @@ var dataStructureTyped = (() => {
         this.addMany(keysOrNodesOrEntries);
     }
     // TODO the _count is not accurate after nodes count modified
+    /**
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
     get count() {
       let sum = 0;
       this.dfs((node) => sum += node.count);
@@ -11398,10 +12061,19 @@ var dataStructureTyped = (() => {
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
     createNode(key, value, count) {
-      return new TreeMultimapNode(key, value, count);
+      return new AVLTreeMultiMapNode(key, value, count);
     }
+    /**
+     * The function creates a new AVLTreeMultiMap object with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `AVLTreeMultiMap` object. It can include properties such as
+     * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
+     * the tree, respectively. These properties can be
+     * @returns a new instance of the `AVLTreeMultiMap` class, with the provided options merged with the
+     * default options. The returned value is casted as `TREE`.
+     */
     createTree(options) {
-      return new _TreeMultimap([], __spreadValues({
+      return new _AVLTreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
         variant: this.variant
       }, options));
@@ -11438,13 +12110,13 @@ var dataStructureTyped = (() => {
       return node;
     }
     /**
-     * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+     * The function checks if an keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode class.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode
      * class.
      */
     isNode(keyOrNodeOrEntry) {
-      return keyOrNodeOrEntry instanceof TreeMultimapNode;
+      return keyOrNodeOrEntry instanceof AVLTreeMultiMapNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -11662,6 +12334,380 @@ var dataStructureTyped = (() => {
       }
       return void 0;
     }
+    /**
+     * The function replaces an old node with a new node and updates the count property of the new node.
+     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+     * needs to be replaced in a data structure.
+     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, after updating the `count` property of the `newNode` object.
+     */
+    _replaceNode(oldNode, newNode) {
+      newNode.count = oldNode.count + newNode.count;
+      return super._replaceNode(oldNode, newNode);
+    }
+  };
+
+  // src/data-structures/binary-tree/tree-multi-map.ts
+  var TreeMultiMapNode = class extends RedBlackTreeNode {
+    /**
+     * The constructor function initializes an instance of a class with a key, value, and count.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key for the
+     * constructor. It is required and must be provided when creating an instance of the class.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+     * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
+     * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
+     * 1.
+     */
+    constructor(key, value, count = 1) {
+      super(key, value);
+      __publicField(this, "_count", 1);
+      this.count = count;
+    }
+    /**
+     * The function returns the value of the private variable _count.
+     * @returns The count property of the object, which is of type number.
+     */
+    get count() {
+      return this._count;
+    }
+    /**
+     * The above function sets the value of the count property.
+     * @param {number} value - The value parameter is of type number, which means it can accept any
+     * numeric value.
+     */
+    set count(value) {
+      this._count = value;
+    }
+  };
+  var TreeMultiMap = class _TreeMultiMap extends RedBlackTree {
+    /**
+     * The constructor function initializes a new instance of the TreeMultiMap class with optional
+     * initial keys, nodes, or entries.
+     * @param keysOrNodesOrEntries - The `keysOrNodesOrEntries` parameter is an iterable object that can
+     * contain keys, nodes, or entries. It is used to initialize the TreeMultiMap with the provided keys,
+     * nodes, or entries.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the
+     * constructor. It allows you to customize the behavior of the `TreeMultiMap` instance.
+     */
+    constructor(keysOrNodesOrEntries = [], options) {
+      super([], options);
+      __publicField(this, "_count", 0);
+      if (keysOrNodesOrEntries)
+        this.addMany(keysOrNodesOrEntries);
+    }
+    // TODO the _count is not accurate after nodes count modified
+    /**
+     * The function calculates the sum of the count property of all nodes in a tree structure.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    get count() {
+      let sum = 0;
+      this.dfs((node) => sum += node.count);
+      return sum;
+    }
+    /**
+     * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
+     * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
+     * which is a generic type that can be replaced with any specific type when using the function.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the node. It is of type `V`, which can be any data type.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of a
+     * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
+     * default to 1.
+     * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+     */
+    createNode(key, value, count) {
+      return new TreeMultiMapNode(key, value, count);
+    }
+    /**
+     * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `TreeMultiMap`. It can include properties such as
+     * `keyComparator`, `valueComparator`, `allowDuplicates`, etc.
+     * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
+     * existing `iterationType` option. The returned value is casted as `TREE`.
+     */
+    createTree(options) {
+      return new _TreeMultiMap([], __spreadValues({
+        iterationType: this.iterationType
+      }, options));
+    }
+    /**
+     * The function `keyValueOrEntryToNode` takes a key, value, and count and returns a node if the input
+     * is valid.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
+     * NODE>`. It can accept three types of values:
+     * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
+     * value associated with a key in a key-value pair.
+     * @param [count=1] - The count parameter is an optional parameter that specifies the number of times
+     * the key-value pair should be added to the node. If not provided, it defaults to 1.
+     * @returns a NODE object or undefined.
+     */
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value, count = 1) {
+      let node;
+      if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
+        return;
+      } else if (this.isNode(keyOrNodeOrEntry)) {
+        node = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value2] = keyOrNodeOrEntry;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          node = this.createNode(key, value2, count);
+        }
+      } else if (!this.isNode(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, value, count);
+      } else {
+        return;
+      }
+      return node;
+    }
+    /**
+     * The function "isNode" checks if a given key, node, or entry is an instance of the TreeMultiMapNode
+     * class.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
+     * NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntry` is an instance
+     * of the `TreeMultiMapNode` class.
+     */
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof TreeMultiMapNode;
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function overrides the add method in TypeScript and adds a new node to the data structure.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
+     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+     * data structure.
+     * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
+     * be added to the data structure. By default, it is set to 1, meaning that the key-value pair will
+     * be added once. However, you can specify a different value for `count` if you want to add
+     * @returns a boolean value.
+     */
+    add(keyOrNodeOrEntry, value, count = 1) {
+      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
+      if (newNode === void 0)
+        return false;
+      const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
+      const inserted = super.add(newNode);
+      if (inserted) {
+        this._count += orgNodeCount;
+      }
+      return true;
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The `delete` function in a TypeScript class is used to delete nodes from a binary tree based on a
+     * given identifier, and it returns an array of results containing information about the deleted
+     * nodes.
+     * @param {ReturnType<C> | null | undefined} identifier - The identifier parameter is the value used
+     * to identify the node to be deleted. It can be of any type that is returned by the callback
+     * function. It can also be null or undefined if no node needs to be deleted.
+     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
+     * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
+     * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+     * used
+     * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
+     * node when performing deletion. If set to true, the count of the target node will not be considered
+     * and the node will be deleted regardless of its count. If set to false (default), the count of the
+     * target node will be decremented
+     * @returns an array of BinaryTreeDeleteResult<NODE> objects.
+     */
+    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
+      const deleteResults = [];
+      if (identifier === null)
+        return deleteResults;
+      const deleteHelper = (node) => {
+        let targetNode = this._Sentinel;
+        let currentNode;
+        while (node !== this._Sentinel) {
+          if (node && callback(node) === identifier) {
+            targetNode = node;
+          }
+          if (node && identifier && callback(node) <= identifier) {
+            node = node.right;
+          } else {
+            node = node == null ? void 0 : node.left;
+          }
+        }
+        if (targetNode === this._Sentinel) {
+          return;
+        }
+        if (ignoreCount || targetNode.count <= 1) {
+          let parentNode = targetNode;
+          let parentNodeOriginalColor = parentNode.color;
+          if (targetNode.left === this._Sentinel) {
+            currentNode = targetNode.right;
+            this._rbTransplant(targetNode, targetNode.right);
+          } else if (targetNode.right === this._Sentinel) {
+            currentNode = targetNode.left;
+            this._rbTransplant(targetNode, targetNode.left);
+          } else {
+            parentNode = this.getLeftMost(targetNode.right);
+            parentNodeOriginalColor = parentNode.color;
+            currentNode = parentNode.right;
+            if (parentNode.parent === targetNode) {
+              currentNode.parent = parentNode;
+            } else {
+              this._rbTransplant(parentNode, parentNode.right);
+              parentNode.right = targetNode.right;
+              parentNode.right.parent = parentNode;
+            }
+            this._rbTransplant(targetNode, parentNode);
+            parentNode.left = targetNode.left;
+            parentNode.left.parent = parentNode;
+            parentNode.color = targetNode.color;
+          }
+          if (parentNodeOriginalColor === 0 /* BLACK */) {
+            this._fixDelete(currentNode);
+          }
+          this._size--;
+          this._count -= targetNode.count;
+          deleteResults.push({ deleted: targetNode, needBalanced: void 0 });
+        } else {
+          targetNode.count--;
+          this._count--;
+        }
+      };
+      deleteHelper(this.root);
+      return deleteResults;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The "clear" function overrides the parent class's "clear" function and also resets the count to
+     * zero.
+     */
+    clear() {
+      super.clear();
+      this._count = 0;
+    }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     *
+     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
+     * tree using either a recursive or iterative approach.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building the balanced binary search tree. It can have two possible
+     * values:
+     * @returns a boolean value.
+     */
+    perfectlyBalance(iterationType = this.iterationType) {
+      const sorted = this.dfs((node) => node, "in"), n = sorted.length;
+      if (sorted.length < 1)
+        return false;
+      this.clear();
+      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+        const buildBalanceBST = (l, r) => {
+          if (l > r)
+            return;
+          const m = l + Math.floor((r - l) / 2);
+          const midNode = sorted[m];
+          this.add(midNode.key, midNode.value, midNode.count);
+          buildBalanceBST(l, m - 1);
+          buildBalanceBST(m + 1, r);
+        };
+        buildBalanceBST(0, n - 1);
+        return true;
+      } else {
+        const stack = [[0, n - 1]];
+        while (stack.length > 0) {
+          const popped = stack.pop();
+          if (popped) {
+            const [l, r] = popped;
+            if (l <= r) {
+              const m = l + Math.floor((r - l) / 2);
+              const midNode = sorted[m];
+              this.add(midNode.key, midNode.value, midNode.count);
+              stack.push([m + 1, r]);
+              stack.push([l, m - 1]);
+            }
+          }
+        }
+        return true;
+      }
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the clone method to create a deep copy of a tree object.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone() {
+      const cloned = this.createTree();
+      this.bfs((node) => cloned.add(node.key, node.value, node.count));
+      return cloned;
+    }
+    /**
+     * The function swaps the properties of two nodes in a binary search tree.
+     * @param srcNode - The source node that needs to be swapped with the destination node. It can be
+     * either a key or a node object.
+     * @param destNode - The `destNode` parameter is the node in the binary search tree where the
+     * properties will be swapped with the `srcNode`.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     * If both `srcNode` and `destNode` are valid nodes, the method swaps their `key`, `value`, `count`,
+     * and `color` properties. If the swapping is successful, the method returns the modified `destNode`.
+     * If either `srcNode` or `destNode` is
+     */
+    _swapProperties(srcNode, destNode) {
+      srcNode = this.ensureNode(srcNode);
+      destNode = this.ensureNode(destNode);
+      if (srcNode && destNode) {
+        const { key, value, count, color } = destNode;
+        const tempNode = this.createNode(key, value, count);
+        if (tempNode) {
+          tempNode.color = color;
+          destNode.key = srcNode.key;
+          destNode.value = srcNode.value;
+          destNode.count = srcNode.count;
+          destNode.color = srcNode.color;
+          srcNode.key = tempNode.key;
+          srcNode.value = tempNode.value;
+          srcNode.count = tempNode.count;
+          srcNode.color = tempNode.color;
+        }
+        return destNode;
+      }
+      return void 0;
+    }
+    /**
+     * The function replaces an old node with a new node and updates the count property of the new node.
+     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+     * needs to be replaced in the data structure.
+     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, after updating the `count` property of the `newNode` object.
+     */
     _replaceNode(oldNode, newNode) {
       newNode.count = oldNode.count + newNode.count;
       return super._replaceNode(oldNode, newNode);
@@ -11670,24 +12716,90 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/tree/tree.ts
   var TreeNode = class _TreeNode {
+    /**
+     * The constructor function initializes a TreeNode object with a key, optional value, and optional
+     * children.
+     * @param {string} key - A string representing the key of the tree node.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+     * value associated with the node. If no value is provided, it defaults to `undefined`.
+     * @param {TreeNode<V>[]} [children] - The `children` parameter is an optional array of `TreeNode<V>`
+     * objects. It represents the child nodes of the current node. If no children are provided, the
+     * default value is an empty array.
+     */
     constructor(key, value, children) {
-      __publicField(this, "key");
-      __publicField(this, "value");
-      __publicField(this, "children");
-      this.key = key;
-      this.value = value || void 0;
-      this.children = children || [];
+      __publicField(this, "_key");
+      __publicField(this, "_value");
+      __publicField(this, "_children");
+      this._key = key;
+      this._value = value || void 0;
+      this._children = children || [];
+    }
+    /**
+     * The function returns the value of the protected variable _key.
+     * @returns The value of the `_key` property, which is a string.
+     */
+    get key() {
+      return this._key;
     }
+    /**
+     * The above function sets the value of a protected variable called "key".
+     * @param {string} value - The value parameter is a string that represents the value to be assigned
+     * to the key.
+     */
+    set key(value) {
+      this._key = value;
+    }
+    /**
+     * The function returns the value stored in a variable, or undefined if the variable is empty.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value() {
+      return this._value;
+    }
+    /**
+     * The function sets the value of a variable.
+     * @param {V | undefined} value - The parameter "value" is of type "V | undefined", which means it
+     * can accept a value of type "V" or it can be undefined.
+     */
+    set value(value) {
+      this._value = value;
+    }
+    /**
+     * The function returns an array of TreeNode objects or undefined.
+     * @returns The `children` property is being returned. It is of type `TreeNode<V>[] | undefined`,
+     * which means it can either be an array of `TreeNode<V>` objects or `undefined`.
+     */
+    get children() {
+      return this._children;
+    }
+    /**
+     * The function sets the value of the children property of a TreeNode object.
+     * @param {TreeNode<V>[] | undefined} value - The value parameter is of type TreeNode<V>[] |
+     * undefined. This means that it can accept an array of TreeNode objects or undefined.
+     */
+    set children(value) {
+      this._children = value;
+    }
+    /**
+     * The function `addChildren` adds one or more child nodes to the current node.
+     * @param {TreeNode<V> | TreeNode<V>[]} children - The `children` parameter can be either a single
+     * `TreeNode<V>` object or an array of `TreeNode<V>` objects.
+     */
     addChildren(children) {
-      if (!this.children) {
-        this.children = [];
+      if (!this._children) {
+        this._children = [];
       }
       if (children instanceof _TreeNode) {
-        this.children.push(children);
+        this._children.push(children);
       } else {
-        this.children = this.children.concat(children);
+        this._children = this._children.concat(children);
       }
     }
+    /**
+     * The function `getHeight()` calculates the maximum depth of a tree structure by performing a
+     * breadth-first search.
+     * @returns the maximum depth or height of the tree.
+     */
     getHeight() {
       let maxDepth = 0;
       if (this) {
@@ -11695,10 +12807,10 @@ var dataStructureTyped = (() => {
           if (level > maxDepth) {
             maxDepth = level;
           }
-          const { children } = node;
-          if (children) {
-            for (let i = 0, len = children.length; i < len; i++) {
-              bfs(children[i], level + 1);
+          const { _children } = node;
+          if (_children) {
+            for (let i = 0, len = _children.length; i < len; i++) {
+              bfs(_children[i], level + 1);
             }
           }
         };
@@ -11710,6 +12822,14 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/priority-queue/priority-queue.ts
   var PriorityQueue = class extends Heap {
+    /**
+     * The constructor initializes a priority queue with optional elements and options.
+     * @param elements - The `elements` parameter is an iterable object that contains the initial
+     * elements to be added to the priority queue. It is an optional parameter and if not provided, the
+     * priority queue will be initialized as empty.
+     * @param [options] - The `options` parameter is an optional object that can be used to customize the
+     * behavior of the priority queue. It can contain the following properties:
+     */
     constructor(elements = [], options) {
       super(elements, options);
     }
@@ -11717,6 +12837,17 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/priority-queue/min-priority-queue.ts
   var MinPriorityQueue = class extends PriorityQueue {
+    /**
+     * The constructor initializes a PriorityQueue with optional elements and options, including a
+     * comparator function.
+     * @param elements - The `elements` parameter is an iterable object that contains the initial
+     * elements to be added to the priority queue. It is optional and defaults to an empty array if not
+     * provided.
+     * @param options - The `options` parameter is an object that contains additional configuration
+     * options for the priority queue. In this case, it has a property called `comparator` which is a
+     * function used to compare elements in the priority queue. The `comparator` function takes two
+     * parameters `a` and `b`,
+     */
     constructor(elements = [], options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
@@ -11732,6 +12863,16 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/priority-queue/max-priority-queue.ts
   var MaxPriorityQueue = class extends PriorityQueue {
+    /**
+     * The constructor initializes a PriorityQueue with optional elements and options, including a
+     * comparator function.
+     * @param elements - The `elements` parameter is an iterable object that contains the initial
+     * elements to be added to the priority queue. It is optional and defaults to an empty array if not
+     * provided.
+     * @param options - The `options` parameter is an object that contains additional configuration
+     * options for the priority queue. In this case, it has a property called `comparator` which is a
+     * function used to compare elements in the priority queue.
+     */
     constructor(elements = [], options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
@@ -11796,7 +12937,7 @@ var dataStructureTyped = (() => {
       return this._rows;
     }
     /**
-     * The function returns the value of the private variable _cols.
+     * The function returns the value of the protected variable _cols.
      * @returns The number of columns.
      */
     get cols() {
@@ -12291,12 +13432,60 @@ var dataStructureTyped = (() => {
   // src/data-structures/trie/trie.ts
   var TrieNode = class {
     constructor(key) {
-      __publicField(this, "key");
-      __publicField(this, "children");
-      __publicField(this, "isEnd");
-      this.key = key;
-      this.isEnd = false;
-      this.children = /* @__PURE__ */ new Map();
+      __publicField(this, "_key");
+      __publicField(this, "_children");
+      __publicField(this, "_isEnd");
+      this._key = key;
+      this._isEnd = false;
+      this._children = /* @__PURE__ */ new Map();
+    }
+    /**
+     * The function returns the value of the protected variable _key.
+     * @returns The value of the `_key` property, which is a string.
+     */
+    get key() {
+      return this._key;
+    }
+    /**
+     * The above function sets the value of a protected variable called "key".
+     * @param {string} value - The value parameter is a string that represents the value to be assigned
+     * to the key.
+     */
+    set key(value) {
+      this._key = value;
+    }
+    /**
+     * The function returns the children of a TrieNode as a Map.
+     * @returns The `children` property of the TrieNode object, which is a Map containing string keys and
+     * TrieNode values.
+     */
+    get children() {
+      return this._children;
+    }
+    /**
+     * The function sets the value of the `_children` property of a TrieNode object.
+     * @param value - The value parameter is a Map object that represents the children of a TrieNode. The
+     * keys of the map are strings, which represent the characters that are associated with each child
+     * TrieNode. The values of the map are TrieNode objects, which represent the child nodes of the
+     * current TrieNode.
+     */
+    set children(value) {
+      this._children = value;
+    }
+    /**
+     * The function returns a boolean value indicating whether a certain condition is met.
+     * @returns The method is returning a boolean value, specifically the value of the variable `_isEnd`.
+     */
+    get isEnd() {
+      return this._isEnd;
+    }
+    /**
+     * The function sets the value of the "_isEnd" property.
+     * @param {boolean} value - The value parameter is a boolean value that indicates whether the current
+     * state is the end state or not.
+     */
+    set isEnd(value) {
+      this._isEnd = value;
     }
   };
   var Trie = class _Trie extends IterableElementBase {
@@ -12329,9 +13518,8 @@ var dataStructureTyped = (() => {
       return this._size;
     }
     /**
-     * The caseSensitive function is a getter that returns the value of the private _caseSensitive property.
-     *
-     * @return The value of the _casesensitive private variable
+     * The caseSensitive function is a getter that returns the value of the protected _caseSensitive property.
+     * @return The value of the _caseSensitive protected variable
      */
     get caseSensitive() {
       return this._caseSensitive;
@@ -12344,12 +13532,12 @@ var dataStructureTyped = (() => {
       return this._root;
     }
     /**
-     * Time Complexity: O(M), where M is the length of the word being added.
-     * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+     * Time Complexity: O(l), where l is the length of the word being added.
+     * Space Complexity: O(l) - Each character in the word adds a TrieNode.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the word being added.
-     * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+     * Time Complexity: O(l), where l is the length of the word being added.
+     * Space Complexity: O(l) - Each character in the word adds a TrieNode.
      *
      * Add a word to the Trie structure.
      * @param {string} word - The word to add.
@@ -12375,11 +13563,11 @@ var dataStructureTyped = (() => {
       return isNewWord;
     }
     /**
-     * Time Complexity: O(M), where M is the length of the input word.
+     * Time Complexity: O(l), where l is the length of the input word.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input word.
+     * Time Complexity: O(l), where l is the length of the input word.
      * Space Complexity: O(1) - Constant space.
      *
      * Check if the Trie contains a given word.
@@ -12398,6 +13586,13 @@ var dataStructureTyped = (() => {
       return cur.isEnd;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The isEmpty function checks if the size of the queue is 0.
      * @return True if the size of the queue is 0
      */
@@ -12405,12 +13600,26 @@ var dataStructureTyped = (() => {
       return this.size === 0;
     }
     /**
-     * Time Complexity: O(M), where M is the length of the word being deleted.
-     * Space Complexity: O(M) - Due to the recursive DFS approach.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(M), where M is the length of the word being deleted.
-     * Space Complexity: O(M) - Due to the recursive DFS approach.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the size of the Trie to 0 and creates a new root TrieNode.
+     */
+    clear() {
+      this._size = 0;
+      this._root = new TrieNode("");
+    }
+    /**
+     * Time Complexity: O(l), where l is the length of the word being deleted.
+     * Space Complexity: O(n) - Due to the recursive DFS approach.
+     */
+    /**
+     * Time Complexity: O(l), where l is the length of the word being deleted.
+     * Space Complexity: O(n) - Due to the recursive DFS approach.
      *
      * Remove a word from the Trie structure.
      * @param{string} word - The word to delete.
@@ -12451,11 +13660,11 @@ var dataStructureTyped = (() => {
       return isDeleted;
     }
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
      * Space Complexity: O(1) - Constant space.
      *
      */
@@ -12479,11 +13688,11 @@ var dataStructureTyped = (() => {
       return maxDepth;
     }
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      *
      * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
@@ -12502,11 +13711,11 @@ var dataStructureTyped = (() => {
       return !cur.isEnd;
     }
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      *
      * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
@@ -12525,12 +13734,12 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the input prefix.
      */
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the input prefix.
      *
      * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
      * @param {string} input - The input string representing the common prefix to check for.
@@ -12554,12 +13763,12 @@ var dataStructureTyped = (() => {
       return commonPre === input;
     }
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the longest common prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the longest common prefix.
      */
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the longest common prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the longest common prefix.
      *
      * Get the longest common prefix among all the words stored in the Trie.
      * @returns {string} The longest common prefix found in the Trie.
@@ -12579,12 +13788,12 @@ var dataStructureTyped = (() => {
       return commonPre;
     }
     /**
-     * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
-     * Space Complexity: O(K * L) - The space required for the output array.
+     * Time Complexity: O(w * l), where w is the number of words retrieved, and l is the average length of the words.
+     * Space Complexity: O(w * l) - The space required for the output array.
      */
     /**
-     * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
-     * Space Complexity: O(K * L) - The space required for the output array.
+     * Time Complexity: O(w * l), where w is the number of words retrieved, and l is the average length of the words.
+     * Space Complexity: O(w * l) - The space required for the output array.
      *
      * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
      * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
@@ -12693,6 +13902,17 @@ var dataStructureTyped = (() => {
       }
       return newTrie;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `_getIterator` returns an iterable iterator that performs a depth-first search on a
+     * trie data structure and yields all the paths to the end nodes.
+     */
     *_getIterator() {
       function* _dfs(node, path) {
         if (node.isEnd) {
@@ -12705,11 +13925,11 @@ var dataStructureTyped = (() => {
       yield* __yieldStar(_dfs(this.root, ""));
     }
     /**
-     * Time Complexity: O(M), where M is the length of the input string.
+     * Time Complexity: O(l), where l is the length of the input string.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input string.
+     * Time Complexity: O(l), where l is the length of the input string.
      * Space Complexity: O(1) - Constant space.
      *
      * @param str