data-structure-typed 1.49.0 → 1.49.2

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

@@ -444,80 +444,6 @@ var dataStructureTyped = (() => {
   __publicField(_HashTable, "LOAD_FACTOR", 0.75);
   var HashTable = _HashTable;
 
-  // src/utils/utils.ts
-  var uuidV4 = function() {
-    return "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".replace(/[x]/g, function(c) {
-      const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
-      return v.toString(16);
-    });
-  };
-  var arrayRemove = function(array, predicate) {
-    let i = -1, len = array ? array.length : 0;
-    const result = [];
-    while (++i < len) {
-      const value = array[i];
-      if (predicate(value, i, array)) {
-        result.push(value);
-        Array.prototype.splice.call(array, i--, 1);
-        len--;
-      }
-    }
-    return result;
-  };
-  var THUNK_SYMBOL = Symbol("thunk");
-  var isThunk = (fnOrValue) => {
-    return typeof fnOrValue === "function" && fnOrValue.__THUNK__ === THUNK_SYMBOL;
-  };
-  var toThunk = (fn) => {
-    const thunk = () => fn();
-    thunk.__THUNK__ = THUNK_SYMBOL;
-    return thunk;
-  };
-  var trampoline = (fn) => {
-    const cont = (...args) => toThunk(() => fn(...args));
-    return Object.assign(
-      (...args) => {
-        let result = fn(...args);
-        while (isThunk(result) && typeof result === "function") {
-          result = result();
-        }
-        return result;
-      },
-      { cont }
-    );
-  };
-  var trampolineAsync = (fn) => {
-    const cont = (...args) => toThunk(() => fn(...args));
-    return Object.assign(
-      (...args) => __async(void 0, null, function* () {
-        let result = yield fn(...args);
-        while (isThunk(result) && typeof result === "function") {
-          result = yield result();
-        }
-        return result;
-      }),
-      { cont }
-    );
-  };
-  var getMSB = (value) => {
-    if (value <= 0) {
-      return 0;
-    }
-    return 1 << 31 - Math.clz32(value);
-  };
-  var rangeCheck = (index, min, max, message = "Index out of bounds.") => {
-    if (index < min || index > max)
-      throw new RangeError(message);
-  };
-  var throwRangeError = (message = "The value is off-limits.") => {
-    throw new RangeError(message);
-  };
-  var isWeakKey = (input) => {
-    const inputType = typeof input;
-    return inputType === "object" && input !== null || inputType === "function";
-  };
-  var calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
-
   // src/data-structures/base/iterable-base.ts
   var IterableEntryBase = class {
     /**
@@ -690,6 +616,20 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    hasValue(value) {
+      for (const [, elementValue] of this) {
+        if (elementValue === value)
+          return true;
+      }
+      return false;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    print() {
+      console.log([...this]);
+    }
   };
   var IterableElementBase = class {
     /**
@@ -825,7 +765,88 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    print() {
+      console.log([...this]);
+    }
+  };
+
+  // src/utils/utils.ts
+  var uuidV4 = function() {
+    return "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".replace(/[x]/g, function(c) {
+      const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  };
+  var arrayRemove = function(array, predicate) {
+    let i = -1, len = array ? array.length : 0;
+    const result = [];
+    while (++i < len) {
+      const value = array[i];
+      if (predicate(value, i, array)) {
+        result.push(value);
+        Array.prototype.splice.call(array, i--, 1);
+        len--;
+      }
+    }
+    return result;
+  };
+  var THUNK_SYMBOL = Symbol("thunk");
+  var isThunk = (fnOrValue) => {
+    return typeof fnOrValue === "function" && fnOrValue.__THUNK__ === THUNK_SYMBOL;
+  };
+  var toThunk = (fn) => {
+    const thunk = () => fn();
+    thunk.__THUNK__ = THUNK_SYMBOL;
+    return thunk;
+  };
+  var trampoline = (fn) => {
+    const cont = (...args) => toThunk(() => fn(...args));
+    return Object.assign(
+      (...args) => {
+        let result = fn(...args);
+        while (isThunk(result) && typeof result === "function") {
+          result = result();
+        }
+        return result;
+      },
+      { cont }
+    );
+  };
+  var trampolineAsync = (fn) => {
+    const cont = (...args) => toThunk(() => fn(...args));
+    return Object.assign(
+      (...args) => __async(void 0, null, function* () {
+        let result = yield fn(...args);
+        while (isThunk(result) && typeof result === "function") {
+          result = yield result();
+        }
+        return result;
+      }),
+      { cont }
+    );
+  };
+  var getMSB = (value) => {
+    if (value <= 0) {
+      return 0;
+    }
+    return 1 << 31 - Math.clz32(value);
+  };
+  var rangeCheck = (index, min, max, message = "Index out of bounds.") => {
+    if (index < min || index > max)
+      throw new RangeError(message);
+  };
+  var throwRangeError = (message = "The value is off-limits.") => {
+    throw new RangeError(message);
+  };
+  var isWeakKey = (input) => {
+    const inputType = typeof input;
+    return inputType === "object" && input !== null || inputType === "function";
   };
+  var calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
 
   // src/data-structures/hash/hash-map.ts
   var HashMap = class _HashMap extends IterableEntryBase {
@@ -886,6 +907,7 @@ var dataStructureTyped = (() => {
         }
         this._store[strKey] = { key, value };
       }
+      return true;
     }
     /**
      * The function "setMany" sets multiple key-value pairs in a map.
@@ -893,8 +915,10 @@ var dataStructureTyped = (() => {
      * key-value pair is represented as an array with two elements: the key and the value.
      */
     setMany(elements) {
+      const results = [];
       for (const [key, value] of elements)
-        this.set(key, value);
+        results.push(this.set(key, value));
+      return results;
     }
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
@@ -1009,6 +1033,9 @@ var dataStructureTyped = (() => {
     print() {
       console.log([...this.entries()]);
     }
+    put(key, value) {
+      return this.set(key, value);
+    }
     /**
      * The function returns an iterator that yields key-value pairs from both an object store and an
      * object map.
@@ -1160,7 +1187,7 @@ var dataStructureTyped = (() => {
         this._sentinel.prev = node;
         this._size++;
       }
-      return this._size;
+      return true;
     }
     has(key) {
       if (isWeakKey(key)) {
@@ -1172,10 +1199,12 @@ var dataStructureTyped = (() => {
       }
     }
     setMany(entries) {
+      const results = [];
       for (const entry of entries) {
         const [key, value] = entry;
-        this.set(key, value);
+        results.push(this.set(key, value));
       }
+      return results;
     }
     /**
      * Time Complexity: O(1)
@@ -1218,7 +1247,7 @@ var dataStructureTyped = (() => {
       while (index--) {
         node = node.next;
       }
-      return [node.key, node.value];
+      return node.value;
     }
     /**
      * Time Complexity: O(1)
@@ -1265,8 +1294,7 @@ var dataStructureTyped = (() => {
       while (index--) {
         node = node.next;
       }
-      this._deleteNode(node);
-      return this._size;
+      return this._deleteNode(node);
     }
     /**
      * Time Complexity: O(1)
@@ -1359,8 +1387,8 @@ var dataStructureTyped = (() => {
       }
       return mappedMap;
     }
-    print() {
-      console.log([...this]);
+    put(key, value) {
+      return this.set(key, value);
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
@@ -1396,6 +1424,7 @@ var dataStructureTyped = (() => {
         this._tail = prev;
       }
       this._size -= 1;
+      return true;
     }
   };
 
@@ -1421,10 +1450,10 @@ var dataStructureTyped = (() => {
       super();
       __publicField(this, "_head");
       __publicField(this, "_tail");
-      __publicField(this, "_length");
+      __publicField(this, "_size");
       this._head = void 0;
       this._tail = void 0;
-      this._length = 0;
+      this._size = 0;
       if (elements) {
         for (const el of elements)
           this.push(el);
@@ -1436,8 +1465,8 @@ var dataStructureTyped = (() => {
     get tail() {
       return this._tail;
     }
-    get length() {
-      return this._length;
+    get size() {
+      return this._size;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the input array, as it performs a loop to push each element into the linked list.
@@ -1480,7 +1509,8 @@ var dataStructureTyped = (() => {
         this.tail.next = newNode;
         this._tail = newNode;
       }
-      this._length++;
+      this._size++;
+      return true;
     }
     /**
      * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
@@ -1495,7 +1525,7 @@ var dataStructureTyped = (() => {
      * any type (E) as specified in the generic type declaration of the class or function.
      */
     addLast(value) {
-      this.push(value);
+      return this.push(value);
     }
     /**
      * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
@@ -1517,7 +1547,7 @@ var dataStructureTyped = (() => {
         const value2 = this.head.value;
         this._head = void 0;
         this._tail = void 0;
-        this._length--;
+        this._size--;
         return value2;
       }
       let current = this.head;
@@ -1527,7 +1557,7 @@ var dataStructureTyped = (() => {
       const value = this.tail.value;
       current.next = void 0;
       this._tail = current;
-      this._length--;
+      this._size--;
       return value;
     }
     /**
@@ -1562,7 +1592,7 @@ var dataStructureTyped = (() => {
         return void 0;
       const removedNode = this.head;
       this._head = this.head.next;
-      this._length--;
+      this._size--;
       return removedNode.value;
     }
     /**
@@ -1600,7 +1630,8 @@ var dataStructureTyped = (() => {
         newNode.next = this.head;
         this._head = newNode;
       }
-      this._length++;
+      this._size++;
+      return true;
     }
     /**
      * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
@@ -1615,7 +1646,7 @@ var dataStructureTyped = (() => {
      * linked list.
      */
     addFirst(value) {
-      this.unshift(value);
+      return this.unshift(value);
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
@@ -1632,7 +1663,7 @@ var dataStructureTyped = (() => {
      * `undefined` if the index is out of bounds.
      */
     getAt(index) {
-      if (index < 0 || index >= this.length)
+      if (index < 0 || index >= this.size)
         return void 0;
       let current = this.head;
       for (let i = 0; i < index; i++) {
@@ -1676,17 +1707,21 @@ var dataStructureTyped = (() => {
      * bounds.
      */
     deleteAt(index) {
-      if (index < 0 || index >= this.length)
-        return void 0;
-      if (index === 0)
-        return this.shift();
-      if (index === this.length - 1)
-        return this.pop();
+      if (index < 0 || index >= this.size)
+        return false;
+      if (index === 0) {
+        this.shift();
+        return true;
+      }
+      if (index === this.size - 1) {
+        this.pop();
+        return true;
+      }
       const prevNode = this.getNodeAt(index - 1);
       const removedNode = prevNode.next;
       prevNode.next = removedNode.next;
-      this._length--;
-      return removedNode.value;
+      this._size--;
+      return true;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
@@ -1725,7 +1760,7 @@ var dataStructureTyped = (() => {
               this._tail = prev;
             }
           }
-          this._length--;
+          this._size--;
           return true;
         }
         prev = current;
@@ -1741,7 +1776,7 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertAt` function inserts a value at a specified index in a singly linked list.
+     * The `addAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
      * linked list. It is of type number.
      * @param {E} value - The `value` parameter represents the value that you want to insert into the linked list at the
@@ -1749,14 +1784,14 @@ var dataStructureTyped = (() => {
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    insertAt(index, value) {
-      if (index < 0 || index > this.length)
+    addAt(index, value) {
+      if (index < 0 || index > this.size)
         return false;
       if (index === 0) {
         this.unshift(value);
         return true;
       }
-      if (index === this.length) {
+      if (index === this.size) {
         this.push(value);
         return true;
       }
@@ -1764,7 +1799,7 @@ var dataStructureTyped = (() => {
       const prevNode = this.getNodeAt(index - 1);
       newNode.next = prevNode.next;
       prevNode.next = newNode;
-      this._length++;
+      this._size++;
       return true;
     }
     /**
@@ -1773,7 +1808,7 @@ var dataStructureTyped = (() => {
      * @returns A boolean value indicating whether the length of the object is equal to 0.
      */
     isEmpty() {
-      return this.length === 0;
+      return this.size === 0;
     }
     /**
      * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
@@ -1781,7 +1816,7 @@ var dataStructureTyped = (() => {
     clear() {
       this._head = void 0;
       this._tail = void 0;
-      this._length = 0;
+      this._size = 0;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to traverse the entire list to convert it to an array.
@@ -1816,7 +1851,7 @@ var dataStructureTyped = (() => {
      */
     reverse() {
       if (!this.head || this.head === this.tail)
-        return;
+        return this;
       let prev = void 0;
       let current = this.head;
       let next = void 0;
@@ -1827,6 +1862,7 @@ var dataStructureTyped = (() => {
         current = next;
       }
       [this._head, this._tail] = [this.tail, this.head];
+      return this;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
@@ -1909,14 +1945,14 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
+     * The `addBefore` function inserts a new value before an existing value in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
      * new value before. It can be either the value itself or a node containing the value in the linked list.
      * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
-     * @returns The method `insertBefore` returns a boolean value. It returns `true` if the new value was successfully
+     * @returns The method `addBefore` returns a boolean value. It returns `true` if the new value was successfully
      * inserted before the existing value, and `false` otherwise.
      */
-    insertBefore(existingValueOrNode, newValue) {
+    addBefore(existingValueOrNode, newValue) {
       if (!this.head)
         return false;
       let existingValue;
@@ -1935,7 +1971,7 @@ var dataStructureTyped = (() => {
           const newNode = new SinglyLinkedListNode(newValue);
           newNode.next = current.next;
           current.next = newNode;
-          this._length++;
+          this._size++;
           return true;
         }
         current = current.next;
@@ -1950,14 +1986,14 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
+     * The `addAfter` function inserts a new node with a given value after an existing node in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
      * the new value will be inserted. It can be either the value of the existing node or the existing node itself.
      * @param {E} newValue - The value that you want to insert into the linked list after the existing value or node.
      * @returns The method returns a boolean value. It returns true if the new value was successfully inserted after the
      * existing value or node, and false if the existing value or node was not found in the linked list.
      */
-    insertAfter(existingValueOrNode, newValue) {
+    addAfter(existingValueOrNode, newValue) {
       let existingNode;
       if (existingValueOrNode instanceof SinglyLinkedListNode) {
         existingNode = existingValueOrNode;
@@ -1971,7 +2007,7 @@ var dataStructureTyped = (() => {
         if (existingNode === this.tail) {
           this._tail = newNode;
         }
-        this._length++;
+        this._size++;
         return true;
       }
       return false;
@@ -2058,13 +2094,6 @@ var dataStructureTyped = (() => {
       }
       return mappedList;
     }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     */
-    print() {
-      console.log([...this]);
-    }
     *_getIterator() {
       let current = this.head;
       while (current) {
@@ -2092,16 +2121,16 @@ var dataStructureTyped = (() => {
   };
   var DoublyLinkedList = class _DoublyLinkedList extends IterableElementBase {
     /**
-     * The constructor initializes the linked list with an empty head, tail, and length.
+     * The constructor initializes the linked list with an empty head, tail, and size.
      */
     constructor(elements) {
       super();
       __publicField(this, "_head");
       __publicField(this, "_tail");
-      __publicField(this, "_length");
+      __publicField(this, "_size");
       this._head = void 0;
       this._tail = void 0;
-      this._length = 0;
+      this._size = 0;
       if (elements) {
         for (const el of elements) {
           this.push(el);
@@ -2114,18 +2143,15 @@ var dataStructureTyped = (() => {
     get tail() {
       return this._tail;
     }
-    get length() {
-      return this._length;
-    }
     get size() {
-      return this.length;
+      return this._size;
     }
     /**
-     * Time Complexity: O(n), where n is the length of the input array.
+     * Time Complexity: O(n), where n is the size of the input array.
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the length of the input array.
+     * Time Complexity: O(n), where n is the size of the input array.
      * Space Complexity: O(n)
      *
      * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
@@ -2161,21 +2187,8 @@ var dataStructureTyped = (() => {
         this.tail.next = newNode;
         this._tail = newNode;
       }
-      this._length++;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addLast function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} value - The value to be added to the linked list.
-     */
-    addLast(value) {
-      this.push(value);
+      this._size++;
+      return true;
     }
     /**
      * Time Complexity: O(1)
@@ -2200,24 +2213,9 @@ var dataStructureTyped = (() => {
         this._tail = removedNode.prev;
         this.tail.next = void 0;
       }
-      this._length--;
+      this._size--;
       return removedNode.value;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-     * list is empty, it returns undefined.
-     */
-    pollLast() {
-      return this.pop();
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -2241,24 +2239,9 @@ var dataStructureTyped = (() => {
         this._head = removedNode.next;
         this.head.prev = void 0;
       }
-      this._length--;
+      this._size--;
       return removedNode.value;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
-     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-     * list.
-     */
-    pollFirst() {
-      return this.shift();
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -2281,52 +2264,8 @@ var dataStructureTyped = (() => {
         this.head.prev = newNode;
         this._head = newNode;
       }
-      this._length++;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
-     * doubly linked list.
-     */
-    addFirst(value) {
-      this.unshift(value);
-    }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `getFirst` function returns the first node in a doubly linked list, or undefined if the list is empty.
-     * @returns The method `getFirst()` returns the first node of the doubly linked list, or `undefined` if the list is empty.
-     */
-    getFirst() {
-      var _a;
-      return (_a = this.head) == null ? void 0 : _a.value;
-    }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `getLast` function returns the last node in a doubly linked list, or undefined if the list is empty.
-     * @returns The method `getLast()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
-     */
-    getLast() {
-      var _a;
-      return (_a = this.tail) == null ? void 0 : _a.value;
+      this._size++;
+      return true;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -2343,7 +2282,7 @@ var dataStructureTyped = (() => {
      * or the linked list is empty, it will return undefined.
      */
     getAt(index) {
-      if (index < 0 || index >= this.length)
+      if (index < 0 || index >= this.size)
         return void 0;
       let current = this.head;
       for (let i = 0; i < index; i++) {
@@ -2367,7 +2306,7 @@ var dataStructureTyped = (() => {
      * valid range of the linked list, otherwise it returns `undefined`.
      */
     getNodeAt(index) {
-      if (index < 0 || index >= this.length)
+      if (index < 0 || index >= this.size)
         return void 0;
       let current = this.head;
       for (let i = 0; i < index; i++) {
@@ -2415,14 +2354,14 @@ var dataStructureTyped = (() => {
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    insertAt(index, value) {
-      if (index < 0 || index > this.length)
+    addAt(index, value) {
+      if (index < 0 || index > this.size)
         return false;
       if (index === 0) {
         this.unshift(value);
         return true;
       }
-      if (index === this.length) {
+      if (index === this.size) {
         this.push(value);
         return true;
       }
@@ -2433,7 +2372,7 @@ var dataStructureTyped = (() => {
       newNode.next = nextNode;
       prevNode.next = newNode;
       nextNode.prev = newNode;
-      this._length++;
+      this._size++;
       return true;
     }
     /**
@@ -2444,7 +2383,7 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
-     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * The `addBefore` function inserts a new value before an existing value or node in a doubly linked list.
      * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
      * before which the new value will be inserted. It can be either the value of the existing node or the existing node
      * itself.
@@ -2453,7 +2392,7 @@ var dataStructureTyped = (() => {
      * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
      * insertion fails.
      */
-    insertBefore(existingValueOrNode, newValue) {
+    addBefore(existingValueOrNode, newValue) {
       let existingNode;
       if (existingValueOrNode instanceof DoublyLinkedListNode) {
         existingNode = existingValueOrNode;
@@ -2471,7 +2410,7 @@ var dataStructureTyped = (() => {
         if (existingNode === this.head) {
           this._head = newNode;
         }
-        this._length++;
+        this._size++;
         return true;
       }
       return false;
@@ -2484,7 +2423,7 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
-     * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
+     * The `addAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
      * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
      * after which the new value will be inserted. It can be either the value of the existing node or the existing node
      * itself.
@@ -2492,7 +2431,7 @@ var dataStructureTyped = (() => {
      * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
      * existing value or node is not found in the doubly linked list.
      */
-    insertAfter(existingValueOrNode, newValue) {
+    addAfter(existingValueOrNode, newValue) {
       let existingNode;
       if (existingValueOrNode instanceof DoublyLinkedListNode) {
         existingNode = existingValueOrNode;
@@ -2510,7 +2449,7 @@ var dataStructureTyped = (() => {
         if (existingNode === this.tail) {
           this._tail = newNode;
         }
-        this._length++;
+        this._size++;
         return true;
       }
       return false;
@@ -2530,19 +2469,23 @@ var dataStructureTyped = (() => {
      * bounds.
      */
     deleteAt(index) {
-      if (index < 0 || index >= this.length)
-        return void 0;
-      if (index === 0)
-        return this.shift();
-      if (index === this.length - 1)
-        return this.pop();
+      if (index < 0 || index >= this.size)
+        return false;
+      if (index === 0) {
+        this.shift();
+        return true;
+      }
+      if (index === this.size - 1) {
+        this.pop();
+        return true;
+      }
       const removedNode = this.getNodeAt(index);
       const prevNode = removedNode.prev;
       const nextNode = removedNode.next;
       prevNode.next = nextNode;
       nextNode.prev = prevNode;
-      this._length--;
-      return removedNode.value;
+      this._size--;
+      return true;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -2575,26 +2518,26 @@ var dataStructureTyped = (() => {
           const nextNode = node.next;
           prevNode.next = nextNode;
           nextNode.prev = prevNode;
-          this._length--;
+          this._size--;
         }
         return true;
       }
       return false;
     }
     /**
-     * The function checks if a variable has a length greater than zero and returns a boolean value.
+     * The function checks if a variable has a size greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
      */
     isEmpty() {
-      return this.length === 0;
+      return this.size === 0;
     }
     /**
-     * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
+     * The `clear` function resets the linked list by setting the head, tail, and size to undefined and 0 respectively.
      */
     clear() {
       this._head = void 0;
       this._tail = void 0;
-      this._length = 0;
+      this._size = 0;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -2689,6 +2632,7 @@ var dataStructureTyped = (() => {
         [current.prev, current.next] = [current.next, current.prev];
         current = next;
       }
+      return this;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -2792,12 +2736,94 @@ var dataStructureTyped = (() => {
       }
       return mappedList;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The addLast function adds a new node with the given value to the end of the doubly linked list.
+     * @param {E} value - The value to be added to the linked list.
+     */
+    addLast(value) {
+      return this.push(value);
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
+     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
+     * list is empty, it returns undefined.
+     */
+    pollLast() {
+      return this.pop();
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
+     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
+     * list.
+     */
+    pollFirst() {
+      return this.shift();
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
+     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
+     * doubly linked list.
+     */
+    addFirst(value) {
+      this.unshift(value);
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
-    print() {
-      console.log([...this]);
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * The `get first` function returns the first node in a doubly linked list, or undefined if the list is empty.
+     * @returns The method `get first()` returns the first node of the doubly linked list, or `undefined` if the list is empty.
+     */
+    get first() {
+      var _a;
+      return (_a = this.head) == null ? void 0 : _a.value;
+    }
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * The `get last` function returns the last node in a doubly linked list, or undefined if the list is empty.
+     * @returns The method `get last()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
+     */
+    get last() {
+      var _a;
+      return (_a = this.tail) == null ? void 0 : _a.value;
     }
     /**
      * The function returns an iterator that iterates over the values of a linked list.
@@ -2968,7 +2994,7 @@ var dataStructureTyped = (() => {
      * Get the value of the first element (the smallest element) in the Skip List.
      * @returns The value of the first element, or undefined if the Skip List is empty.
      */
-    getFirst() {
+    get first() {
       const firstNode = this.head.forward[0];
       return firstNode ? firstNode.value : void 0;
     }
@@ -2983,7 +3009,7 @@ var dataStructureTyped = (() => {
      * Get the value of the last element (the largest element) in the Skip List.
      * @returns The value of the last element, or undefined if the Skip List is empty.
      */
-    getLast() {
+    get last() {
       let current = this.head;
       for (let i = this.level - 1; i >= 0; i--) {
         while (current.forward[i]) {
@@ -3140,7 +3166,7 @@ var dataStructureTyped = (() => {
      */
     push(element) {
       this.elements.push(element);
-      return this;
+      return true;
     }
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
@@ -3156,8 +3182,8 @@ var dataStructureTyped = (() => {
      */
     pop() {
       if (this.isEmpty())
-        return void 0;
-      return this.elements.pop() || void 0;
+        return;
+      return this.elements.pop();
     }
     /**
      * Time Complexity: O(n)
@@ -3250,9 +3276,6 @@ var dataStructureTyped = (() => {
       }
       return newStack;
     }
-    print() {
-      console.log([...this]);
-    }
     /**
      * Custom iterator for the Stack class.
      * @returns An iterator object.
@@ -3317,7 +3340,7 @@ var dataStructureTyped = (() => {
      */
     push(element) {
       this.nodes.push(element);
-      return this;
+      return true;
     }
     /**
      * 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.
@@ -3334,7 +3357,7 @@ var dataStructureTyped = (() => {
     shift() {
       if (this.size === 0)
         return void 0;
-      const first = this.getFirst();
+      const first = this.first;
       this._offset += 1;
       if (this.offset * 2 < this.nodes.length)
         return first;
@@ -3350,11 +3373,11 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * The `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
+     * @returns The `get first()` method returns the first element of the data structure, represented by the `_nodes` array at
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
-    getFirst() {
+    get first() {
       return this.size > 0 ? this.nodes[this.offset] : void 0;
     }
     /**
@@ -3370,7 +3393,7 @@ var dataStructureTyped = (() => {
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     peek() {
-      return this.getFirst();
+      return this.first;
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
@@ -3380,11 +3403,11 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-     * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * 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 `_nodes` array if the array is not empty. If the
      * array is empty, it returns `undefined`.
      */
-    getLast() {
+    get last() {
       return this.size > 0 ? this.nodes[this.nodes.length - 1] : void 0;
     }
     /**
@@ -3400,7 +3423,7 @@ var dataStructureTyped = (() => {
      * array is empty, it returns `undefined`.
      */
     peekLast() {
-      return this.getLast();
+      return this.last;
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
@@ -3414,7 +3437,7 @@ var dataStructureTyped = (() => {
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
     enqueue(value) {
-      this.push(value);
+      return this.push(value);
     }
     /**
      * Time Complexity: O(n) - same as shift().
@@ -3492,9 +3515,6 @@ var dataStructureTyped = (() => {
     clone() {
       return new _Queue(this.nodes.slice(this.offset));
     }
-    print() {
-      console.log([...this]);
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -3569,7 +3589,7 @@ var dataStructureTyped = (() => {
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
     enqueue(value) {
-      this.push(value);
+      return this.push(value);
     }
     /**
      * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
@@ -3579,10 +3599,10 @@ var dataStructureTyped = (() => {
       return this.shift();
     }
     /**
-     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     * The `get first` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `get first()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
-    getFirst() {
+    get first() {
       var _a;
       return (_a = this.head) == null ? void 0 : _a.value;
     }
@@ -3591,7 +3611,7 @@ var dataStructureTyped = (() => {
      * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
     peek() {
-      return this.getFirst();
+      return this.first;
     }
   };
 
@@ -3661,95 +3681,6 @@ var dataStructureTyped = (() => {
         return;
       return this._buckets[this._bucketLast][this._lastInBucket];
     }
-    /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
-     */
-    isEmpty() {
-      return this.size === 0;
-    }
-    /**
-     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
-     * Space Complexity: O(n) - Due to potential resizing.
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
-     *
-     * 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
-     * data structure.
-     */
-    addLast(element) {
-      this.push(element);
-    }
-    /**
-     * Time Complexity: O(1) - Removes the first element.
-     * Space Complexity: O(1) - In-place operation.
-     */
-    /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
-     *
-     * The function "pollLast" removes and returns the last element of an array.
-     * @returns The last element of the array is being returned.
-     */
-    pollLast() {
-      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.
-     */
-    addFirst(element) {
-      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`.
-     */
-    pollFirst() {
-      return this.shift();
-    }
-    /**
-     * The clear() function resets the state of the object by initializing all variables to their default
-     * values.
-     */
-    clear() {
-      this._buckets = [new Array(this._bucketSize)];
-      this._bucketCount = 1;
-      this._bucketFirst = this._bucketLast = this._size = 0;
-      this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
-    }
-    /**
-     * The below function is a generator that yields elements from a collection one by one.
-     */
-    *begin() {
-      let index = 0;
-      while (index < this.size) {
-        yield this.getAt(index);
-        index++;
-      }
-    }
-    /**
-     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
-     * the last element.
-     */
-    *reverseBegin() {
-      let index = this.size - 1;
-      while (index >= 0) {
-        yield this.getAt(index);
-        index--;
-      }
-    }
     /**
      * Time Complexity - Amortized O(1) (possible reallocation)
      * Space Complexity - O(n) (due to potential resizing).
@@ -3779,7 +3710,7 @@ var dataStructureTyped = (() => {
       }
       this._size += 1;
       this._buckets[this._bucketLast][this._lastInBucket] = element;
-      return this.size;
+      return true;
     }
     /**
      * Time Complexity: O(1)
@@ -3841,38 +3772,76 @@ var dataStructureTyped = (() => {
       }
       this._size += 1;
       this._buckets[this._bucketFirst][this._firstInBucket] = element;
-      return this.size;
+      return true;
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `shift()` function removes and returns the first element from a data structure, updating the
-     * internal state variables accordingly.
-     * @returns The element that is being removed from the beginning of the data structure is being
-     * returned.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `shift()` function removes and returns the first element from a data structure, updating the
+     * internal state variables accordingly.
+     * @returns The element that is being removed from the beginning of the data structure is being
+     * returned.
+     */
+    shift() {
+      if (this.size === 0)
+        return;
+      const element = this._buckets[this._bucketFirst][this._firstInBucket];
+      if (this.size !== 1) {
+        if (this._firstInBucket < this._bucketSize - 1) {
+          this._firstInBucket += 1;
+        } else if (this._bucketFirst < this._bucketCount - 1) {
+          this._bucketFirst += 1;
+          this._firstInBucket = 0;
+        } else {
+          this._bucketFirst = 0;
+          this._firstInBucket = 0;
+        }
+      }
+      this._size -= 1;
+      return element;
+    }
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     */
+    isEmpty() {
+      return this.size === 0;
+    }
+    /**
+     * The clear() function resets the state of the object by initializing all variables to their default
+     * values.
+     */
+    clear() {
+      this._buckets = [new Array(this._bucketSize)];
+      this._bucketCount = 1;
+      this._bucketFirst = this._bucketLast = this._size = 0;
+      this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
+    }
+    /**
+     * The below function is a generator that yields elements from a collection one by one.
+     */
+    *begin() {
+      let index = 0;
+      while (index < this.size) {
+        yield this.getAt(index);
+        index++;
+      }
+    }
+    /**
+     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
+     * the last element.
      */
-    shift() {
-      if (this.size === 0)
-        return;
-      const element = this._buckets[this._bucketFirst][this._firstInBucket];
-      if (this.size !== 1) {
-        if (this._firstInBucket < this._bucketSize - 1) {
-          this._firstInBucket += 1;
-        } else if (this._bucketFirst < this._bucketCount - 1) {
-          this._bucketFirst += 1;
-          this._firstInBucket = 0;
-        } else {
-          this._bucketFirst = 0;
-          this._firstInBucket = 0;
-        }
+    *reverseBegin() {
+      let index = this.size - 1;
+      while (index >= 0) {
+        yield this.getAt(index);
+        index--;
       }
-      this._size -= 1;
-      return element;
     }
     /**
      * Time Complexity: O(1)
@@ -3917,6 +3886,7 @@ var dataStructureTyped = (() => {
         indexInBucket
       } = this._getBucketAndPosition(pos);
       this._buckets[bucketIndex][indexInBucket] = element;
+      return true;
     }
     /**
      * Time Complexity: O(n)
@@ -3926,7 +3896,7 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `insertAt` function inserts one or more elements at a specified position in an array-like data
+     * The `addAt` function inserts one or more elements at a specified position in an array-like data
      * structure.
      * @param {number} pos - The `pos` parameter represents the position at which the element(s) should
      * be inserted. It is of type `number`.
@@ -3937,7 +3907,7 @@ var dataStructureTyped = (() => {
      * will be inserted once. However, you can provide a different value for `num` if you want
      * @returns The size of the array after the insertion is being returned.
      */
-    insertAt(pos, element, num = 1) {
+    addAt(pos, element, num = 1) {
       const length = this.size;
       rangeCheck(pos, 0, length);
       if (pos === 0) {
@@ -3957,7 +3927,7 @@ var dataStructureTyped = (() => {
         for (let i = 0; i < arr.length; ++i)
           this.push(arr[i]);
       }
-      return this.size;
+      return true;
     }
     /**
      * Time Complexity: O(1)
@@ -4025,7 +3995,7 @@ var dataStructureTyped = (() => {
         }
         this.pop();
       }
-      return this.size;
+      return true;
     }
     /**
      * Time Complexity: O(n)
@@ -4044,7 +4014,7 @@ var dataStructureTyped = (() => {
     delete(element) {
       const size = this.size;
       if (size === 0)
-        return 0;
+        return false;
       let i = 0;
       let index = 0;
       while (i < size) {
@@ -4056,7 +4026,7 @@ var dataStructureTyped = (() => {
         i += 1;
       }
       this.cut(index - 1);
-      return this.size;
+      return true;
     }
     /**
      * Time Complexity: O(n)
@@ -4096,7 +4066,7 @@ var dataStructureTyped = (() => {
      */
     unique() {
       if (this.size <= 1) {
-        return this.size;
+        return this;
       }
       let index = 1;
       let prev = this.getAt(0);
@@ -4108,7 +4078,7 @@ var dataStructureTyped = (() => {
         }
       }
       this.cut(index - 1);
-      return this.size;
+      return this;
     }
     /**
      * Time Complexity: O(n log n)
@@ -4122,7 +4092,7 @@ var dataStructureTyped = (() => {
      * @param [comparator] - The `comparator` parameter is a function that takes in two elements `x` and
      * `y` of type `E` and returns a number. The comparator function is used to determine the order of
      * the elements in the sorted array.
-     * @returns The method is returning the sorted instance of the object on which the method is called.
+     * @returns Deque<E>
      */
     sort(comparator) {
       const arr = [];
@@ -4192,7 +4162,7 @@ var dataStructureTyped = (() => {
           return element;
         }
       }
-      return void 0;
+      return;
     }
     /**
      * Time Complexity: O(n)
@@ -4229,11 +4199,7 @@ var dataStructureTyped = (() => {
      * @returns The `toArray()` method is returning an array of elements of type `E`.
      */
     toArray() {
-      const arr = [];
-      for (let i = 0; i < this.size; ++i) {
-        arr.push(this.getAt(i));
-      }
-      return arr;
+      return [...this];
     }
     /**
      * Time Complexity: O(n)
@@ -4293,11 +4259,55 @@ var dataStructureTyped = (() => {
       return newDeque;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
+     * Space Complexity: O(n) - Due to potential resizing.
      */
-    print() {
-      console.log([...this]);
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
+     *
+     * 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
+     * data structure.
+     */
+    addLast(element) {
+      return this.push(element);
+    }
+    /**
+     * Time Complexity: O(1) - Removes the first element.
+     * Space Complexity: O(1) - In-place operation.
+     */
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     *
+     * The function "pollLast" removes and returns the last element of an array.
+     * @returns The last element of the array is being returned.
+     */
+    pollLast() {
+      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.
+     */
+    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`.
+     */
+    pollFirst() {
+      return this.shift();
     }
     /**
      * Time Complexity: O(n)
@@ -4396,7 +4406,7 @@ var dataStructureTyped = (() => {
       }
       if (elements) {
         for (const el of elements) {
-          this.push(el);
+          this.add(el);
         }
       }
     }
@@ -4438,23 +4448,8 @@ var dataStructureTyped = (() => {
      * @param element - The element to be inserted.
      */
     add(element) {
-      return this.push(element);
-    }
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     *
-     * Insert an element into the heap and maintain the heap properties.
-     * @param element - The element to be inserted.
-     */
-    push(element) {
       this._elements.push(element);
-      this._bubbleUp(this.elements.length - 1);
-      return this;
+      return this._bubbleUp(this.elements.length - 1);
     }
     /**
      * Time Complexity: O(log n), where n is the number of elements in the heap.
@@ -4478,20 +4473,6 @@ var dataStructureTyped = (() => {
       }
       return value;
     }
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     *
-     * Remove and return the top element (smallest or largest element) from the heap.
-     * @returns The top element or undefined if the heap is empty.
-     */
-    pop() {
-      return this.poll();
-    }
     /**
      * Peek at the top element of the heap without removing it.
      * @returns The top element or undefined if the heap is empty.
@@ -4525,7 +4506,7 @@ var dataStructureTyped = (() => {
      */
     refill(elements) {
       this._elements = elements;
-      this.fix();
+      return this.fix();
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the heap.
@@ -4562,7 +4543,7 @@ var dataStructureTyped = (() => {
       if (index < 0)
         return false;
       if (index === 0) {
-        this.pop();
+        this.poll();
       } else if (index === this.elements.length - 1) {
         this.elements.pop();
       } else {
@@ -4669,8 +4650,10 @@ var dataStructureTyped = (() => {
      * Fix the entire heap to maintain heap properties.
      */
     fix() {
+      const results = [];
       for (let i = Math.floor(this.size / 2); i >= 0; i--)
-        this._sinkDown(i, this.elements.length >> 1);
+        results.push(this._sinkDown(i, this.elements.length >> 1));
+      return results;
     }
     /**
      * Time Complexity: O(n)
@@ -4697,7 +4680,7 @@ var dataStructureTyped = (() => {
       let index = 0;
       for (const current of this) {
         if (callback.call(thisArg, current, index, this)) {
-          filteredList.push(current);
+          filteredList.add(current);
         }
         index++;
       }
@@ -4736,13 +4719,6 @@ var dataStructureTyped = (() => {
       }
       return mappedHeap;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    print() {
-      console.log([...this]);
-    }
     *_getIterator() {
       for (const element of this.elements) {
         yield element;
@@ -4770,6 +4746,7 @@ var dataStructureTyped = (() => {
         index = parent;
       }
       this.elements[index] = element;
+      return true;
     }
     /**
      * Time Complexity: O(log n)
@@ -4795,6 +4772,7 @@ var dataStructureTyped = (() => {
         index = left;
       }
       this.elements[index] = element;
+      return true;
     }
   };
   var FibonacciHeapNode = class {
@@ -5175,43 +5153,6 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/data-structures/priority-queue/priority-queue.ts
-  var PriorityQueue = class extends Heap {
-    constructor(elements, options) {
-      super(elements, options);
-    }
-  };
-
-  // src/data-structures/priority-queue/min-priority-queue.ts
-  var MinPriorityQueue = class extends PriorityQueue {
-    constructor(elements, options = {
-      comparator: (a, b) => {
-        if (!(typeof a === "number" && typeof b === "number")) {
-          throw new Error("The a, b params of compare function must be number");
-        } else {
-          return a - b;
-        }
-      }
-    }) {
-      super(elements, options);
-    }
-  };
-
-  // src/data-structures/priority-queue/max-priority-queue.ts
-  var MaxPriorityQueue = class extends PriorityQueue {
-    constructor(elements, options = {
-      comparator: (a, b) => {
-        if (!(typeof a === "number" && typeof b === "number")) {
-          throw new Error("The a, b params of compare function must be number");
-        } else {
-          return b - a;
-        }
-      }
-    }) {
-      super(elements, options);
-    }
-  };
-
   // src/data-structures/graph/abstract-graph.ts
   var AbstractVertex = class {
     /**
@@ -5638,13 +5579,7 @@ var dataStructureTyped = (() => {
      * shortest paths from the source vertex to all other vertexMap in the graph. If `genPaths
      * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstraWithoutHeap(src, dest, getMinDist, genPaths) {
-      if (getMinDist === void 0)
-        getMinDist = false;
-      if (genPaths === void 0)
-        genPaths = false;
-      if (dest === void 0)
-        dest = void 0;
+    dijkstraWithoutHeap(src, dest = void 0, getMinDist = false, genPaths = false) {
       let minDist = Infinity;
       let minDest = void 0;
       let minPath = [];
@@ -5771,14 +5706,8 @@ var dataStructureTyped = (() => {
      * shortest paths from the source vertex to all other vertexMap in the graph. If `genPaths
      * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstra(src, dest, getMinDist, genPaths) {
+    dijkstra(src, dest = void 0, getMinDist = false, genPaths = false) {
       var _a;
-      if (getMinDist === void 0)
-        getMinDist = false;
-      if (genPaths === void 0)
-        genPaths = false;
-      if (dest === void 0)
-        dest = void 0;
       let minDist = Infinity;
       let minDest = void 0;
       let minPath = [];
@@ -5796,7 +5725,7 @@ var dataStructureTyped = (() => {
         if (vertexOrKey instanceof AbstractVertex)
           distMap.set(vertexOrKey, Infinity);
       }
-      const heap = new PriorityQueue([], { comparator: (a, b) => a.key - b.key });
+      const heap = new Heap([], { comparator: (a, b) => a.key - b.key });
       heap.add({ key: 0, value: srcVertex });
       distMap.set(srcVertex, 0);
       preMap.set(srcVertex, void 0);
@@ -6152,13 +6081,27 @@ var dataStructureTyped = (() => {
       }
       const cycles = /* @__PURE__ */ new Map();
       if (needCycles) {
-        let SCCs2 = /* @__PURE__ */ new Map();
-        if (SCCs2.size < 1) {
-          SCCs2 = getSCCs();
-        }
-        SCCs2.forEach((SCC, low) => {
-          if (SCC.length > 1) {
-            cycles.set(low, SCC);
+        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);
           }
         });
       }
@@ -7285,23 +7228,6 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/types/data-structures/binary-tree/binary-tree.ts
-  var IterationType = /* @__PURE__ */ ((IterationType3) => {
-    IterationType3["ITERATIVE"] = "ITERATIVE";
-    IterationType3["RECURSIVE"] = "RECURSIVE";
-    return IterationType3;
-  })(IterationType || {});
-  var FamilyPosition = /* @__PURE__ */ ((FamilyPosition2) => {
-    FamilyPosition2["ROOT"] = "ROOT";
-    FamilyPosition2["LEFT"] = "LEFT";
-    FamilyPosition2["RIGHT"] = "RIGHT";
-    FamilyPosition2["ROOT_LEFT"] = "ROOT_LEFT";
-    FamilyPosition2["ROOT_RIGHT"] = "ROOT_RIGHT";
-    FamilyPosition2["ISOLATED"] = "ISOLATED";
-    FamilyPosition2["MAL_NODE"] = "MAL_NODE";
-    return FamilyPosition2;
-  })(FamilyPosition || {});
-
   // src/types/data-structures/binary-tree/rb-tree.ts
   var RBTNColor = /* @__PURE__ */ ((RBTNColor2) => {
     RBTNColor2[RBTNColor2["RED"] = 1] = "RED";
@@ -7321,6 +7247,21 @@ var dataStructureTyped = (() => {
     CP2["gt"] = "gt";
     return CP2;
   })(CP || {});
+  var IterationType = /* @__PURE__ */ ((IterationType3) => {
+    IterationType3["ITERATIVE"] = "ITERATIVE";
+    IterationType3["RECURSIVE"] = "RECURSIVE";
+    return IterationType3;
+  })(IterationType || {});
+  var FamilyPosition = /* @__PURE__ */ ((FamilyPosition2) => {
+    FamilyPosition2["ROOT"] = "ROOT";
+    FamilyPosition2["LEFT"] = "LEFT";
+    FamilyPosition2["RIGHT"] = "RIGHT";
+    FamilyPosition2["ROOT_LEFT"] = "ROOT_LEFT";
+    FamilyPosition2["ROOT_RIGHT"] = "ROOT_RIGHT";
+    FamilyPosition2["ISOLATED"] = "ISOLATED";
+    FamilyPosition2["MAL_NODE"] = "MAL_NODE";
+    return FamilyPosition2;
+  })(FamilyPosition || {});
 
   // src/data-structures/binary-tree/binary-tree.ts
   var BinaryTreeNode = class {
@@ -7371,7 +7312,7 @@ var dataStructureTyped = (() => {
   var BinaryTree = class _BinaryTree extends IterableEntryBase {
     /**
      * The constructor function initializes a binary tree object with optional elements and options.
-     * @param [elements] - An optional iterable of BTNodeExemplar objects. These objects represent the
+     * @param [elements] - An optional iterable of BTNExemplar objects. These objects represent the
      * elements to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
@@ -7428,7 +7369,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V,N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V,N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the class N.
      */
     isNode(exemplar) {
@@ -7436,7 +7377,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node. If no value
      * is provided, it will be `undefined`.
@@ -7468,7 +7409,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param kne - BTNodeExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
+     * @param kne - BTNExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
      * two type parameters V and N, representing the value and node type respectively.
      * @returns a boolean value.
      */
@@ -7540,7 +7481,7 @@ var dataStructureTyped = (() => {
      *
      * The `addMany` function takes in a collection of nodes and an optional collection of values, and
      * adds each node with its corresponding value to the data structure.
-     * @param nodes - An iterable collection of BTNodeExemplar objects.
+     * @param nodes - An iterable collection of BTNExemplar objects.
      * @param [values] - An optional iterable of values that will be assigned to each node being added.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
@@ -7583,7 +7524,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that is used to determine the
      * identifier of the node to be deleted. It is optional and has a default value of
      * `this._defaultOneParamCallback`. The `callback` function should return the identifier of the node.
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
       const deletedResult = [];
@@ -8989,7 +8930,7 @@ var dataStructureTyped = (() => {
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
      * the tree with optional elements and options.
-     * @param [elements] - An optional iterable of BTNodeExemplar objects that will be added to the
+     * @param [elements] - An optional iterable of BTNExemplar objects that will be added to the
      * binary search tree.
      * @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:
@@ -9040,7 +8981,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
      */
     isNode(exemplar) {
@@ -9049,7 +8990,7 @@ var dataStructureTyped = (() => {
     /**
      * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
      * otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node.
      * @returns a node of type N or undefined.
@@ -10040,7 +9981,7 @@ var dataStructureTyped = (() => {
   var AVLTree = class _AVLTree extends BST {
     /**
      * The constructor function initializes an AVLTree object with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
      * objects. It represents a collection of elements that will be added to the AVL tree during
      * initialization.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
@@ -10079,7 +10020,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if an exemplar is an instance of AVLTreeNode.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
      */
     isNode(exemplar) {
@@ -10135,7 +10076,7 @@ var dataStructureTyped = (() => {
      * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
      * default to the `_defaultOneParamCallback` function. The `callback` function should have a single
      * parameter of type `N
-     * @returns The method is returning an array of `BiTreeDeleteResult<N>`.
+     * @returns The method is returning an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
       if (identifier instanceof AVLTreeNode)
@@ -10465,7 +10406,7 @@ var dataStructureTyped = (() => {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -10518,7 +10459,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
@@ -10536,7 +10477,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
@@ -10638,7 +10579,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
      * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
      * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
       const ans = [];
@@ -10729,7 +10670,7 @@ var dataStructureTyped = (() => {
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
       var _a;
-      if (identifier instanceof BinaryTreeNode)
+      if (identifier instanceof RedBlackTreeNode)
         callback = (node) => node;
       beginRoot = this.ensureNode(beginRoot);
       return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
@@ -11049,7 +10990,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
@@ -11067,7 +11008,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -11215,7 +11156,7 @@ var dataStructureTyped = (() => {
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
       var _a;
@@ -11411,6 +11352,43 @@ var dataStructureTyped = (() => {
     }
   };
 
+  // src/data-structures/priority-queue/priority-queue.ts
+  var PriorityQueue = class extends Heap {
+    constructor(elements, options) {
+      super(elements, options);
+    }
+  };
+
+  // src/data-structures/priority-queue/min-priority-queue.ts
+  var MinPriorityQueue = class extends PriorityQueue {
+    constructor(elements, options = {
+      comparator: (a, b) => {
+        if (!(typeof a === "number" && typeof b === "number")) {
+          throw new Error("The a, b params of compare function must be number");
+        } else {
+          return a - b;
+        }
+      }
+    }) {
+      super(elements, options);
+    }
+  };
+
+  // src/data-structures/priority-queue/max-priority-queue.ts
+  var MaxPriorityQueue = class extends PriorityQueue {
+    constructor(elements, options = {
+      comparator: (a, b) => {
+        if (!(typeof a === "number" && typeof b === "number")) {
+          throw new Error("The a, b params of compare function must be number");
+        } else {
+          return b - a;
+        }
+      }
+    }) {
+      super(elements, options);
+    }
+  };
+
   // src/data-structures/matrix/matrix.ts
   var MatrixNTI2D = class {
     /**
@@ -12333,11 +12311,11 @@ var dataStructureTyped = (() => {
      * @returns The `filter` method is returning an array of strings (`string[]`).
      */
     filter(predicate, thisArg) {
-      const results = [];
+      const results = new _Trie();
       let index = 0;
       for (const word of this) {
         if (predicate.call(thisArg, word, index, this)) {
-          results.push(word);
+          results.add(word);
         }
         index++;
       }
@@ -12369,9 +12347,6 @@ var dataStructureTyped = (() => {
       }
       return newTrie;
     }
-    print() {
-      console.log([...this]);
-    }
     *_getIterator() {
       function* _dfs(node, path) {
         if (node.isEnd) {