bst-typed 1.53.6 → 1.53.8

package/dist/data-structures/binary-tree/tree-multi-map.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeMultiMap = exports.TreeMultiMapNode = void 0;
-const rb_tree_1 = require("./rb-tree");
-class TreeMultiMapNode extends rb_tree_1.RedBlackTreeNode {
+const red_black_tree_1 = require("./red-black-tree");
+class TreeMultiMapNode extends red_black_tree_1.RedBlackTreeNode {
     /**
      * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
      * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
@@ -37,7 +37,7 @@ class TreeMultiMapNode extends rb_tree_1.RedBlackTreeNode {
     }
 }
 exports.TreeMultiMapNode = TreeMultiMapNode;
-class TreeMultiMap extends rb_tree_1.RedBlackTree {
+class TreeMultiMap extends red_black_tree_1.RedBlackTree {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
      * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
@@ -99,7 +99,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * existing `iterationType` property. The returned value is casted as `TREE`.
      */
     createTree(options) {
-        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
+        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn }, options));
     }
     /**
      * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
@@ -113,7 +113,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
      * @returns either a NODE object or undefined.
      */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
         if (keyNodeEntryOrRaw === undefined || keyNodeEntryOrRaw === null)
             return [undefined, undefined];
         if (this.isNode(keyNodeEntryOrRaw))
@@ -126,7 +126,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
             if (this.isKey(key))
                 return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
         }
