data-structure-typed 1.49.1 → 1.49.3

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

@@ -616,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 {
     /**
@@ -751,6 +765,13 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    print() {
+      console.log([...this]);
+    }
   };
 
   // src/utils/utils.ts
@@ -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)) {
@@ -1171,18 +1198,13 @@ var dataStructureTyped = (() => {
         return hash in this._noObjMap;
       }
     }
-    hasValue(value) {
-      for (const [, elementValue] of this) {
-        if (elementValue === value)
-          return true;
-      }
-      return false;
-    }
     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)
@@ -1225,7 +1247,7 @@ var dataStructureTyped = (() => {
       while (index--) {
         node = node.next;
       }
-      return [node.key, node.value];
+      return node.value;
     }
     /**
      * Time Complexity: O(1)
@@ -1272,8 +1294,7 @@ var dataStructureTyped = (() => {
       while (index--) {
         node = node.next;
       }
-      this._deleteNode(node);
-      return this._size;
+      return this._deleteNode(node);
     }
     /**
      * Time Complexity: O(1)
@@ -1366,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.
@@ -1403,6 +1424,7 @@ var dataStructureTyped = (() => {
         this._tail = prev;
       }
       this._size -= 1;
+      return true;
     }
   };
 
@@ -1428,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);
@@ -1443,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.
@@ -1487,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.
@@ -1502,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.
@@ -1524,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;
@@ -1534,7 +1557,7 @@ var dataStructureTyped = (() => {
       const value = this.tail.value;
       current.next = void 0;
       this._tail = current;
-      this._length--;
+      this._size--;
       return value;
     }
     /**
@@ -1569,7 +1592,7 @@ var dataStructureTyped = (() => {
         return void 0;
       const removedNode = this.head;
       this._head = this.head.next;
-      this._length--;
+      this._size--;
       return removedNode.value;
     }
     /**
@@ -1607,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.
@@ -1622,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.
@@ -1639,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++) {
@@ -1683,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.
@@ -1732,7 +1760,7 @@ var dataStructureTyped = (() => {
               this._tail = prev;
             }
           }
-          this._length--;
+          this._size--;
           return true;
         }
         prev = current;
@@ -1748,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
@@ -1756,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;
       }
@@ -1771,7 +1799,7 @@ var dataStructureTyped = (() => {
       const prevNode = this.getNodeAt(index - 1);
       newNode.next = prevNode.next;
       prevNode.next = newNode;
-      this._length++;
+      this._size++;
       return true;
     }
     /**
@@ -1780,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.
@@ -1788,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.
@@ -1823,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;
@@ -1834,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.
@@ -1916,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;
@@ -1942,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;
@@ -1957,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;
@@ -1978,7 +2007,7 @@ var dataStructureTyped = (() => {
         if (existingNode === this.tail) {
           this._tail = newNode;
         }
-        this._length++;
+        this._size++;
         return true;
       }
       return false;
@@ -2065,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) {
@@ -2099,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);
@@ -2121,18 +2143,45 @@ 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 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(1)
+     * 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;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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
@@ -2168,21 +2217,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)
@@ -2207,26 +2243,11 @@ 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)
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      */
     /**
@@ -2248,26 +2269,11 @@ 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)
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      */
     /**
@@ -2288,52 +2294,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.
@@ -2350,7 +2312,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++) {
@@ -2374,7 +2336,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++) {
@@ -2422,14 +2384,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;
       }
@@ -2440,7 +2402,7 @@ var dataStructureTyped = (() => {
       newNode.next = nextNode;
       prevNode.next = newNode;
       nextNode.prev = newNode;
-      this._length++;
+      this._size++;
       return true;
     }
     /**
@@ -2451,7 +2413,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.
@@ -2460,7 +2422,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;
@@ -2478,7 +2440,7 @@ var dataStructureTyped = (() => {
         if (existingNode === this.head) {
           this._head = newNode;
         }
-        this._length++;
+        this._size++;
         return true;
       }
       return false;
@@ -2491,7 +2453,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.
@@ -2499,7 +2461,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;
@@ -2517,15 +2479,11 @@ var dataStructureTyped = (() => {
         if (existingNode === this.tail) {
           this._tail = newNode;
         }
-        this._length++;
+        this._size++;
         return true;
       }
       return false;
     }
-    /**
-     * 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)
@@ -2537,24 +2495,24 @@ 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.
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -2582,26 +2540,34 @@ 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.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * 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.
      */
     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.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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.
@@ -2655,7 +2621,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -2680,7 +2646,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -2696,9 +2662,10 @@ 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.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
@@ -2738,8 +2705,8 @@ var dataStructureTyped = (() => {
       return array;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -2770,8 +2737,8 @@ var dataStructureTyped = (() => {
       return filteredList;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -2799,12 +2766,64 @@ 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(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(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(n), where n is the number of elements in the linked list.
+     * 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);
     }
     /**
      * The function returns an iterator that iterates over the values of a linked list.
@@ -2859,6 +2878,41 @@ var dataStructureTyped = (() => {
     get probability() {
       return this._probability;
     }
+    /**
+     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
+     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     */
+    /**
+     * Time Complexity: O(1) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
+     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     *
+     * 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.
+     */
+    get first() {
+      const firstNode = this.head.forward[0];
+      return firstNode ? firstNode.value : void 0;
+    }
+    /**
+     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
+     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     */
+    /**
+     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
+     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+     *
+     * 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.
+     */
+    get last() {
+      let current = this.head;
+      for (let i = this.level - 1; i >= 0; i--) {
+        while (current.forward[i]) {
+          current = current.forward[i];
+        }
+      }
+      return current.value;
+    }
     /**
      * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
      * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
@@ -2917,7 +2971,7 @@ var dataStructureTyped = (() => {
       return void 0;
     }
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
+     * Time Complexity: O(1) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
      * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
      */
     /**
@@ -2964,41 +3018,6 @@ var dataStructureTyped = (() => {
       }
       return false;
     }
-    /**
-     * Time Complexity: O(1) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
-     */
-    /**
-     * Time Complexity: O(1) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
-     *
-     * 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() {
-      const firstNode = this.head.forward[0];
-      return firstNode ? firstNode.value : void 0;
-    }
-    /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
-     */
-    /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-     * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
-     *
-     * 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() {
-      let current = this.head;
-      for (let i = this.level - 1; i >= 0; i--) {
-        while (current.forward[i]) {
-          current = current.forward[i];
-        }
-      }
-      return current.value;
-    }
     /**
      * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
      * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
@@ -3147,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.
@@ -3163,7 +3182,7 @@ var dataStructureTyped = (() => {
      */
     pop() {
       if (this.isEmpty())
-        return void 0;
+        return;
       return this.elements.pop();
     }
     /**
@@ -3257,9 +3276,6 @@ var dataStructureTyped = (() => {
       }
       return newStack;
     }
-    print() {
-      console.log([...this]);
-    }
     /**
      * Custom iterator for the Stack class.
      * @returns An iterator object.
@@ -3299,6 +3315,36 @@ var dataStructureTyped = (() => {
     get size() {
       return this.nodes.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.
+     *
+     * 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`.
+     */
+    get first() {
+      return this.size > 0 ? this.nodes[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) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     *
+     * 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`.
+     */
+    get last() {
+      return this.size > 0 ? this.nodes[this.nodes.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.
+     */
     /**
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
@@ -3311,7 +3357,7 @@ var dataStructureTyped = (() => {
       return new _Queue(elements);
     }
     /**
-     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      */
     /**
@@ -3324,10 +3370,10 @@ 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.
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      */
     /**
@@ -3341,7 +3387,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;
@@ -3349,21 +3395,6 @@ var dataStructureTyped = (() => {
       this._offset = 0;
       return 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) - 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 `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
-     */
-    getFirst() {
-      return this.size > 0 ? this.nodes[this.offset] : void 0;
-    }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -3377,22 +3408,7 @@ var dataStructureTyped = (() => {
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     peek() {
-      return this.getFirst();
-    }
-    /**
-     * 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) - 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
-     * array is empty, it returns `undefined`.
-     */
-    getLast() {
-      return this.size > 0 ? this.nodes[this.nodes.length - 1] : void 0;
+      return this.first;
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
@@ -3407,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.
@@ -3499,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)
@@ -3572,190 +3585,101 @@ var dataStructureTyped = (() => {
   };
   var LinkedListQueue = class extends SinglyLinkedList {
     /**
-     * The enqueue function adds a value to the end of an array.
-     * @param {E} value - The value parameter represents the value that you want to add to the queue.
+     * 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`.
      */
-    enqueue(value) {
-      this.push(value);
-    }
-    /**
-     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
-     * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
-     */
-    dequeue() {
-      return this.shift();
-    }
-    /**
-     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-     */
-    getFirst() {
+    get first() {
       var _a;
       return (_a = this.head) == null ? void 0 : _a.value;
     }
     /**
-     * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-     */
-    peek() {
-      return this.getFirst();
-    }
-  };
-
-  // src/data-structures/queue/deque.ts
-  var Deque = class _Deque extends IterableElementBase {
-    /**
-     * The constructor initializes a data structure with a specified bucket size and populates it with
-     * elements from an iterable.
-     * @param elements - The `elements` parameter is an iterable object (such as an array or a Set) that
-     * contains the initial elements to be stored in the data structure. It can also be an object with a
-     * `length` property or a `size` property, which represents the number of elements in the iterable.
-     * @param bucketSize - The `bucketSize` parameter is the maximum number of elements that can be
-     * stored in each bucket. It determines the size of each bucket in the data structure.
-     */
-    constructor(elements = [], bucketSize = 1 << 12) {
-      super();
-      __publicField(this, "_bucketFirst", 0);
-      __publicField(this, "_firstInBucket", 0);
-      __publicField(this, "_bucketLast", 0);
-      __publicField(this, "_lastInBucket", 0);
-      __publicField(this, "_bucketCount", 0);
-      __publicField(this, "_bucketSize");
-      __publicField(this, "_buckets", []);
-      __publicField(this, "_size", 0);
-      let _size;
-      if ("length" in elements) {
-        if (elements.length instanceof Function)
-          _size = elements.length();
-        else
-          _size = elements.length;
-      } else {
-        if (elements.size instanceof Function)
-          _size = elements.size();
-        else
-          _size = elements.size;
-      }
-      this._bucketSize = bucketSize;
-      this._bucketCount = calcMinUnitsRequired(_size, this._bucketSize) || 1;
-      for (let i = 0; i < this._bucketCount; ++i) {
-        this._buckets.push(new Array(this._bucketSize));
-      }
-      const needBucketNum = calcMinUnitsRequired(_size, this._bucketSize);
-      this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
-      this._firstInBucket = this._lastInBucket = this._bucketSize - _size % this._bucketSize >> 1;
-      for (const element of elements) {
-        this.push(element);
-      }
-    }
-    get buckets() {
-      return this._buckets;
-    }
-    get size() {
-      return this._size;
-    }
-    /**
-     * The function returns the first element in a collection if it exists, otherwise it returns
-     * undefined.
-     * @returns The first element of the collection, of type E, is being returned.
-     */
-    get first() {
-      if (this.size === 0)
-        return;
-      return this._buckets[this._bucketFirst][this._firstInBucket];
-    }
-    get last() {
-      if (this.size === 0)
-        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.
+     * The enqueue function adds a value to the end of an array.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
-    addFirst(element) {
-      this.unshift(element);
+    enqueue(value) {
+      return this.push(value);
     }
     /**
-     * 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`.
+     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
+     * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
      */
-    pollFirst() {
+    dequeue() {
       return this.shift();
     }
     /**
-     * The clear() function resets the state of the object by initializing all variables to their default
-     * values.
+     * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
-    clear() {
-      this._buckets = [new Array(this._bucketSize)];
-      this._bucketCount = 1;
-      this._bucketFirst = this._bucketLast = this._size = 0;
-      this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
+    peek() {
+      return this.first;
     }
+  };
+
+  // src/data-structures/queue/deque.ts
+  var Deque = class _Deque extends IterableElementBase {
     /**
-     * The below function is a generator that yields elements from a collection one by one.
+     * The constructor initializes a data structure with a specified bucket size and populates it with
+     * elements from an iterable.
+     * @param elements - The `elements` parameter is an iterable object (such as an array or a Set) that
+     * contains the initial elements to be stored in the data structure. It can also be an object with a
+     * `length` property or a `size` property, which represents the number of elements in the iterable.
+     * @param bucketSize - The `bucketSize` parameter is the maximum number of elements that can be
+     * stored in each bucket. It determines the size of each bucket in the data structure.
      */
-    *begin() {
-      let index = 0;
-      while (index < this.size) {
-        yield this.getAt(index);
-        index++;
+    constructor(elements = [], bucketSize = 1 << 12) {
+      super();
+      __publicField(this, "_bucketFirst", 0);
+      __publicField(this, "_firstInBucket", 0);
+      __publicField(this, "_bucketLast", 0);
+      __publicField(this, "_lastInBucket", 0);
+      __publicField(this, "_bucketCount", 0);
+      __publicField(this, "_bucketSize");
+      __publicField(this, "_buckets", []);
+      __publicField(this, "_size", 0);
+      let _size;
+      if ("length" in elements) {
+        if (elements.length instanceof Function)
+          _size = elements.length();
+        else
+          _size = elements.length;
+      } else {
+        if (elements.size instanceof Function)
+          _size = elements.size();
+        else
+          _size = elements.size;
+      }
+      this._bucketSize = bucketSize;
+      this._bucketCount = calcMinUnitsRequired(_size, this._bucketSize) || 1;
+      for (let i = 0; i < this._bucketCount; ++i) {
+        this._buckets.push(new Array(this._bucketSize));
+      }
+      const needBucketNum = calcMinUnitsRequired(_size, this._bucketSize);
+      this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
+      this._firstInBucket = this._lastInBucket = this._bucketSize - _size % this._bucketSize >> 1;
+      for (const element of elements) {
+        this.push(element);
       }
     }
+    get buckets() {
+      return this._buckets;
+    }
+    get size() {
+      return this._size;
+    }
     /**
-     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
-     * the last element.
+     * The function returns the first element in a collection if it exists, otherwise it returns
+     * undefined.
+     * @returns The first element of the collection, of type E, is being returned.
      */
-    *reverseBegin() {
-      let index = this.size - 1;
-      while (index >= 0) {
-        yield this.getAt(index);
-        index--;
-      }
+    get first() {
+      if (this.size === 0)
+        return;
+      return this._buckets[this._bucketFirst][this._firstInBucket];
+    }
+    get last() {
+      if (this.size === 0)
+        return;
+      return this._buckets[this._bucketLast][this._lastInBucket];
     }
     /**
      * Time Complexity - Amortized O(1) (possible reallocation)
@@ -3786,7 +3710,7 @@ var dataStructureTyped = (() => {
       }
       this._size += 1;
       this._buckets[this._bucketLast][this._lastInBucket] = element;
-      return this.size;
+      return true;
     }
     /**
      * Time Complexity: O(1)
@@ -3848,7 +3772,7 @@ var dataStructureTyped = (() => {
       }
       this._size += 1;
       this._buckets[this._bucketFirst][this._firstInBucket] = element;
-      return this.size;
+      return true;
     }
     /**
      * Time Complexity: O(1)
@@ -3881,6 +3805,44 @@ var dataStructureTyped = (() => {
       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.
+     */
+    *reverseBegin() {
+      let index = this.size - 1;
+      while (index >= 0) {
+        yield this.getAt(index);
+        index--;
+      }
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -3924,6 +3886,7 @@ var dataStructureTyped = (() => {
         indexInBucket
       } = this._getBucketAndPosition(pos);
       this._buckets[bucketIndex][indexInBucket] = element;
+      return true;
     }
     /**
      * Time Complexity: O(n)
@@ -3933,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`.
@@ -3944,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) {
@@ -3964,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)
@@ -4032,7 +3995,7 @@ var dataStructureTyped = (() => {
         }
         this.pop();
       }
-      return this.size;
+      return true;
     }
     /**
      * Time Complexity: O(n)
@@ -4051,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) {
@@ -4063,7 +4026,7 @@ var dataStructureTyped = (() => {
         i += 1;
       }
       this.cut(index - 1);
-      return this.size;
+      return true;
     }
     /**
      * Time Complexity: O(n)
@@ -4103,7 +4066,7 @@ var dataStructureTyped = (() => {
      */
     unique() {
       if (this.size <= 1) {
-        return this.size;
+        return this;
       }
       let index = 1;
       let prev = this.getAt(0);
@@ -4115,7 +4078,7 @@ var dataStructureTyped = (() => {
         }
       }
       this.cut(index - 1);
-      return this.size;
+      return this;
     }
     /**
      * Time Complexity: O(n log n)
@@ -4129,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 = [];
@@ -4199,7 +4162,7 @@ var dataStructureTyped = (() => {
           return element;
         }
       }
-      return void 0;
+      return;
     }
     /**
      * Time Complexity: O(n)
@@ -4236,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)
@@ -4300,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)
@@ -4403,7 +4406,7 @@ var dataStructureTyped = (() => {
       }
       if (elements) {
         for (const el of elements) {
-          this.push(el);
+          this.add(el);
         }
       }
     }
@@ -4445,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.
@@ -4485,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.
@@ -4532,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.
@@ -4569,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 {
@@ -4676,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)
@@ -4704,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++;
       }
@@ -4743,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;
@@ -4777,6 +4746,7 @@ var dataStructureTyped = (() => {
         index = parent;
       }
       this.elements[index] = element;
+      return true;
     }
     /**
      * Time Complexity: O(log n)
@@ -4802,6 +4772,7 @@ var dataStructureTyped = (() => {
         index = left;
       }
       this.elements[index] = element;
+      return true;
     }
   };
   var FibonacciHeapNode = class {
@@ -5271,10 +5242,10 @@ var dataStructureTyped = (() => {
      */
     addVertex(keyOrVertex, value) {
       if (keyOrVertex instanceof AbstractVertex) {
-        return this._addVertexOnly(keyOrVertex);
+        return this._addVertex(keyOrVertex);
       } else {
         const newVertex = this.createVertex(keyOrVertex, value);
-        return this._addVertexOnly(newVertex);
+        return this._addVertex(newVertex);
       }
     }
     isVertexKey(potentialKey) {
@@ -5344,7 +5315,7 @@ var dataStructureTyped = (() => {
      */
     addEdge(srcOrEdge, dest, weight, value) {
       if (srcOrEdge instanceof AbstractEdge) {
-        return this._addEdgeOnly(srcOrEdge);
+        return this._addEdge(srcOrEdge);
       } else {
         if (dest instanceof AbstractVertex || typeof dest === "string" || typeof dest === "number") {
           if (!(this.hasVertex(srcOrEdge) && this.hasVertex(dest)))
@@ -5354,7 +5325,7 @@ var dataStructureTyped = (() => {
           if (dest instanceof AbstractVertex)
             dest = dest.key;
           const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
-          return this._addEdgeOnly(newEdge);
+          return this._addEdge(newEdge);
         } else {
           throw new Error("dest must be a Vertex or vertex key while srcOrEdge is an Edge");
         }
@@ -6160,13 +6131,6 @@ var dataStructureTyped = (() => {
     getLowMap() {
       return this.tarjan(false, false, false, false).lowMap;
     }
-    /**
-     * The function `getCycles` returns a map of cycles found using the Tarjan algorithm.
-     * @returns The function `getCycles()` is returning a `Map<number, VO[]>`.
-     */
-    getCycles() {
-      return this.tarjan(false, false, false, true).cycles;
-    }
     /**
      * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
      * @returns an array of VO objects, specifically the cut vertexes.
@@ -6189,6 +6153,44 @@ var dataStructureTyped = (() => {
     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;
+        }
+        visited2.add(vertex);
+        currentPath.push(vertex.key);
+        for (const neighbor of this.getNeighbors(vertex)) {
+          neighbor && dfs(neighbor, currentPath, visited2);
+        }
+        visited2.delete(vertex);
+        currentPath.pop();
+      };
+      for (const vertex of this.vertexMap.values()) {
+        dfs(vertex, [], visited);
+      }
+      const uniqueCycles = /* @__PURE__ */ new Map();
+      for (const cycle of cycles) {
+        const sorted = [...cycle].sort().toString();
+        if (uniqueCycles.has(sorted))
+          continue;
+        else {
+          uniqueCycles.set(sorted, cycle);
+        }
+      }
+      return [...uniqueCycles].map(
+        (cycleString) => cycleString[1]
+      );
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -6251,7 +6253,7 @@ var dataStructureTyped = (() => {
         yield [vertex.key, vertex.value];
       }
     }
-    _addVertexOnly(newVertex) {
+    _addVertex(newVertex) {
       if (this.hasVertex(newVertex)) {
         return false;
       }
@@ -6788,13 +6790,13 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_addEdgeOnly` adds an edge to a graph if the source and destination vertexMap exist.
+     * The function `_addEdge` adds an edge to a graph if the source and destination vertexMap exist.
      * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph. It is the edge that
      * needs to be added to the graph.
      * @returns a boolean value. It returns true if the edge was successfully added to the graph, and false if either the
      * source or destination vertex does not exist in the graph.
      */
-    _addEdgeOnly(edge) {
+    _addEdge(edge) {
       if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
         return false;
       }
@@ -7148,7 +7150,7 @@ var dataStructureTyped = (() => {
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
      * @returns a boolean value.
      */
-    _addEdgeOnly(edge) {
+    _addEdge(edge) {
       for (const end of edge.vertexMap) {
         const endVertex = this._getVertex(end);
         if (endVertex === void 0)
@@ -12340,11 +12342,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++;
       }
@@ -12376,9 +12378,6 @@ var dataStructureTyped = (() => {
       }
       return newTrie;
     }
-    print() {
-      console.log([...this]);
-    }
     *_getIterator() {
       function* _dfs(node, path) {
         if (node.isEnd) {