data-structure-typed 1.53.4 → 1.53.6

package/dist/umd/data-structure-typed.js

@@ -1562,33 +1562,17 @@ var dataStructureTyped = (() => {
     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)
      *
-     * 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) {
-      const newNode = new SinglyLinkedListNode(element);
+    push(elementOrNode) {
+      const newNode = this._ensureNode(elementOrNode);
       if (!this.head) {
         this._head = newNode;
         this._tail = newNode;
@@ -1644,13 +1628,15 @@ var dataStructureTyped = (() => {
      * 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(element) {
-      const newNode = new SinglyLinkedListNode(element);
+    unshift(elementOrNode) {
+      const newNode = this._ensureNode(elementOrNode);
       if (!this.head) {
         this._head = newNode;
         this._tail = newNode;
@@ -1661,6 +1647,27 @@ var dataStructureTyped = (() => {
       this._size++;
       return true;
     }
+    /**
+     * 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`.
+     */
+    get(elementNodeOrPredicate) {
+      const predicate = this._ensurePredicate(elementNodeOrPredicate);
+      let current = this.head;
+      while (current) {
+        if (predicate(current)) return current.value;
+        current = current.next;
+      }
+      return void 0;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -1679,6 +1686,22 @@ var dataStructureTyped = (() => {
       }
       return current.value;
     }
+    /**
+     * 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) {
+      return elementNodeOrPredicate instanceof SinglyLinkedListNode;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -1727,18 +1750,18 @@ var dataStructureTyped = (() => {
      * 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) {
-      if (valueOrNode === void 0) return false;
+    delete(elementOrNode) {
+      if (elementOrNode === void 0) return false;
       let value;
-      if (valueOrNode instanceof SinglyLinkedListNode) {
-        value = valueOrNode.value;
+      if (elementOrNode instanceof SinglyLinkedListNode) {
+        value = elementOrNode.value;
       } else {
-        value = valueOrNode;
+        value = elementOrNode;
       }
       let current = this.head, prev = void 0;
       while (current) {
@@ -1766,25 +1789,28 @@ var dataStructureTyped = (() => {
      * 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.
+     * 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, value) {
+    addAt(index, newElementOrNode) {
       if (index < 0 || index > this._size) return false;
       if (index === 0) {
-        this.unshift(value);
+        this.unshift(newElementOrNode);
         return true;
       }
       if (index === this._size) {
-        this.push(value);
+        this.push(newElementOrNode);
         return true;
       }
-      const newNode = new SinglyLinkedListNode(value);
+      const newNode = this._ensureNode(newElementOrNode);
       const prevNode = this.getNodeAt(index - 1);
       newNode.next = prevNode.next;
       prevNode.next = newNode;
@@ -1848,16 +1874,21 @@ var dataStructureTyped = (() => {
      * 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) {
+    indexOf(elementNodeOrPredicate) {
+      const predicate = this._ensurePredicate(elementNodeOrPredicate);
       let index = 0;
       let current = this.head;
       while (current) {
-        if (current.value === value) {
+        if (predicate(current)) {
           return index;
         }
         index++;
@@ -1869,16 +1900,21 @@ var dataStructureTyped = (() => {
      * 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) {
+    getNode(elementNodeOrPredicate) {
+      if (elementNodeOrPredicate === void 0) return;
+      const predicate = this._ensurePredicate(elementNodeOrPredicate);
       let current = this.head;
       while (current) {
-        if (current.value === value) {
+        if (predicate(current)) {
           return current;
         }
         current = current.next;
@@ -1889,29 +1925,34 @@ var dataStructureTyped = (() => {
      * 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.
+     * 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(existingValueOrNode, newValue) {
+    addBefore(existingElementOrNode, newElementOrNode) {
       if (!this.head) return false;
       let existingValue;
-      if (existingValueOrNode instanceof SinglyLinkedListNode) {
-        existingValue = existingValueOrNode.value;
+      if (this.isNode(existingElementOrNode)) {
+        existingValue = existingElementOrNode.value;
       } else {
-        existingValue = existingValueOrNode;
+        existingValue = existingElementOrNode;
       }
       if (this.head.value === existingValue) {
-        this.unshift(newValue);
+        this.unshift(newElementOrNode);
         return true;
       }
       let current = this.head;
       while (current.next) {
         if (current.next.value === existingValue) {
-          const newNode = new SinglyLinkedListNode(newValue);
+          const newNode = this._ensureNode(newElementOrNode);
           newNode.next = current.next;
           current.next = newNode;
           this._size++;
@@ -1925,22 +1966,22 @@ var dataStructureTyped = (() => {
      * 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.
+     * 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(existingValueOrNode, newValue) {
-      let existingNode;
-      if (existingValueOrNode instanceof SinglyLinkedListNode) {
-        existingNode = existingValueOrNode;
-      } else {
-        existingNode = this.getNode(existingValueOrNode);
-      }
+    addAfter(existingElementOrNode, newElementOrNode) {
+      const existingNode = this.getNode(existingElementOrNode);
       if (existingNode) {
-        const newNode = new SinglyLinkedListNode(newValue);
+        const newNode = this._ensureNode(newElementOrNode);
         newNode.next = existingNode.next;
         existingNode.next = newNode;
         if (existingNode === this.tail) {
@@ -1955,15 +1996,19 @@ var dataStructureTyped = (() => {
      * 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) {
+    countOccurrences(elementOrNode) {
+      const predicate = this._ensurePredicate(elementOrNode);
       let count = 0;
       let current = this.head;
       while (current) {
-        if (current.value === value) {
+        if (predicate(current)) {
           count++;
         }
         current = current.next;
@@ -2049,6 +2094,61 @@ var dataStructureTyped = (() => {
         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.
+     * @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.
+     */
+    _isPredicate(elementNodeOrPredicate) {
+      return typeof elementNodeOrPredicate === "function";
+    }
+    /**
+     * 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.
+     */
+    _ensureNode(elementOrNode) {
+      if (this.isNode(elementOrNode)) return elementOrNode;
+      return new SinglyLinkedListNode(elementOrNode);
+    }
+    /**
+     * 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
+     */
+    _ensurePredicate(elementNodeOrPredicate) {
+      if (this.isNode(elementNodeOrPredicate)) return (node) => node === elementNodeOrPredicate;
+      if (this._isPredicate(elementNodeOrPredicate)) return elementNodeOrPredicate;
+      return (node) => node.value === elementNodeOrPredicate;
+    }
   };
 
   // src/data-structures/linked-list/doubly-linked-list.ts
@@ -2177,28 +2277,33 @@ var dataStructureTyped = (() => {
       return (_a = this.tail) == null ? void 0 : _a.value;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
-     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
-     * given array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a DoublyLinkedList object.
+     * The function `isNode` in TypeScript checks if a given input is an instance of
+     * `DoublyLinkedListNode`.
+     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<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 `DoublyLinkedListNode<E>`. If it is, the function returns `true`, indicating that the
+     * parameter is a `DoublyLinkedListNode<E>`. If it is not an instance of `DoublyLinkedListNode<E>`,
+     * the function returns `false`.
      */
-    static fromArray(data) {
-      return new _DoublyLinkedList(data);
+    isNode(elementNodeOrPredicate) {
+      return elementNodeOrPredicate instanceof DoublyLinkedListNode;
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The push function adds a new element to the end of a doubly linked list.
-     * @param {E} element - The "element" parameter represents the value that you want to add to the
-     * doubly 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 doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the `push`
+     * method can accept either an element of type `E` or a `DoublyLinkedListNode<E>` object.
+     * @returns The `push` method is returning a boolean value, specifically `true`.
      */
-    push(element) {
-      const newNode = new DoublyLinkedListNode(element);
+    push(elementOrNode) {
+      const newNode = this._ensureNode(elementOrNode);
       if (!this.head) {
         this._head = newNode;
         this._tail = newNode;
@@ -2254,13 +2359,14 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The unshift function adds a new element to the beginning of a doubly linked list.
-     * @param {E} element - The "element" parameter represents the value of the element that you want to
-     * add to the beginning of the doubly 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 doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the
+     * `unshift` method can be either an element of type `E` or a `DoublyLinkedListNode` containing an
+     * element of type `E`.
+     * @returns The `unshift` method is returning a boolean value, specifically `true`.
      */
-    unshift(element) {
-      const newNode = new DoublyLinkedListNode(element);
+    unshift(elementOrNode) {
+      const newNode = this._ensureNode(elementOrNode);
       if (!this.head) {
         this._head = newNode;
         this._tail = newNode;
@@ -2313,16 +2419,26 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function `findNodeByValue` searches for a node with a specific value in a doubly linked list and returns the
-     * node if found, otherwise it returns undefined.
-     * @param {E} value - The `value` parameter is the value that we want to search for in the doubly linked list.
-     * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `value`
-     * is found in the linked list. If no such node is found, it returns `undefined`.
+     * This TypeScript function searches for a node in a doubly linked list based on a given element node
+     * or predicate.
+     * @param {| E
+     *       | DoublyLinkedListNode<E>
+     *       | ((node: DoublyLinkedListNode<E>) => boolean)
+     *       | undefined} elementNodeOrPredicate - The `getNode` method you provided is used to find a
+     * node in a doubly linked list based on a given element, node, or predicate function. The
+     * `elementNodeOrPredicate` parameter can be one of the following:
+     * @returns The `getNode` method returns a `DoublyLinkedListNode<E>` or `undefined` based on the
+     * input `elementNodeOrPredicate`. If the input is `undefined`, the method returns `undefined`.
+     * Otherwise, it iterates through the linked list starting from the head node and applies the
+     * provided predicate function to each node. If a node satisfies the predicate, that node is
+     * returned. If
      */
-    getNode(value) {
+    getNode(elementNodeOrPredicate) {
+      if (elementNodeOrPredicate === void 0) return;
+      const predicate = this._ensurePredicate(elementNodeOrPredicate);
       let current = this.head;
       while (current) {
-        if (current.value === value) {
+        if (predicate(current)) {
           return current;
         }
         current = current.next;
@@ -2333,25 +2449,27 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `insert` function inserts a value at a specified index in a doubly linked list.
-     * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
-     * DoublyLinkedList. It is of type number.
-     * @param {E} value - The `value` parameter represents the value that you want to insert into the Doubly 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.
+     * The `addAt` function inserts a new element or node at a specified index in a doubly linked list.
+     * @param {number} index - The `index` parameter in the `addAt` method represents the position at
+     * which you want to add a new element or node in the doubly linked list. It indicates the location
+     * where the new element or node should be inserted.
+     * @param {E | DoublyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter in the
+     * `addAt` method can be either a value of type `E` or a `DoublyLinkedListNode<E>` object.
+     * @returns The `addAt` method returns a boolean value. It returns `true` if the element or node was
+     * successfully added at the specified index, and `false` if the index is out of bounds (less than 0
+     * or greater than the size of the list).
      */
-    addAt(index, value) {
+    addAt(index, newElementOrNode) {
       if (index < 0 || index > this._size) return false;
       if (index === 0) {
-        this.unshift(value);
+        this.unshift(newElementOrNode);
         return true;
       }
       if (index === this._size) {
-        this.push(value);
+        this.push(newElementOrNode);
         return true;
       }
-      const newNode = new DoublyLinkedListNode(value);
+      const newNode = this._ensureNode(newElementOrNode);
       const prevNode = this.getNodeAt(index - 1);
       const nextNode = prevNode.next;
       newNode.prev = prevNode;
@@ -2365,24 +2483,21 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
-     * The `addBefore` function inserts a new value before an existing value or node in a doubly linked list.
-     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
-     * before 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 `newValue` parameter represents the value that you want to insert into the doubly linked
-     * list.
-     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
-     * insertion fails.
+     * The `addBefore` function in TypeScript adds a new element or node before an existing element or
+     * node in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} existingElementOrNode - The `existingElementOrNode` parameter
+     * in the `addBefore` method can be either an element of type `E` or a `DoublyLinkedListNode<E>`.
+     * @param {E | DoublyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter
+     * represents the element or node that you want to add before the `existingElementOrNode` in a doubly
+     * linked list.
+     * @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 existing element or
+     * node was not found.
      */
-    addBefore(existingValueOrNode, newValue) {
-      let existingNode;
-      if (existingValueOrNode instanceof DoublyLinkedListNode) {
-        existingNode = existingValueOrNode;
-      } else {
-        existingNode = this.getNode(existingValueOrNode);
-      }
+    addBefore(existingElementOrNode, newElementOrNode) {
+      const existingNode = this.getNode(existingElementOrNode);
       if (existingNode) {
-        const newNode = new DoublyLinkedListNode(newValue);
+        const newNode = this._ensureNode(newElementOrNode);
         newNode.prev = existingNode.prev;
         if (existingNode.prev) {
           existingNode.prev.next = newNode;
@@ -2401,23 +2516,22 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
-     * The `addAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
-     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly 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 doubly linked list.
-     * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
-     * existing value or node is not found in the doubly linked list.
-     */
-    addAfter(existingValueOrNode, newValue) {
-      let existingNode;
-      if (existingValueOrNode instanceof DoublyLinkedListNode) {
-        existingNode = existingValueOrNode;
-      } else {
-        existingNode = this.getNode(existingValueOrNode);
-      }
+     * The `addAfter` function in TypeScript adds a new element or node after an existing element or node
+     * in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} existingElementOrNode - existingElementOrNode represents the
+     * element or node in the doubly linked list after which you want to add a new element or node.
+     * @param {E | DoublyLinkedListNode<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 doubly linked list. This parameter can be either an element value or a
+     * `DoublyLinkedListNode` object that you want to insert
+     * @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 in the linked list.
+     */
+    addAfter(existingElementOrNode, newElementOrNode) {
+      const existingNode = this.getNode(existingElementOrNode);
       if (existingNode) {
-        const newNode = new DoublyLinkedListNode(newValue);
+        const newNode = this._ensureNode(newElementOrNode);
         newNode.next = existingNode.next;
         if (existingNode.next) {
           existingNode.next.prev = newNode;
@@ -2464,19 +2578,17 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
-     * The `delete` function removes a node from a doubly linked list based on either the node itself or its value.
-     * @param {E | DoublyLinkedListNode<E>} valOrNode - The `valOrNode` parameter can accept either a value of type `E` or
-     * a `DoublyLinkedListNode<E>` object.
-     * @returns The `delete` method returns a boolean value. It returns `true` if the value or node was successfully
-     * deleted from the doubly linked list, and `false` if the value or node was not found in the list.
+     * The `delete` function removes a specified element or node from a doubly linked list if it exists.
+     * @param {E | DoublyLinkedListNode<E> | undefined} elementOrNode - The `elementOrNode` parameter in
+     * the `delete` method can accept an element of type `E`, a `DoublyLinkedListNode` of type `E`, or it
+     * can be `undefined`. This parameter is used to identify the node that needs to be deleted from the
+     * doubly linked list
+     * @returns The `delete` method returns a boolean value - `true` if the element or node was
+     * successfully deleted from the doubly linked list, and `false` if the element or node was not found
+     * in the list.
      */
-    delete(valOrNode) {
-      let node;
-      if (valOrNode instanceof DoublyLinkedListNode) {
-        node = valOrNode;
-      } else {
-        node = this.getNode(valOrNode);
-      }
+    delete(elementOrNode) {
+      const node = this.getNode(elementOrNode);
       if (node) {
         if (node === this.head) {
           this.shift();
@@ -2518,17 +2630,19 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function returns the index of the first occurrence of a given value in a linked list.
-     * @param {E} value - The parameter `value` is of type `E`, which means it can be any data type. It represents the value
-     * that we are searching for in the linked list.
-     * @returns The method `indexOf` returns the index of the first occurrence of the specified value `value` in the linked
-     * list. If the value is not found, it 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(value) {
+    indexOf(elementNodeOrPredicate) {
+      const predicate = this._ensurePredicate(elementNodeOrPredicate);
       let index = 0;
       let current = this.head;
       while (current) {
-        if (current.value === value) {
+        if (predicate(current)) {
           return index;
         }
         index++;
@@ -2540,19 +2654,41 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
-     * value that satisfies the given callback function, or undefined if no value satisfies the callback.
-     * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
-     * function is used to determine whether a given value satisfies a certain condition.
-     * @returns The method `findBackward` returns the last value in the linked list that satisfies the condition specified by
-     * the callback function. If no value satisfies the condition, it returns `undefined`.
+     * 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
+     * elementNodeOrPredicate - The `get` method takes in a parameter called `elementNodeOrPredicate`,
+     * which can be one of the following types:
+     * @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`.
      */
-    findBackward(callback) {
+    get(elementNodeOrPredicate) {
+      const predicate = this._ensurePredicate(elementNodeOrPredicate);
+      let current = this.head;
+      while (current) {
+        if (predicate(current)) return current.value;
+        current = current.next;
+      }
+      return void 0;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `getBackward` function searches for a specific element in a doubly linked list starting from
+     * the tail and moving backwards.
+     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `getBackward`
+     * function can be one of the following types:
+     * @returns The `getBackward` method returns the value of the element node that matches the provided
+     * predicate when traversing the doubly linked list backwards. If no matching element is found, it
+     * returns `undefined`.
+     */
+    getBackward(elementNodeOrPredicate) {
+      const predicate = this._ensurePredicate(elementNodeOrPredicate);
       let current = this.tail;
       while (current) {
-        if (callback(current.value)) {
-          return current.value;
-        }
+        if (predicate(current)) return current.value;
         current = current.prev;
       }
       return void 0;
@@ -2674,6 +2810,35 @@ var dataStructureTyped = (() => {
       }
       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)
+     *
+     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
+     * given array.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+     * @returns The `fromArray` function returns a DoublyLinkedList object.
+     */
+    static fromArray(data) {
+      return new _DoublyLinkedList(data);
+    }
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */
@@ -2684,6 +2849,45 @@ var dataStructureTyped = (() => {
         current = current.next;
       }
     }
+    /**
+     * The function `_isPredicate` checks if the input is a function that takes a `DoublyLinkedListNode`
+     * as an argument and returns a boolean.
+     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter can be one of the following
+     * types:
+     * @returns The _isPredicate method is returning a boolean value indicating 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.
+     */
+    _isPredicate(elementNodeOrPredicate) {
+      return typeof elementNodeOrPredicate === "function";
+    }
+    /**
+     * The function `_ensureNode` ensures that the input is a valid node in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter can be either
+     * an element of type `E` or a `DoublyLinkedListNode` containing an element of type `E`.
+     * @returns If the `elementOrNode` parameter is already a `DoublyLinkedListNode`, it will be returned
+     * as is. Otherwise, a new `DoublyLinkedListNode` instance will be created with the `elementOrNode`
+     * value and returned.
+     */
+    _ensureNode(elementOrNode) {
+      if (this.isNode(elementOrNode)) return elementOrNode;
+      return new DoublyLinkedListNode(elementOrNode);
+    }
+    /**
+     * 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 | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter can be one of the following
+     * types:
+     * @returns A function is being returned that takes a `DoublyLinkedListNode` as a parameter and
+     * returns a boolean value based on the conditions specified in the code.
+     */
+    _ensurePredicate(elementNodeOrPredicate) {
+      if (this.isNode(elementNodeOrPredicate)) return (node) => node === elementNodeOrPredicate;
+      if (this._isPredicate(elementNodeOrPredicate)) return elementNodeOrPredicate;
+      return (node) => node.value === elementNodeOrPredicate;
+    }
   };
 
   // src/data-structures/linked-list/skip-linked-list.ts