red-black-tree-typed 1.53.6 → 1.54.1

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

@@ -64,13 +64,13 @@ class DoublyLinkedListNode {
 }
 exports.DoublyLinkedListNode = DoublyLinkedListNode;
 /**
- * 1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
+ *1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
  * 2. Bidirectional Traversal: Unlike singly linked lists, doubly linked lists can be easily traversed forwards or backwards. This makes insertions and deletions in the list more flexible and efficient.
  * 3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
  * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
  * @example
  * // text editor operation history
- * const actions = [
+ *     const actions = [
  *       { type: 'insert', content: 'first line of text' },
  *       { type: 'insert', content: 'second line of text' },
  *       { type: 'delete', content: 'delete the first line' }
@@ -82,7 +82,7 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *     console.log(editorHistory.last?.type); // 'insert'
  * @example
  * // Browser history
- * const browserHistory = new DoublyLinkedList<string>();
+ *     const browserHistory = new DoublyLinkedList<string>();
  *
  *     browserHistory.push('home page');
  *     browserHistory.push('search page');
@@ -93,7 +93,7 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *     console.log(browserHistory.last); // 'search page'
  * @example
  * // Use DoublyLinkedList to implement music player
- * // Define the Song interface
+ *     // Define the Song interface
  *     interface Song {
  *       title: string;
  *       artist: string;
@@ -218,7 +218,7 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *  //    ]
  * @example
  * // Use DoublyLinkedList to implement LRU cache
- * interface CacheEntry<K, V> {
+ *     interface CacheEntry<K, V> {
  *       key: K;
  *       value: V;
  *     }
@@ -380,7 +380,7 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *     console.log(cache.isEmpty); // true
  * @example
  * // finding lyrics by timestamp in Coldplay's "Fix You"
- * // Create a DoublyLinkedList to store song lyrics with timestamps
+ *     // Create a DoublyLinkedList to store song lyrics with timestamps
  *     const lyricsList = new DoublyLinkedList<{ time: number; text: string }>();
  *
  *     // Detailed lyrics with precise timestamps (in milliseconds)
@@ -420,7 +420,7 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *     console.log(lateTimeLyric?.text); // 'And I will try to fix you'
  * @example
  * // cpu process schedules
- * class Process {
+ *     class Process {
  *       constructor(
  *         public id: number,
  *         public priority: number
@@ -496,20 +496,22 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *     console.log(scheduler.listProcesses()); // []
  */
 class DoublyLinkedList extends base_1.IterableElementBase {
+    /**
+     * This TypeScript constructor initializes a DoublyLinkedList with optional elements and options.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the constructor is an
+     * iterable collection of elements of type `E` or `R`. It is used to initialize the DoublyLinkedList
+     * with the elements provided in the iterable. If no elements are provided, the default value is an
+     * empty iterable.
+     * @param [options] - The `options` parameter in the constructor is of type
+     * `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 = [], options) {
         super(options);
         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.
@@ -555,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)
@@ -663,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)
@@ -784,7 +847,9 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * node was not found.
      */
     addBefore(existingElementOrNode, newElementOrNode) {
-        const existingNode = this.getNode(existingElementOrNode);
+        const existingNode = this.isNode(existingElementOrNode)
+            ? existingElementOrNode
+            : this.getNode(existingElementOrNode);
         if (existingNode) {
             const newNode = this._ensureNode(newElementOrNode);
             newNode.prev = existingNode.prev;
@@ -818,7 +883,9 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * was not found in the linked list.
      */
     addAfter(existingElementOrNode, newElementOrNode) {
-        const existingNode = this.getNode(existingElementOrNode);
+        const existingNode = this.isNode(existingElementOrNode)
+            ? existingElementOrNode
+            : this.getNode(existingElementOrNode);
         if (existingNode) {
             const newNode = this._ensureNode(newElementOrNode);
             newNode.next = existingNode.next;
@@ -956,7 +1023,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * @returns The `get` method returns the value of the first node in the doubly linked list that
      * satisfies the provided predicate function. If no such node is found, it returns `undefined`.
      */
-    get(elementNodeOrPredicate) {
+    search(elementNodeOrPredicate) {
         const predicate = this._ensurePredicate(elementNodeOrPredicate);
         let current = this.head;
         while (current) {
@@ -1110,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);
@@ -1123,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

@@ -40,8 +40,11 @@ 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 +75,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 +124,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)
@@ -123,7 +163,7 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The `get` method returns the value of the first node in the singly linked list that
      * satisfies the provided predicate function. If no such node is found, it returns `undefined`.
      */
-    get(elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)): E | undefined;
+    search(elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)): E | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -199,12 +239,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 +397,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

@@ -45,20 +45,14 @@ class SinglyLinkedListNode {
     }
 }
 exports.SinglyLinkedListNode = SinglyLinkedListNode;
+/**
+ *
+ */
 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 +93,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 +198,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)
@@ -200,7 +257,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * @returns The `get` method returns the value of the first node in the singly linked list that
      * satisfies the provided predicate function. If no such node is found, it returns `undefined`.
      */
-    get(elementNodeOrPredicate) {
+    search(elementNodeOrPredicate) {
         const predicate = this._ensurePredicate(elementNodeOrPredicate);
         let current = this.head;
         while (current) {
@@ -366,6 +423,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 +434,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 +709,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/linked-list/skip-linked-list.d.ts

@@ -12,6 +12,9 @@ export declare class SkipListNode<K, V> {
     forward: SkipListNode<K, V>[];
     constructor(key: K, value: V, level: number);
 }
+/**
+ *
+ */
 export declare class SkipList<K, V> {
     /**
      * The constructor function initializes a SkipLinkedList object with optional options and elements.

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

@@ -9,6 +9,9 @@ class SkipListNode {
     }
 }
 exports.SkipListNode = SkipListNode;
+/**
+ *
+ */
 class SkipList {
     /**
      * The constructor function initializes a SkipLinkedList object with optional options and elements.

package/dist/data-structures/matrix/matrix.d.ts

@@ -6,6 +6,9 @@
  * @license MIT License
  */
 import type { MatrixOptions } from '../../types';
+/**
+ *
+ */
 export declare class Matrix {
     /**
      * The constructor function initializes a matrix object with the provided data and options, or with

package/dist/data-structures/matrix/matrix.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Matrix = void 0;
+/**
+ *
+ */
 class Matrix {
     /**
      * The constructor function initializes a matrix object with the provided data and options, or with

package/dist/data-structures/matrix/navigator.d.ts

@@ -19,6 +19,9 @@ export declare class Character {
      */
     constructor(direction: Direction, turning: Turning);
 }
+/**
+ *
+ */
 export declare class Navigator<T = number> {
     onMove: (cur: [number, number]) => void;
     protected readonly _matrix: T[][];

package/dist/data-structures/matrix/navigator.js

@@ -16,6 +16,9 @@ class Character {
     }
 }
 exports.Character = Character;
+/**
+ *
+ */
 class Navigator {
     /**
      * The constructor initializes the Navigator object with the given parameters and sets the current position as visited

package/dist/data-structures/priority-queue/max-priority-queue.d.ts

@@ -7,6 +7,9 @@
  */
 import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
+/**
+ *
+ */
 export declare class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
     /**
      * The constructor initializes a PriorityQueue with optional elements and options, including a

package/dist/data-structures/priority-queue/max-priority-queue.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxPriorityQueue = void 0;
 const priority_queue_1 = require("./priority-queue");
+/**
+ *
+ */
 class MaxPriorityQueue extends priority_queue_1.PriorityQueue {
     /**
      * The constructor initializes a PriorityQueue with optional elements and options, including a

package/dist/data-structures/priority-queue/min-priority-queue.d.ts

@@ -7,6 +7,9 @@
  */
 import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
+/**
+ *
+ */
 export declare class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
     /**
      * The constructor initializes a PriorityQueue with optional elements and options, including a

package/dist/data-structures/priority-queue/min-priority-queue.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinPriorityQueue = void 0;
 const priority_queue_1 = require("./priority-queue");
+/**
+ *
+ */
 class MinPriorityQueue extends priority_queue_1.PriorityQueue {
     /**
      * The constructor initializes a PriorityQueue with optional elements and options, including a

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)