-        if (this._toEntryFn) {
+        if (this.isRaw(keyNodeEntryOrRaw)) {
             const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
             const finalValue = value !== null && value !== void 0 ? value : entryValue;
             if (this.isKey(key))
@@ -163,7 +163,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * was successful, and false otherwise.
      */
     add(keyNodeEntryOrRaw, value, count = 1) {
-        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
+        const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
         const orgCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
         const isSuccessAdded = super.add(newNode, newValue);
         if (isSuccessAdded) {

package/dist/data-structures/hash/hash-map.d.ts

@@ -62,6 +62,9 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     get hashFn(): (key: K) => string;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given element is an array with exactly two elements.
      * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
      * data type.
@@ -69,16 +72,25 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     isEntry(rawElement: any): rawElement is [K, V];
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the size of an object is equal to zero and returns a boolean value.
      * @returns A boolean value indicating whether the size of the object is 0 or not.
      */
     isEmpty(): boolean;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function resets the state of an object by clearing its internal store, object map, and
      * size.
      */
     clear(): void;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
      * the key is not already present.
      * @param {K} key - The key parameter is the key used to identify the value in the data structure. It
@@ -89,6 +101,9 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     set(key: K, value: V): boolean;
     /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
      * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
      * pair using a mapping function, and sets each key-value pair in the current object.
      * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
@@ -97,6 +112,9 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     setMany(entryOrRawElements: Iterable<R | [K, V]>): boolean[];
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
      * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
@@ -106,6 +124,9 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     get(key: K): V | undefined;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `has` function checks if a given key exists in the `_objMap` or `_store` based on whether it
      * is an object key or not.
      * @param {K} key - The parameter "key" is of type K, which means it can be any type.
@@ -113,6 +134,9 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     has(key: K): boolean;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `delete` function removes an element from a map-like data structure based on the provided key.
      * @param {K} key - The `key` parameter is the key of the element that you want to delete from the
      * data structure.
@@ -292,6 +316,9 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     set(key: K, value?: V): boolean;
     /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
      * The function `setMany` takes an iterable collection, converts each element into a key-value pair
      * using a provided function, and sets each key-value pair in the current object, returning an array
      * of booleans indicating the success of each set operation.
@@ -301,6 +328,9 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     setMany(entryOrRawElements: Iterable<R | [K, V]>): boolean[];
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given key exists in a map, using different logic depending on whether the
      * key is a weak key or not.
      * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.

package/dist/data-structures/hash/hash-map.js

@@ -75,6 +75,9 @@ class HashMap extends base_1.IterableEntryBase {
         return this._hashFn;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given element is an array with exactly two elements.
      * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
      * data type.
@@ -84,6 +87,9 @@ class HashMap extends base_1.IterableEntryBase {
         return Array.isArray(rawElement) && rawElement.length === 2;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the size of an object is equal to zero and returns a boolean value.
      * @returns A boolean value indicating whether the size of the object is 0 or not.
      */
@@ -91,6 +97,9 @@ class HashMap extends base_1.IterableEntryBase {
         return this._size === 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function resets the state of an object by clearing its internal store, object map, and
      * size.
      */
@@ -100,6 +109,9 @@ class HashMap extends base_1.IterableEntryBase {
         this._size = 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
      * the key is not already present.
      * @param {K} key - The key parameter is the key used to identify the value in the data structure. It
@@ -125,6 +137,9 @@ class HashMap extends base_1.IterableEntryBase {
         return true;
     }
     /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
      * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
      * pair using a mapping function, and sets each key-value pair in the current object.
      * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
@@ -150,6 +165,9 @@ class HashMap extends base_1.IterableEntryBase {
         return results;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
      * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
@@ -168,6 +186,9 @@ class HashMap extends base_1.IterableEntryBase {
         }
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `has` function checks if a given key exists in the `_objMap` or `_store` based on whether it
      * is an object key or not.
      * @param {K} key - The parameter "key" is of type K, which means it can be any type.
@@ -183,6 +204,9 @@ class HashMap extends base_1.IterableEntryBase {
         }
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `delete` function removes an element from a map-like data structure based on the provided key.
      * @param {K} key - The `key` parameter is the key of the element that you want to delete from the
      * data structure.
@@ -523,6 +547,9 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         return true;
     }
     /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
      * The function `setMany` takes an iterable collection, converts each element into a key-value pair
      * using a provided function, and sets each key-value pair in the current object, returning an array
      * of booleans indicating the success of each set operation.
@@ -549,6 +576,9 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         return results;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given key exists in a map, using different logic depending on whether the
      * key is a weak key or not.
      * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.

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

@@ -19,7 +19,7 @@ import { IterableElementBase } from '../base';
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prime's minimum-spanning tree algorithm, which use heaps to improve performance.
  * @example
  * // Use Heap to sort an array
- * function heapSort(arr: number[]): number[] {
+ *     function heapSort(arr: number[]): number[] {
  *       const heap = new Heap<number>(arr, { comparator: (a, b) => a - b });
  *       const sorted: number[] = [];
  *       while (!heap.isEmpty()) {
@@ -32,7 +32,7 @@ import { IterableElementBase } from '../base';
  *     console.log(heapSort(array)); // [1, 2, 3, 4, 5, 8]
  * @example
  * // Use Heap to solve top k problems
- * function topKElements(arr: number[], k: number): number[] {
+ *     function topKElements(arr: number[], k: number): number[] {
  *       const heap = new Heap<number>([], { comparator: (a, b) => b - a }); // Max heap
  *       arr.forEach(num => {
  *         heap.add(num);
@@ -45,7 +45,7 @@ import { IterableElementBase } from '../base';
  *     console.log(topKElements(numbers, 3)); // [15, 10, 5]
  * @example
  * // Use Heap to merge sorted sequences
- * function mergeSortedSequences(sequences: number[][]): number[] {
+ *     function mergeSortedSequences(sequences: number[][]): number[] {
  *       const heap = new Heap<{ value: number; seqIndex: number; itemIndex: number }>([], {
  *         comparator: (a, b) => a.value - b.value // Min heap
  *       });
@@ -82,7 +82,7 @@ import { IterableElementBase } from '../base';
  *     console.log(mergeSortedSequences(sequences)); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
  * @example
  * // Use Heap to dynamically maintain the median
- * class MedianFinder {
+ *     class MedianFinder {
  *       private low: MaxHeap<number>; // Max heap, stores the smaller half
  *       private high: MinHeap<number>; // Min heap, stores the larger half
  *
@@ -119,7 +119,7 @@ import { IterableElementBase } from '../base';
  *     console.log(medianFinder.findMedian()); // 30
  * @example
  * // Use Heap for load balancing
- * function loadBalance(requests: number[], servers: number): number[] {
+ *     function loadBalance(requests: number[], servers: number): number[] {
  *       const serverHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // min heap
  *       const serverLoads = new Array(servers).fill(0);
  *
@@ -141,7 +141,7 @@ import { IterableElementBase } from '../base';
  *     console.log(loadBalance(requests, 3)); // [12, 8, 5]
  * @example
  * // Use Heap to schedule tasks
- * type Task = [string, number];
+ *     type Task = [string, number];
  *
  *     function scheduleTasks(tasks: Task[], machines: number): Map<number, Task[]> {
  *       const machineHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // Min heap
@@ -224,10 +224,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, He
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Insert an element into the heap and maintain the heap properties.
-     * @param element - The element to be inserted.
+     * The add function pushes an element into an array and then triggers a bubble-up operation.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the
+     * data structure.
+     * @returns The `add` method is returning a boolean value, which is the result of calling the
+     * `_bubbleUp` method with the index `this.elements.length - 1` as an argument.
      */
     add(element: E): boolean;
+    /**
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     *
+     * The `addMany` function iterates over elements and adds them to a collection, returning an array of
+     * boolean values indicating success or failure.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `addMany` method is
+     * an iterable containing elements of type `E` or `R`. The method iterates over each element in the
+     * iterable and adds them to the data structure. If a transformation function `_toElementFn` is
+     * provided, it transforms the element
+     * @returns The `addMany` method returns an array of boolean values indicating whether each element
+     * in the input iterable was successfully added to the data structure.
+     */
+    addMany(elements: Iterable<E> | Iterable<R>): boolean[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -340,7 +357,7 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, He
      */
     filter(callback: ElementCallback<E, R, boolean, Heap<E, R>>, thisArg?: any): Heap<E, R>;
     /**
-     * Time Complexity: O(n log n)
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * The `map` function creates a new heap by applying a callback function to each element of the

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

@@ -21,7 +21,7 @@ const base_1 = require("../base");
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prime's minimum-spanning tree algorithm, which use heaps to improve performance.
  * @example
  * // Use Heap to sort an array
- * function heapSort(arr: number[]): number[] {
+ *     function heapSort(arr: number[]): number[] {
  *       const heap = new Heap<number>(arr, { comparator: (a, b) => a - b });
  *       const sorted: number[] = [];
  *       while (!heap.isEmpty()) {
@@ -34,7 +34,7 @@ const base_1 = require("../base");
  *     console.log(heapSort(array)); // [1, 2, 3, 4, 5, 8]
  * @example
  * // Use Heap to solve top k problems
- * function topKElements(arr: number[], k: number): number[] {
+ *     function topKElements(arr: number[], k: number): number[] {
  *       const heap = new Heap<number>([], { comparator: (a, b) => b - a }); // Max heap
  *       arr.forEach(num => {
  *         heap.add(num);
@@ -47,7 +47,7 @@ const base_1 = require("../base");
  *     console.log(topKElements(numbers, 3)); // [15, 10, 5]
  * @example
  * // Use Heap to merge sorted sequences
- * function mergeSortedSequences(sequences: number[][]): number[] {
+ *     function mergeSortedSequences(sequences: number[][]): number[] {
  *       const heap = new Heap<{ value: number; seqIndex: number; itemIndex: number }>([], {
  *         comparator: (a, b) => a.value - b.value // Min heap
  *       });
@@ -84,7 +84,7 @@ const base_1 = require("../base");
  *     console.log(mergeSortedSequences(sequences)); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
  * @example
  * // Use Heap to dynamically maintain the median
- * class MedianFinder {
+ *     class MedianFinder {
  *       private low: MaxHeap<number>; // Max heap, stores the smaller half
  *       private high: MinHeap<number>; // Min heap, stores the larger half
  *
@@ -121,7 +121,7 @@ const base_1 = require("../base");
  *     console.log(medianFinder.findMedian()); // 30
  * @example
  * // Use Heap for load balancing
- * function loadBalance(requests: number[], servers: number): number[] {
+ *     function loadBalance(requests: number[], servers: number): number[] {
  *       const serverHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // min heap
  *       const serverLoads = new Array(servers).fill(0);
  *
@@ -143,7 +143,7 @@ const base_1 = require("../base");
  *     console.log(loadBalance(requests, 3)); // [12, 8, 5]
  * @example
  * // Use Heap to schedule tasks
- * type Task = [string, number];
+ *     type Task = [string, number];
  *
  *     function scheduleTasks(tasks: Task[], machines: number): Map<number, Task[]> {
  *       const machineHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // Min heap
@@ -218,14 +218,7 @@ class Heap extends base_1.IterableElementBase {
             if (comparator)
                 this._comparator = comparator;
         }
-        if (elements) {
-            for (const el of elements) {
-                if (this.toElementFn)
-                    this.add(this.toElementFn(el));
-                else
-                    this.add(el);
-            }
-        }
+        this.addMany(elements);
     }
     /**
      * The function returns an array of elements.
@@ -261,13 +254,40 @@ class Heap extends base_1.IterableElementBase {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Insert an element into the heap and maintain the heap properties.
-     * @param element - The element to be inserted.
+     * The add function pushes an element into an array and then triggers a bubble-up operation.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the
+     * data structure.
+     * @returns The `add` method is returning a boolean value, which is the result of calling the
+     * `_bubbleUp` method with the index `this.elements.length - 1` as an argument.
      */
     add(element) {
         this._elements.push(element);
         return this._bubbleUp(this.elements.length - 1);
     }
+    /**
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     *
+     * The `addMany` function iterates over elements and adds them to a collection, returning an array of
+     * boolean values indicating success or failure.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `addMany` method is
+     * an iterable containing elements of type `E` or `R`. The method iterates over each element in the
+     * iterable and adds them to the data structure. If a transformation function `_toElementFn` is
+     * provided, it transforms the element
+     * @returns The `addMany` method returns an array of boolean values indicating whether each element
+     * in the input iterable was successfully added to the data structure.
+     */
+    addMany(elements) {
+        const ans = [];
+        for (const el of elements) {
+            if (this._toElementFn) {
+                ans.push(this.add(this._toElementFn(el)));
+                continue;
+            }
+            ans.push(this.add(el));
+        }
+        return ans;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -470,7 +490,7 @@ class Heap extends base_1.IterableElementBase {
         return filteredList;
     }
     /**
-     * Time Complexity: O(n log n)
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * The `map` function creates a new heap by applying a callback function to each element of the

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

@@ -55,13 +55,13 @@ export declare class DoublyLinkedListNode<E = any> {
     set prev(value: DoublyLinkedListNode<E> | undefined);
 }
 /**
- * 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' }
@@ -73,7 +73,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *     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');
@@ -84,7 +84,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *     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;
@@ -209,7 +209,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *  //    ]
  * @example
  * // Use DoublyLinkedList to implement LRU cache
- * interface CacheEntry<K, V> {
+ *     interface CacheEntry<K, V> {
  *       key: K;
  *       value: V;
  *     }
@@ -371,7 +371,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *     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)
@@ -411,7 +411,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *     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
@@ -487,7 +487,17 @@ export declare class DoublyLinkedListNode<E = any> {
  *     console.log(scheduler.listProcesses()); // []
  */
 export declare class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R, DoublyLinkedList<E, R>> {
-    constructor(elements?: Iterable<E> | Iterable<R>, options?: DoublyLinkedListOptions<E, R>);
+    /**
+     * 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?: 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.
@@ -575,6 +585,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)
@@ -729,7 +768,7 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * @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: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): E | undefined;
+    search(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): E | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -820,6 +859,12 @@ 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;
     /**