heap-typed 1.53.5 → 1.53.7

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,6 +487,16 @@ 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>> {
+    /**
+     * 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>, options?: DoublyLinkedListOptions<E, R>);
     protected _head: DoublyLinkedListNode<E> | undefined;
     /**
@@ -709,22 +719,18 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The indexOf function in TypeScript returns the index of a specified element or node in a Doubly
-     * Linked List.
-     * @param {E | DoublyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the
-     * `indexOf` method can be either an element of type `E` or a `DoublyLinkedListNode` containing an
-     * element of type `E`.
-     * @returns The `indexOf` method is returning the index of the element or node in the doubly linked
-     * list. If the element or node is found in the list, the method returns the index of that element or
-     * node. If the element or node is not found in the list, the method returns -1.
+     * This function finds the index of a specified element, node, or predicate in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `indexOf` method takes in a parameter `elementNodeOrPredicate`, which
+     * can be one of the following:
+     * @returns The `indexOf` method returns the index of the element in the doubly linked list that
+     * matches the provided element, node, or predicate. If no match is found, it returns -1.
      */
-    indexOf(elementOrNode: E | DoublyLinkedListNode<E>): number;
+    indexOf(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     */
-    /**
      * This function retrieves an element from a doubly linked list based on a given element
      * node or predicate.
      * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
@@ -733,7 +739,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 +826,12 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * @returns a new instance of the `DoublyLinkedList` class with elements of type `T` and `RR`.
      */
     map<EM, RM>(callback: ElementCallback<E, R, EM, DoublyLinkedList<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): DoublyLinkedList<EM, RM>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     */
+    countOccurrences(elementOrNode: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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,6 +496,16 @@ 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;
@@ -784,13 +794,9 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * node was not found.
      */
     addBefore(existingElementOrNode, newElementOrNode) {
-        let existingNode;
-        if (existingElementOrNode instanceof DoublyLinkedListNode) {
-            existingNode = existingElementOrNode;
-        }
-        else {
-            existingNode = this.getNode(existingElementOrNode);
-        }
+        const existingNode = this.isNode(existingElementOrNode)
+            ? existingElementOrNode
+            : this.getNode(existingElementOrNode);
         if (existingNode) {
             const newNode = this._ensureNode(newElementOrNode);
             newNode.prev = existingNode.prev;
@@ -824,13 +830,9 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * was not found in the linked list.
      */
     addAfter(existingElementOrNode, newElementOrNode) {
-        let existingNode;
-        if (existingElementOrNode instanceof DoublyLinkedListNode) {
-            existingNode = existingElementOrNode;
-        }
-        else {
-            existingNode = this.getNode(existingElementOrNode);
-        }
+        const existingNode = this.isNode(existingElementOrNode)
+            ? existingElementOrNode
+            : this.getNode(existingElementOrNode);
         if (existingNode) {
             const newNode = this._ensureNode(newElementOrNode);
             newNode.next = existingNode.next;
@@ -936,17 +938,15 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The indexOf function in TypeScript returns the index of a specified element or node in a Doubly
-     * Linked List.
-     * @param {E | DoublyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the
-     * `indexOf` method can be either an element of type `E` or a `DoublyLinkedListNode` containing an
-     * element of type `E`.
-     * @returns The `indexOf` method is returning the index of the element or node in the doubly linked
-     * list. If the element or node is found in the list, the method returns the index of that element or
-     * node. If the element or node is not found in the list, the method returns -1.
+     * This function finds the index of a specified element, node, or predicate in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `indexOf` method takes in a parameter `elementNodeOrPredicate`, which
+     * can be one of the following:
+     * @returns The `indexOf` method returns the index of the element in the doubly linked list that
+     * matches the provided element, node, or predicate. If no match is found, it returns -1.
      */
-    indexOf(elementOrNode) {
-        const predicate = this._ensurePredicate(elementOrNode);
+    indexOf(elementNodeOrPredicate) {
+        const predicate = this._ensurePredicate(elementNodeOrPredicate);
         let index = 0;
         let current = this.head;
         while (current) {
@@ -962,8 +962,6 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     */
-    /**
      * This function retrieves an element from a doubly linked list based on a given element
      * node or predicate.
      * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
@@ -972,7 +970,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) {
@@ -1122,6 +1120,23 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         }
         return mappedList;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     */
+    countOccurrences(elementOrNode) {
+        const predicate = this._ensurePredicate(elementOrNode);
+        let count = 0;
+        let current = this.head;
+        while (current) {
+            if (predicate(current)) {
+                count++;
+            }
+            current = current.next;
+        }
+        return count;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -72,26 +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)
      *
-     * The push function adds a new element to the end of a singly linked list.
-     * @param {E} element - The "element" parameter represents the value of the element that you want to
-     * add to the linked list.
-     * @returns The `push` method is returning a boolean value, `true`.
+     * The `push` function adds a new element or node to the end of a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the `push`
+     * method can accept either an element of type `E` or a `SinglyLinkedListNode<E>` object.
+     * @returns The `push` method is returning a boolean value, specifically `true`.
      */
-    push(element: E): boolean;
+    push(elementOrNode: E | SinglyLinkedListNode<E>): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -113,12 +103,27 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The unshift function adds a new element to the beginning of a singly linked list.
-     * @param {E} element - The "element" parameter represents the value of the element that you want to
-     * add to the beginning of the singly linked list.
-     * @returns The `unshift` method is returning a boolean value, `true`.
+     * The unshift function adds a new element or node to the beginning of a singly linked list in
+     * TypeScript.
+     * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the
+     * `unshift` method can be either an element of type `E` or a `SinglyLinkedListNode` containing an
+     * element of type `E`.
+     * @returns The `unshift` method is returning a boolean value, specifically `true`.
+     */
+    unshift(elementOrNode: E | SinglyLinkedListNode<E>): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * This function searches for a specific element in a singly linked list based on a given node or
+     * predicate.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `get` method can be one of
+     * the following types:
+     * @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`.
      */
-    unshift(element: E): boolean;
+    search(elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)): E | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -130,6 +135,20 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      * `undefined` if the index is out of bounds.
      */
     at(index: number): E | undefined;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `isNode` in TypeScript checks if the input is an instance of `SinglyLinkedListNode`.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `isNode` function can be
+     * one of the following types:
+     * @returns The `isNode` function is checking if the `elementNodeOrPredicate` parameter is an
+     * instance of `SinglyLinkedListNode<E>`. If it is, the function returns `true`, indicating that the
+     * parameter is a `SinglyLinkedListNode<E>`. If it is not an instance of `SinglyLinkedListNode<E>`,
+     * the function returns `false`.
+     */
+    isNode(elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)): elementNodeOrPredicate is SinglyLinkedListNode<E>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -157,25 +176,28 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      * Space Complexity: O(1)
      *
      * The delete function removes a node with a specific value from a singly linked list.
-     * @param {E | SinglyLinkedListNode<E>} valueOrNode - The `valueOrNode` parameter can accept either a value of type `E`
+     * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter can accept either a value of type `E`
      * or a `SinglyLinkedListNode<E>` object.
      * @returns The `delete` method returns a boolean value. It returns `true` if the value or node is found and
      * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
      */
-    delete(valueOrNode: E | SinglyLinkedListNode<E> | undefined): boolean;
+    delete(elementOrNode: E | SinglyLinkedListNode<E> | undefined): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `addAt` function inserts a value at a specified index in a singly linked list.
-     * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
-     * linked list. It is of type number.
-     * @param {E} value - The `value` parameter represents the value that you want to insert into the linked list at the
-     * specified index.
-     * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
-     * if the index is out of bounds.
-     */
-    addAt(index: number, value: E): boolean;
+     * The `addAt` function inserts a new element or node at a specified index in a singly linked list.
+     * @param {number} index - The `index` parameter represents the position at which you want to add a
+     * new element or node in the linked list. It is a number that indicates the index where the new
+     * element or node should be inserted.
+     * @param {E | SinglyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter in the
+     * `addAt` method can be either a value of type `E` or a `SinglyLinkedListNode<E>` object. This
+     * parameter represents the element or node that you want to add to the linked list at the specified
+     * index.
+     * @returns The `addAt` method returns a boolean value - `true` if the element or node was
+     * successfully added at the specified index, and `false` if the index is out of bounds.
+     */
+    addAt(index: number, newElementOrNode: E | SinglyLinkedListNode<E>): boolean;
     /**
      * 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.
@@ -206,56 +228,76 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `indexOf` function returns the index of the first occurrence of a given value in a linked list.
-     * @param {E} value - The value parameter is the value that you want to find the index of in the linked list.
-     * @returns The method is returning the index of the first occurrence of the specified value in the linked list. If the
-     * value is not found, it returns -1.
+     * The `indexOf` function in TypeScript searches for a specific element or node in a singly linked
+     * list and returns its index if found.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `indexOf` method can be one
+     * of the following types:
+     * @returns The `indexOf` method returns the index of the first occurrence of the element that
+     * matches the provided predicate in the singly linked list. If no matching element is found, it
+     * returns -1.
      */
-    indexOf(value: E): number;
+    indexOf(elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function finds a node in a singly linked list by its value and returns the node if found, otherwise returns
-     * undefined.
-     * @param {E} value - The value parameter is the value that we want to search for in the linked list.
-     * @returns a `SinglyLinkedListNode<E>` if a node with the specified value is found in the linked list. If no node with
-     * the specified value is found, the function returns `undefined`.
+     * The function `getNode` in TypeScript searches for a node in a singly linked list based on a given
+     * element, node, or predicate.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean) | undefined} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `getNode` method can be one
+     * of the following types:
+     * @returns The `getNode` method returns either a `SinglyLinkedListNode<E>` if a matching node is
+     * found based on the provided predicate, or it returns `undefined` if no matching node is found or
+     * if the input parameter is `undefined`.
      */
-    getNode(value: E): SinglyLinkedListNode<E> | undefined;
+    getNode(elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean) | undefined): SinglyLinkedListNode<E> | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `addBefore` function inserts a new value before an existing value in a singly linked list.
-     * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
-     * new value before. It can be either the value itself or a node containing the value in the linked list.
-     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
-     * @returns The method `addBefore` returns a boolean value. It returns `true` if the new value was successfully
-     * inserted before the existing value, and `false` otherwise.
-     */
-    addBefore(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
+     * The function `addBefore` in TypeScript adds a new element or node before an existing element or
+     * node in a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} existingElementOrNode - existingElementOrNode represents the
+     * element or node in the linked list before which you want to add a new element or node.
+     * @param {E | SinglyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter in the
+     * `addBefore` method represents the element or node that you want to insert before the existing
+     * element or node in the linked list. This new element can be of type `E` or a
+     * `SinglyLinkedListNode<E>`.
+     * @returns The `addBefore` method returns a boolean value - `true` if the new element or node was
+     * successfully added before the existing element or node, and `false` if the operation was
+     * unsuccessful.
+     */
+    addBefore(existingElementOrNode: E | SinglyLinkedListNode<E>, newElementOrNode: E | SinglyLinkedListNode<E>): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `addAfter` function inserts a new node with a given value after an existing node in a singly linked list.
-     * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
-     * the new value will be inserted. It can be either the value of the existing node or the existing node itself.
-     * @param {E} newValue - The value that you want to insert into the linked list after the existing value or node.
-     * @returns The method returns a boolean value. It returns true if the new value was successfully inserted after the
-     * existing value or node, and false if the existing value or node was not found in the linked list.
-     */
-    addAfter(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
+     * The `addAfter` function in TypeScript adds a new element or node after an existing element or node
+     * in a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} existingElementOrNode - existingElementOrNode can be either
+     * an element of type E or a SinglyLinkedListNode of type E.
+     * @param {E | SinglyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter in the
+     * `addAfter` method represents the element or node that you want to add after the existing element
+     * or node in a singly linked list. This parameter can be either the value of the new element or a
+     * reference to a `SinglyLinkedListNode` containing
+     * @returns The `addAfter` method returns a boolean value - `true` if the new element or node was
+     * successfully added after the existing element or node, and `false` if the existing element or node
+     * was not found.
+     */
+    addAfter(existingElementOrNode: E | SinglyLinkedListNode<E>, newElementOrNode: E | SinglyLinkedListNode<E>): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function counts the number of occurrences of a given value in a linked list.
-     * @param {E} value - The value parameter is the value that you want to count the occurrences of in the linked list.
-     * @returns The count of occurrences of the given value in the linked list.
+     * The function `countOccurrences` iterates through a singly linked list and counts the occurrences
+     * of a specified element or nodes that satisfy a given predicate.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<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 singly linked list.
      */
-    countOccurrences(value: E): number;
+    countOccurrences(elementOrNode: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -309,4 +351,44 @@ 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.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter can be one of the following types:
+     * @returns The _isPredicate method is returning a boolean value based on whether the
+     * elementNodeOrPredicate parameter is a function or not. If the elementNodeOrPredicate is a
+     * function, the method will return true, indicating that it is a predicate function. If it is not a
+     * function, the method will return false.
+     */
+    protected _isPredicate(elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)): elementNodeOrPredicate is (node: SinglyLinkedListNode<E>) => boolean;
+    /**
+     * The function `_ensureNode` ensures that the input is a valid node and returns it, creating a new
+     * node if necessary.
+     * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter can be either
+     * an element of type `E` or a `SinglyLinkedListNode` containing an element of type `E`.
+     * @returns A SinglyLinkedListNode<E> object is being returned.
+     */
+    protected _ensureNode(elementOrNode: E | SinglyLinkedListNode<E>): SinglyLinkedListNode<E>;
+    /**
+     * The function `_ensurePredicate` in TypeScript ensures that the input is either a node, a predicate
+     * function, or a value to compare with the node's value.
+     * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter can be one of the following types:
+     * @returns A function is being returned. If the input `elementNodeOrPredicate` is already a node, a
+     * function is returned that checks if a given node is equal to the input node. If the input is a
+     * predicate function, it is returned as is. If the input is neither a node nor a predicate function,
+     * a function is returned that checks if a given node's value is equal to the input
+     */
+    protected _ensurePredicate(elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)): (node: SinglyLinkedListNode<E>) => boolean;
 }