red-black-tree-typed 1.53.7 → 1.54.1

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)
@@ -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)

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)

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

@@ -84,6 +84,18 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * @returns Always returns true, indicating the element was successfully added.
      */
     push(element: E): boolean;
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The `pushMany` function iterates over elements and pushes them into an array after applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `pushMany` function
+     * is an iterable containing elements of type `E` or `R`.
+     * @returns The `pushMany` function is returning an array of boolean values indicating whether each
+     * element was successfully pushed into the data structure.
+     */
+    pushMany(elements: Iterable<E> | Iterable<R>): boolean[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -94,12 +106,18 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      */
     shift(): E | undefined;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The delete function removes an element from the list.
      * @param {E} element - Specify the element to be deleted
      * @return A boolean value indicating whether the element was successfully deleted or not
      */
     delete(element: E): boolean;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The deleteAt function deletes the element at a given index.
      * @param {number} index - Determine the index of the element to be deleted
      * @return A boolean value
@@ -109,7 +127,12 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * @param index
+     * The `at` function returns the element at a specified index adjusted by an offset, or `undefined`
+     * if the index is out of bounds.
+     * @param {number} index - The `index` parameter represents the position of the element you want to
+     * retrieve from the data structure.
+     * @returns The `at` method is returning the element at the specified index adjusted by the offset
+     * `_offset`.
      */
     at(index: number): E | undefined;
     /**
@@ -136,6 +159,9 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      */
     clear(): void;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The `compact` function in TypeScript slices the elements array based on the offset and resets the
      * offset to zero.
      * @returns The `compact()` method is returning a boolean value of `true`.
@@ -169,6 +195,20 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new Queue by applying a callback function to each
+     * element in the original Queue.
+     * @param callback - The `callback` parameter is a function that will be applied to each element in
+     * the queue. It takes the current element, its index, and the queue itself as arguments, and returns
+     * a new element.
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be provided to
+     * convert a raw element of type `RM` to a new element of type `EM`. This function is used within the
+     * `map` method to transform each raw element before passing it to the `callback` function. If
+     * @param {any} [thisArg] - The `thisArg` parameter in the `map` function is used to specify the
+     * value of `this` when executing the `callback` function. It allows you to set the context (the
+     * value of `this`) within the callback function. If `thisArg` is provided, it will be
+     * @returns A new Queue object containing elements of type EM, which are the result of applying the
+     * callback function to each element in the original Queue object.
      */
     map<EM, RM>(callback: ElementCallback<E, R, EM, Queue<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Queue<EM, RM>;
     /**

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

@@ -22,14 +22,7 @@ class Queue extends base_1.IterableElementBase {
             const { autoCompactRatio = 0.5 } = options;
             this._autoCompactRatio = autoCompactRatio;
         }
-        if (elements) {
-            for (const el of elements) {
-                if (this.toElementFn)
-                    this.push(this.toElementFn(el));
-                else
-                    this.push(el);
-            }
-        }
+        this.pushMany(elements);
     }
     /**
      * The elements function returns the elements of this set.
@@ -114,6 +107,27 @@ class Queue extends base_1.IterableElementBase {
         this.elements.push(element);
         return true;
     }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The `pushMany` function iterates over elements and pushes them into an array after applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `pushMany` function
+     * is an iterable containing elements of type `E` or `R`.
+     * @returns The `pushMany` function is returning 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)));
+            else
+                ans.push(this.push(el));
+        }
+        return ans;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -132,6 +146,9 @@ class Queue extends base_1.IterableElementBase {
         return first;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The delete function removes an element from the list.
      * @param {E} element - Specify the element to be deleted
      * @return A boolean value indicating whether the element was successfully deleted or not
@@ -141,6 +158,9 @@ class Queue extends base_1.IterableElementBase {
         return this.deleteAt(index);
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The deleteAt function deletes the element at a given index.
      * @param {number} index - Determine the index of the element to be deleted
      * @return A boolean value
@@ -153,7 +173,12 @@ class Queue extends base_1.IterableElementBase {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * @param index
+     * The `at` function returns the element at a specified index adjusted by an offset, or `undefined`
+     * if the index is out of bounds.
+     * @param {number} index - The `index` parameter represents the position of the element you want to
+     * retrieve from the data structure.
+     * @returns The `at` method is returning the element at the specified index adjusted by the offset
+     * `_offset`.
      */
     at(index) {
         return this.elements[index + this._offset];
@@ -189,6 +214,9 @@ class Queue extends base_1.IterableElementBase {
         this._offset = 0;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The `compact` function in TypeScript slices the elements array based on the offset and resets the
      * offset to zero.
      * @returns The `compact()` method is returning a boolean value of `true`.
@@ -238,6 +266,20 @@ class Queue extends base_1.IterableElementBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new Queue by applying a callback function to each
+     * element in the original Queue.
+     * @param callback - The `callback` parameter is a function that will be applied to each element in
+     * the queue. It takes the current element, its index, and the queue itself as arguments, and returns
+     * a new element.
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be provided to
+     * convert a raw element of type `RM` to a new element of type `EM`. This function is used within the
+     * `map` method to transform each raw element before passing it to the `callback` function. If
+     * @param {any} [thisArg] - The `thisArg` parameter in the `map` function is used to specify the
+     * value of `this` when executing the `callback` function. It allows you to set the context (the
+     * value of `this`) within the callback function. If `thisArg` is provided, it will be
+     * @returns A new Queue object containing elements of type EM, which are the result of applying the
+     * callback function to each element in the original Queue object.
      */
     map(callback, toElementFn, thisArg) {
         const newDeque = new Queue([], { toElementFn });