bst-typed 1.53.7 → 1.53.9

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -497,7 +497,7 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * `DoublyLinkedListOptions<E, R>`. It is an optional parameter that allows you to pass additional
      * configuration options to customize the behavior of the DoublyLinkedList.
      */
-    constructor(elements?: Iterable<E> | Iterable<R>, options?: DoublyLinkedListOptions<E, R>);
+    constructor(elements?: Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>, options?: DoublyLinkedListOptions<E, R>);
     protected _head: DoublyLinkedListNode<E> | undefined;
     /**
      * The `head` function returns the first node of a doubly linked list.
@@ -533,6 +533,16 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The method `get last()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
      */
     get last(): E | undefined;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
+     * given array.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+     * @returns The `fromArray` function returns a DoublyLinkedList object.
+     */
+    static fromArray<E>(data: E[]): DoublyLinkedList<E, any>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -585,6 +595,35 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The `unshift` method is returning a boolean value, specifically `true`.
      */
     unshift(elementOrNode: E | DoublyLinkedListNode<E>): boolean;
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `pushMany` iterates over elements and pushes them into a data structure, applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `pushMany` function can accept an iterable containing elements of type `E`, `R`,
+     * or `DoublyLinkedListNode<E>`. The function iterates over each element in the iterable and pushes
+     * it onto the linked list. If a transformation function `to
+     * @returns The `pushMany` function is returning an array of boolean values (`ans`) which indicate
+     * the success or failure of pushing each element into the data structure.
+     */
+    pushMany(elements: Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>): boolean[];
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `unshiftMany` iterates through a collection of elements and adds them to the
+     * beginning of a Doubly Linked List, returning an array of boolean values indicating the success of
+     * each insertion.
+     * @param {Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `unshiftMany` function can accept an iterable containing elements of type `E`,
+     * `R`, or `DoublyLinkedListNode<E>`. The function iterates over each element in the iterable and
+     * performs an `unshift` operation on the doubly linked list
+     * @returns The `unshiftMany` function returns an array of boolean values indicating the success of
+     * each unshift operation performed on the elements passed as input.
+     */
+    unshiftMany(elements: Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>): boolean[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -830,18 +869,14 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
+     * The function `countOccurrences` iterates through a doubly linked list and counts the occurrences
+     * of a specified element or nodes that satisfy a given predicate.
+     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementOrNode
+     * - The `elementOrNode` parameter in the `countOccurrences` method can accept three types of values:
+     * @returns The `countOccurrences` method returns the number of occurrences of the specified element,
+     * node, or predicate function in the doubly linked list.
      */
     countOccurrences(elementOrNode: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): number;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
-     * given array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a DoublyLinkedList object.
-     */
-    static fromArray<E>(data: E[]): DoublyLinkedList<E, any>;
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -511,15 +511,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         this._head = undefined;
         this._tail = undefined;
         this._size = 0;
-        if (elements) {
-            for (const el of elements) {
-                if (this.toElementFn) {
-                    this.push(this.toElementFn(el));
-                }
-                else
-                    this.push(el);
-            }
-        }
+        this.pushMany(elements);
     }
     /**
      * The `head` function returns the first node of a doubly linked list.
@@ -565,6 +557,18 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         var _a;
         return (_a = this.tail) === null || _a === void 0 ? void 0 : _a.value;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
+     * given array.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+     * @returns The `fromArray` function returns a DoublyLinkedList object.
+     */
+    static fromArray(data) {
+        return new DoublyLinkedList(data);
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -673,6 +677,55 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         this._size++;
         return true;
     }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `pushMany` iterates over elements and pushes them into a data structure, applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `pushMany` function can accept an iterable containing elements of type `E`, `R`,
+     * or `DoublyLinkedListNode<E>`. The function iterates over each element in the iterable and pushes
+     * it onto the linked list. If a transformation function `to
+     * @returns The `pushMany` function is returning an array of boolean values (`ans`) which indicate
+     * the success or failure of pushing each element into the data structure.
+     */
+    pushMany(elements) {
+        const ans = [];
+        for (const el of elements) {
+            if (this.toElementFn) {
+                ans.push(this.push(this.toElementFn(el)));
+                continue;
+            }
+            ans.push(this.push(el));
+        }
+        return ans;
+    }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `unshiftMany` iterates through a collection of elements and adds them to the
+     * beginning of a Doubly Linked List, returning an array of boolean values indicating the success of
+     * each insertion.
+     * @param {Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `unshiftMany` function can accept an iterable containing elements of type `E`,
+     * `R`, or `DoublyLinkedListNode<E>`. The function iterates over each element in the iterable and
+     * performs an `unshift` operation on the doubly linked list
+     * @returns The `unshiftMany` function returns an array of boolean values indicating the success of
+     * each unshift operation performed on the elements passed as input.
+     */
+    unshiftMany(elements) {
+        const ans = [];
+        for (const el of elements) {
+            if (this.toElementFn) {
+                ans.push(this.unshift(this.toElementFn(el)));
+                continue;
+            }
+            ans.push(this.unshift(el));
+        }
+        return ans;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -1124,6 +1177,12 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
+     * The function `countOccurrences` iterates through a doubly linked list and counts the occurrences
+     * of a specified element or nodes that satisfy a given predicate.
+     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementOrNode
+     * - The `elementOrNode` parameter in the `countOccurrences` method can accept three types of values:
+     * @returns The `countOccurrences` method returns the number of occurrences of the specified element,
+     * node, or predicate function in the doubly linked list.
      */
     countOccurrences(elementOrNode) {
         const predicate = this._ensurePredicate(elementOrNode);
@@ -1137,18 +1196,6 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         }
         return count;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
-     * given array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a DoublyLinkedList object.
-     */
-    static fromArray(data) {
-        return new DoublyLinkedList(data);
-    }
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -41,7 +41,7 @@ export declare class SinglyLinkedListNode<E = any> {
     set next(value: SinglyLinkedListNode<E> | undefined);
 }
 export declare class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R, SinglyLinkedList<E, R>> {
-    constructor(elements?: Iterable<E> | Iterable<R>, options?: SinglyLinkedListOptions<E, R>);
+    constructor(elements?: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>, options?: SinglyLinkedListOptions<E, R>);
     protected _head: SinglyLinkedListNode<E> | undefined;
     /**
      * The `head` function returns the first node of a singly linked list.
@@ -72,6 +72,16 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The size of the object, which is a number.
      */
     get size(): number;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
+     * array.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+     * @returns The `fromArray` function returns a `SinglyLinkedList` object.
+     */
+    static fromArray<E>(data: E[]): SinglyLinkedList<E, any>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -111,6 +121,33 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The `unshift` method is returning a boolean value, specifically `true`.
      */
     unshift(elementOrNode: E | SinglyLinkedListNode<E>): boolean;
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `pushMany` iterates over elements and pushes them into a data structure, applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `pushMany` function can accept an iterable containing elements of type `E`, `R`,
+     * or `SinglyLinkedListNode<E>`.
+     * @returns The `pushMany` function returns an array of boolean values indicating whether each
+     * element was successfully pushed into the data structure.
+     */
+    pushMany(elements: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>): boolean[];
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `unshiftMany` iterates over elements and adds them to a data structure, optionally
+     * converting them using a provided function.
+     * @param {Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `unshiftMany` function can accept an iterable containing elements of type `E`,
+     * `R`, or `SinglyLinkedListNode<E>`. The function iterates over each element in the iterable and
+     * performs an `unshift` operation on the linked list for each
+     * @returns The `unshiftMany` function is returning an array of boolean values, where each value
+     * represents the result of calling the `unshift` method on the current instance of the class.
+     */
+    unshiftMany(elements: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>): boolean[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -199,12 +236,18 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      */
     addAt(index: number, newElementOrNode: E | SinglyLinkedListNode<E>): boolean;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the length of a data structure is equal to zero and returns a boolean value indicating
      * whether it is empty or not.
      * @returns A boolean value indicating whether the length of the object is equal to 0.
      */
     isEmpty(): boolean;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
      */
     clear(): void;
@@ -351,16 +394,6 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      * The function `_getIterator` returns an iterable iterator that yields the values of a linked list.
      */
     protected _getIterator(): IterableIterator<E>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
-     * array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a `SinglyLinkedList` object.
-     */
-    static fromArray<E>(data: E[]): SinglyLinkedList<E, any>;
     /**
      * The _isPredicate function in TypeScript checks if the input is a function that takes a
      * SinglyLinkedListNode as an argument and returns a boolean.

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -49,16 +49,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
     constructor(elements = [], options) {
         super(options);
         this._size = 0;
-        if (elements) {
-            for (const el of elements) {
-                if (this.toElementFn) {
-                    this.push(this.toElementFn(el));
-                }
-                else {
-                    this.push(el);
-                }
-            }
-        }
+        this.pushMany(elements);
     }
     /**
      * The `head` function returns the first node of a singly linked list.
@@ -99,6 +90,22 @@ class SinglyLinkedList extends base_1.IterableElementBase {
     get size() {
         return this._size;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
+     * array.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+     * @returns The `fromArray` function returns a `SinglyLinkedList` object.
+     */
+    static fromArray(data) {
+        const singlyLinkedList = new SinglyLinkedList();
+        for (const item of data) {
+            singlyLinkedList.push(item);
+        }
+        return singlyLinkedList;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -188,6 +195,53 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         this._size++;
         return true;
     }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `pushMany` iterates over elements and pushes them into a data structure, applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `pushMany` function can accept an iterable containing elements of type `E`, `R`,
+     * or `SinglyLinkedListNode<E>`.
+     * @returns The `pushMany` function returns an array of boolean values indicating whether each
+     * element was successfully pushed into the data structure.
+     */
+    pushMany(elements) {
+        const ans = [];
+        for (const el of elements) {
+            if (this.toElementFn) {
+                ans.push(this.push(this.toElementFn(el)));
+                continue;
+            }
+            ans.push(this.push(el));
+        }
+        return ans;
+    }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The function `unshiftMany` iterates over elements and adds them to a data structure, optionally
+     * converting them using a provided function.
+     * @param {Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>} elements - The `elements`
+     * parameter in the `unshiftMany` function can accept an iterable containing elements of type `E`,
+     * `R`, or `SinglyLinkedListNode<E>`. The function iterates over each element in the iterable and
+     * performs an `unshift` operation on the linked list for each
+     * @returns The `unshiftMany` function is returning an array of boolean values, where each value
+     * represents the result of calling the `unshift` method on the current instance of the class.
+     */
+    unshiftMany(elements) {
+        const ans = [];
+        for (const el of elements) {
+            if (this.toElementFn) {
+                ans.push(this.unshift(this.toElementFn(el)));
+                continue;
+            }
+            ans.push(this.unshift(el));
+        }
+        return ans;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -366,6 +420,9 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         return true;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the length of a data structure is equal to zero and returns a boolean value indicating
      * whether it is empty or not.
      * @returns A boolean value indicating whether the length of the object is equal to 0.
@@ -374,6 +431,9 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         return this._size === 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
      */
     clear() {
@@ -646,22 +706,6 @@ class SinglyLinkedList extends base_1.IterableElementBase {
             current = current.next;
         }
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
-     * array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a `SinglyLinkedList` object.
-     */
-    static fromArray(data) {
-        const singlyLinkedList = new SinglyLinkedList();
-        for (const item of data) {
-            singlyLinkedList.push(item);
-        }
-        return singlyLinkedList;
-    }
     /**
      * The _isPredicate function in TypeScript checks if the input is a function that takes a
      * SinglyLinkedListNode as an argument and returns a boolean.

package/dist/data-structures/queue/deque.d.ts

@@ -115,6 +115,16 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      * @returns The element that was removed from the data structure is being returned.
      */
     pop(): E | undefined;
+    /**
+     * 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(): E | undefined;
     /**
      * Time Complexity: Amortized O(1)
      * Space Complexity: O(n)
@@ -127,15 +137,34 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      */
     unshift(element: E): boolean;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
      *
-     * 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(): E | undefined;
+     * The function `pushMany` iterates over elements and pushes them into an array after applying a
+     * transformation function if provided.
+     * @param {IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>} elements - The `elements`
+     * parameter in the `pushMany` function is expected to be an iterable containing elements of type `E`
+     * or `R`. It can be either an `IterableWithSizeOrLength<E>` or an `IterableWithSizeOrLength<R>`. The
+     * function iterates over each element
+     * @returns The `pushMany` function is returning an array of boolean values, where each value
+     * represents the result of calling the `push` method on the current object instance with the
+     * corresponding element from the input `elements` iterable.
+     */
+    pushMany(elements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>): boolean[];
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The `unshiftMany` function in TypeScript iterates over elements and adds them to the beginning of
+     * an array, optionally converting them using a provided function.
+     * @param {IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>} elements - The `elements`
+     * parameter in the `unshiftMany` function is an iterable containing elements of type `E` or `R`. It
+     * can be an array or any other iterable data structure that has a known size or length. The function
+     * iterates over each element in the `elements` iterable and
+     * @returns The `unshiftMany` function returns an array of boolean values indicating whether each
+     * element was successfully added to the beginning of the array.
+     */
+    unshiftMany(elements?: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>): boolean[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/queue/deque.js

@@ -60,14 +60,7 @@ class Deque extends base_1.IterableElementBase {
         const needBucketNum = (0, utils_1.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 el of elements) {
-            if (this.toElementFn) {
-                this.push(this.toElementFn(el));
-            }
-            else {
-                this.push(el);
-            }
-        }
+        this.pushMany(elements);
     }
     /**
      * The bucketSize function returns the size of the bucket.
@@ -214,6 +207,35 @@ class Deque extends base_1.IterableElementBase {
         this._size -= 1;
         return element;
     }
+    /**
+     * 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: Amortized O(1)
      * Space Complexity: O(n)
@@ -247,33 +269,55 @@ class Deque extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
      *
-     * 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;
+     * The function `pushMany` iterates over elements and pushes them into an array after applying a
+     * transformation function if provided.
+     * @param {IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>} elements - The `elements`
+     * parameter in the `pushMany` function is expected to be an iterable containing elements of type `E`
+     * or `R`. It can be either an `IterableWithSizeOrLength<E>` or an `IterableWithSizeOrLength<R>`. The
+     * function iterates over each element
+     * @returns The `pushMany` function is returning an array of boolean values, where each value
+     * represents the result of calling the `push` method on the current object instance with the
+     * corresponding element from the input `elements` iterable.
+     */
+    pushMany(elements) {
+        const ans = [];
+        for (const el of elements) {
+            if (this.toElementFn) {
+                ans.push(this.push(this.toElementFn(el)));
             }
-            else if (this._bucketFirst < this._bucketCount - 1) {
-                this._bucketFirst += 1;
-                this._firstInBucket = 0;
+            else {
+                ans.push(this.push(el));
+            }
+        }
+        return ans;
+    }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The `unshiftMany` function in TypeScript iterates over elements and adds them to the beginning of
+     * an array, optionally converting them using a provided function.
+     * @param {IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>} elements - The `elements`
+     * parameter in the `unshiftMany` function is an iterable containing elements of type `E` or `R`. It
+     * can be an array or any other iterable data structure that has a known size or length. The function
+     * iterates over each element in the `elements` iterable and
+     * @returns The `unshiftMany` function returns an array of boolean values indicating whether each
+     * element was successfully added to the beginning of the array.
+     */
+    unshiftMany(elements = []) {
+        const ans = [];
+        for (const el of elements) {
+            if (this.toElementFn) {
+                ans.push(this.unshift(this.toElementFn(el)));
             }
             else {
-                this._bucketFirst = 0;
-                this._firstInBucket = 0;
+                ans.push(this.unshift(el));
             }
         }
-        this._size -= 1;
-        return element;
+        return ans;
     }
     /**
      * Time Complexity: O(1)