heap-typed 2.0.4 → 2.1.0

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

@@ -5,23 +5,55 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { DoublyLinkedListOptions, ElementCallback } from '../../types';
+import type { DoublyLinkedListOptions, ElementCallback, LinearBaseOptions } from '../../types';
 import { LinearLinkedBase, LinkedListNode } from '../base/linear-base';
+/**
+ * Node of a doubly linked list; stores value and prev/next links.
+ * @remarks Time O(1), Space O(1)
+ * @template E
+ */
 export declare class DoublyLinkedListNode<E = any> extends LinkedListNode<E> {
     /**
-     * The constructor function initializes the value, next, and previous properties of an object.
-     * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
-     * is defined as a generic type "E".
+     * Create a node.
+     * @remarks Time O(1), Space O(1)
+     * @param value - Element value to store.
+     * @returns New node instance.
      */
     constructor(value: E);
     protected _next: DoublyLinkedListNode<E> | undefined;
+    /**
+     * Get the next node link.
+     * @remarks Time O(1), Space O(1)
+     * @returns Next node or undefined.
+     */
     get next(): DoublyLinkedListNode<E> | undefined;
+    /**
+     * Set the next node link.
+     * @remarks Time O(1), Space O(1)
+     * @param value - Next node or undefined.
+     * @returns void
+     */
     set next(value: DoublyLinkedListNode<E> | undefined);
     protected _prev: DoublyLinkedListNode<E> | undefined;
+    /**
+     * Get the previous node link.
+     * @remarks Time O(1), Space O(1)
+     * @returns Previous node or undefined.
+     */
     get prev(): DoublyLinkedListNode<E> | undefined;
+    /**
+     * Set the previous node link.
+     * @remarks Time O(1), Space O(1)
+     * @param value - Previous node or undefined.
+     * @returns void
+     */
     set prev(value: DoublyLinkedListNode<E> | undefined);
 }
 /**
+ * Doubly linked list with O(1) push/pop/unshift/shift and linear scans.
+ * @remarks Time O(1), Space O(1)
+ * @template E
+ * @template R
  * 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.
@@ -196,6 +228,16 @@ export declare class DoublyLinkedListNode<E = any> extends LinkedListNode<E> {
  *         this.map = new Map<K, DoublyLinkedListNode<CacheEntry<K, V>>>();
  *       }
  *
+ *       // Get the current cache length
+ *       get length(): number {
+ *         return this.list.length;
+ *       }
+ *
+ *       // Check if it is empty
+ *       get isEmpty(): boolean {
+ *         return this.list.isEmpty();
+ *       }
+ *
  *       // Get cached value
  *       get(key: K): V | undefined {
  *         const node = this.map.get(key);
@@ -241,12 +283,6 @@ export declare class DoublyLinkedListNode<E = any> extends LinkedListNode<E> {
  *         }
  *       }
  *
- *       // Move the node to the head of the linked list
- *       private moveToFront(node: DoublyLinkedListNode<CacheEntry<K, V>>): void {
- *         this.list.delete(node);
- *         this.list.unshift(node.value);
- *       }
- *
  *       // Delete specific key
  *       delete(key: K): boolean {
  *         const node = this.map.get(key);
@@ -266,14 +302,10 @@ export declare class DoublyLinkedListNode<E = any> extends LinkedListNode<E> {
  *         this.map.clear();
  *       }
  *
- *       // Get the current cache length
- *       get length(): number {
- *         return this.list.length;
- *       }
- *
- *       // Check if it is empty
- *       get isEmpty(): boolean {
- *         return this.list.isEmpty();
+ *       // Move the node to the head of the linked list
+ *       private moveToFront(node: DoublyLinkedListNode<CacheEntry<K, V>>): void {
+ *         this.list.delete(node);
+ *         this.list.unshift(node.value);
  *       }
  *     }
  *
@@ -455,431 +487,283 @@ export declare class DoublyLinkedListNode<E = any> extends LinkedListNode<E> {
  *     console.log(scheduler.listProcesses()); // []
  */
 export declare class DoublyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, DoublyLinkedListNode<E>> {
+    protected _equals: (a: E, b: E) => boolean;
     /**
-     * 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.
+     * Create a DoublyLinkedList and optionally bulk-insert elements.
+     * @remarks Time O(N), Space O(N)
+     * @param [elements] - Iterable of elements or nodes (or raw records if toElementFn is provided).
+     * @param [options] - Options such as maxLen and toElementFn.
+     * @returns New DoublyLinkedList instance.
      */
     constructor(elements?: Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>, options?: DoublyLinkedListOptions<E, R>);
     protected _head: DoublyLinkedListNode<E> | undefined;
+    /**
+     * Get the head node.
+     * @remarks Time O(1), Space O(1)
+     * @returns Head node or undefined.
+     */
     get head(): DoublyLinkedListNode<E> | undefined;
     protected _tail: DoublyLinkedListNode<E> | undefined;
+    /**
+     * Get the tail node.
+     * @remarks Time O(1), Space O(1)
+     * @returns Tail node or undefined.
+     */
     get tail(): DoublyLinkedListNode<E> | undefined;
     protected _length: number;
+    /**
+     * Get the number of elements.
+     * @remarks Time O(1), Space O(1)
+     * @returns Current length.
+     */
     get length(): number;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `get first` function returns the first node in a doubly linked list, or undefined if the list is empty.
-     * @returns The method `get first()` returns the first node of the doubly linked list, or `undefined` if the list is empty.
+     * Get the first element value.
+     * @remarks Time O(1), Space O(1)
+     * @returns First element or undefined.
      */
     get first(): E | undefined;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `get last` function returns the last node in a doubly linked list, or undefined if the list is empty.
-     * @returns The method `get last()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
+     * Get the last element value.
+     * @remarks Time O(1), Space O(1)
+     * @returns Last element or undefined.
      */
     get last(): E | undefined;
     /**
-     * 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<E>(data: E[]): DoublyLinkedList<E, any>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * 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`.
+     * Create a new list from an array of elements.
+     * @remarks Time O(N), Space O(N)
+     * @template E
+     * @template R
+     * @param this - The constructor (subclass) to instantiate.
+     * @param data - Array of elements to insert.
+     * @returns A new list populated with the array's elements.
+     */
+    static fromArray<E, R = any>(this: new (elements?: Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>, options?: DoublyLinkedListOptions<E, R>) => any, data: E[]): any;
+    /**
+     * Type guard: check whether the input is a DoublyLinkedListNode.
+     * @remarks Time O(1), Space O(1)
+     * @param elementNodeOrPredicate - Element, node, or predicate.
+     * @returns True if the value is a DoublyLinkedListNode.
      */
     isNode(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): elementNodeOrPredicate is DoublyLinkedListNode<E>;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * 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`.
+     * Append an element/node to the tail.
+     * @remarks Time O(1), Space O(1)
+     * @param elementOrNode - Element or node to append.
+     * @returns True when appended.
      */
     push(elementOrNode: E | DoublyLinkedListNode<E>): boolean;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pop()` function removes and returns the value of the last element in a linked list.
-     * @returns The method is returning the value of the removed node.
+     * Remove and return the tail element.
+     * @remarks Time O(1), Space O(1)
+     * @returns Removed element or undefined.
      */
     pop(): E | undefined;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `shift()` function removes and returns the value of the first element in a doubly linked list.
-     * @returns The value of the removed node.
+     * Remove and return the head element.
+     * @remarks Time O(1), Space O(1)
+     * @returns Removed element or undefined.
      */
     shift(): E | undefined;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * 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`.
+     * Prepend an element/node to the head.
+     * @remarks Time O(1), Space O(1)
+     * @param elementOrNode - Element or node to prepend.
+     * @returns True when prepended.
      */
     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.
+     * Append a sequence of elements/nodes.
+     * @remarks Time O(N), Space O(1)
+     * @param elements - Iterable of elements or nodes (or raw records if toElementFn is provided).
+     * @returns Array of per-element success flags.
      */
     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.
+     * Prepend a sequence of elements/nodes.
+     * @remarks Time O(N), Space O(1)
+     * @param elements - Iterable of elements or nodes (or raw records if toElementFn is provided).
+     * @returns Array of per-element success flags.
      */
     unshiftMany(elements: Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>): boolean[];
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `at` function returns the value at a specified index in a linked list, or undefined if the index is out of bounds.
-     * @param {number} index - The index parameter is a number that represents the position of the element we want to
-     * retrieve from the list.
-     * @returns The method is returning the value at the specified index in the linked list. If the index is out of bounds
-     * or the linked list is empty, it will return undefined.
+     * Get the element at a given index.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index.
+     * @returns Element or undefined.
      */
     at(index: number): E | undefined;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function `getNodeAt` returns the node at a given index in a doubly linked list, or undefined if the index is out of
-     * range.
-     * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
-     * retrieve from the doubly linked list. It indicates the zero-based index of the node we want to access.
-     * @returns The method `getNodeAt(index: number)` returns a `DoublyLinkedListNode<E>` object if the index is within the
-     * valid range of the linked list, otherwise it returns `undefined`.
+     * Get the node reference at a given index.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index.
+     * @returns Node or undefined.
      */
     getNodeAt(index: number): DoublyLinkedListNode<E> | undefined;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * 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
+     * Find a node by value, reference, or predicate.
+     * @remarks Time O(N), Space O(1)
+     * @param [elementNodeOrPredicate] - Element, node, or predicate to match.
+     * @returns Matching node or undefined.
      */
     getNode(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean) | undefined): DoublyLinkedListNode<E> | undefined;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * 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 length of the list).
+     * Insert a new element/node at an index, shifting following nodes.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index.
+     * @param newElementOrNode - Element or node to insert.
+     * @returns True if inserted.
      */
     addAt(index: number, newElementOrNode: E | DoublyLinkedListNode<E>): boolean;
     /**
-     * Time Complexity: O(1) or O(n)
-     * Space Complexity: O(1)
-     *
-     * 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.
+     * Insert a new element/node before an existing one.
+     * @remarks Time O(N), Space O(1)
+     * @param existingElementOrNode - Existing element or node.
+     * @param newElementOrNode - Element or node to insert.
+     * @returns True if inserted.
      */
     addBefore(existingElementOrNode: E | DoublyLinkedListNode<E>, newElementOrNode: E | DoublyLinkedListNode<E>): boolean;
     /**
-     * Time Complexity: O(1) or O(n)
-     * Space Complexity: O(1)
-     *
-     * 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.
+     * Insert a new element/node after an existing one.
+     * @remarks Time O(N), Space O(1)
+     * @param existingElementOrNode - Existing element or node.
+     * @param newElementOrNode - Element or node to insert.
+     * @returns True if inserted.
      */
     addAfter(existingElementOrNode: E | DoublyLinkedListNode<E>, newElementOrNode: E | DoublyLinkedListNode<E>): boolean;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function `setAt` updates the value at a specified index in a data structure if the index
-     * exists.
-     * @param {number} index - The `index` parameter in the `setAt` method refers to the position in the
-     * data structure where you want to set a new value.
-     * @param {E} value - The `value` parameter in the `setAt` method represents the new value that you
-     * want to set at the specified index in the data structure.
-     * @returns The `setAt` method returns a boolean value - `true` if the value at the specified index
-     * is successfully updated, and `false` if the index is out of bounds.
+     * Set the element value at an index.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index.
+     * @param value - New value.
+     * @returns True if updated.
      */
     setAt(index: number, value: E): boolean;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
-     * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
-     * data structure. It is of type number.
-     * @returns The method `deleteAt` returns the value of the node that was deleted, or `undefined` if the index is out of
-     * bounds.
+     * Delete the element at an index.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index.
+     * @returns Removed element or undefined.
      */
     deleteAt(index: number): E | undefined;
     /**
-     * Time Complexity: O(1) or O(n)
-     * Space Complexity: O(1)
-     *
-     * 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 the first match by value/node.
+     * @remarks Time O(N), Space O(1)
+     * @param [elementOrNode] - Element or node to remove.
+     * @returns True if removed.
      */
     delete(elementOrNode: E | DoublyLinkedListNode<E> | undefined): boolean;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function checks if a variable has a length greater than zero and returns a boolean value.
-     * @returns A boolean value is being returned.
+     * Check whether the list is empty.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if length is 0.
      */
     isEmpty(): boolean;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
+     * Remove all nodes and reset length.
+     * @remarks Time O(N), Space O(1)
+     * @returns void
      */
     clear(): void;
     /**
-     * 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
-     * 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`.
+     * Find the first value matching a predicate scanning forward.
+     * @remarks Time O(N), Space O(1)
+     * @param elementNodeOrPredicate - Element, node, or predicate to match.
+     * @returns Matched value or undefined.
      */
     search(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): E | undefined;
     /**
-     * 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`.
+     * Find the first value matching a predicate scanning backward.
+     * @remarks Time O(N), Space O(1)
+     * @param elementNodeOrPredicate - Element, node, or predicate to match.
+     * @returns Matched value or undefined.
      */
     getBackward(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): E | undefined;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `reverse` function reverses the order of the elements in a doubly linked list.
+     * Reverse the list in place.
+     * @remarks Time O(N), Space O(1)
+     * @returns This list.
      */
     reverse(): this;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `clone` function creates a new instance of the `DoublyLinkedList` class with the same values
-     * as the original list.
-     * @returns The `clone()` method is returning a new instance of the `DoublyLinkedList` class, which
-     * is a copy of the original list.
+     * Set the equality comparator used to compare values.
+     * @remarks Time O(1), Space O(1)
+     * @param equals - Equality predicate (a, b) → boolean.
+     * @returns This list.
      */
-    clone(): this;
+    setEquality(equals: (a: E, b: E) => boolean): this;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `filter` function creates a new DoublyLinkedList by iterating over the elements of the current
-     * list and applying a callback function to each element, returning only the elements for which the
-     * callback function returns true.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the DoublyLinkedList. It takes three arguments: the current element, the index of the current
-     * element, and the DoublyLinkedList itself. The callback function should return a boolean value
-     * indicating whether the current element should be included
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns The `filter` method is returning a new `DoublyLinkedList` object that contains the
-     * elements that pass the filter condition specified by the `callback` function.
-     */
-    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): DoublyLinkedList<E, R>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function takes a callback function and returns a new DoublyLinkedList with the results
-     * of applying the callback to each element in the original list.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * original DoublyLinkedList. It takes three arguments: current (the current element being
-     * processed), index (the index of the current element), and this (the original DoublyLinkedList).
-     * The callback function should return a value of type
-     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
-     * convert the raw element (`RR`) to the desired element type (`T`). It takes the raw element as
-     * input and returns the converted element. If this parameter is not provided, the raw element will
-     * be used as is.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-     * specify the value of `this` within the callback function. It is used to set the context or scope
-     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
-     * value of
-     * @returns a new instance of the `DoublyLinkedList` class with elements of type `T` and `RR`.
-     */
-    map<EM, RM>(callback: ElementCallback<E, R, EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): DoublyLinkedList<EM, RM>;
-    /**
-     * 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;
-    /**
-     * The function returns an iterator that iterates over the values of a linked list.
+     * Deep clone this list (values are copied by reference).
+     * @remarks Time O(N), Space O(N)
+     * @returns A new list with the same element sequence.
      */
-    protected _getIterator(): IterableIterator<E>;
+    clone(): this;
     /**
-     * The function returns an iterator that iterates over the elements of a data structure in reverse
-     * order.
+     * Filter values into a new list of the same class.
+     * @remarks Time O(N), Space O(N)
+     * @param callback - Predicate (value, index, list) → boolean to keep value.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new list with kept values.
      */
-    protected _getReverseIterator(): IterableIterator<E>;
+    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): this;
     /**
-     * The function returns an iterator that iterates over the nodes of a doubly linked list starting
-     * from the head.
+     * Map values into a new list of the same class.
+     * @remarks Time O(N), Space O(N)
+     * @param callback - Mapping function (value, index, list) → newValue.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new list with mapped values.
      */
-    protected _getNodeIterator(): IterableIterator<DoublyLinkedListNode<E>>;
+    mapSame(callback: ElementCallback<E, R, E>, thisArg?: any): this;
     /**
-     * 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.
+     * Map values into a new list (possibly different element type).
+     * @remarks Time O(N), Space O(N)
+     * @template EM
+     * @template RM
+     * @param callback - Mapping function (value, index, list) → newElement.
+     * @param [options] - Options for the output list (e.g., maxLen, toElementFn).
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new DoublyLinkedList with mapped values.
      */
-    protected _isPredicate(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): elementNodeOrPredicate is (node: DoublyLinkedListNode<E>) => boolean;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, options?: DoublyLinkedListOptions<EM, RM>, thisArg?: any): DoublyLinkedList<EM, RM>;
     /**
-     * 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.
+     * (Protected) Create or return a node for the given input (node or raw element).
+     * @remarks Time O(1), Space O(1)
+     * @param elementOrNode - Element value or node to normalize.
+     * @returns A DoublyLinkedListNode for the provided input.
      */
     protected _ensureNode(elementOrNode: E | DoublyLinkedListNode<E>): DoublyLinkedListNode<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 | 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.
+     * (Protected) Normalize input into a predicate over nodes.
+     * @remarks Time O(1), Space O(1)
+     * @param elementNodeOrPredicate - Element, node, or node predicate.
+     * @returns A predicate function taking a node and returning true/false.
      */
     protected _ensurePredicate(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): (node: DoublyLinkedListNode<E>) => boolean;
     /**
-     * The function `_createInstance` returns a new instance of `DoublyLinkedList` with the specified
-     * options.
-     * @param [options] - The `options` parameter in the `_createInstance` method is of type
-     * `DoublyLinkedListOptions<E, R>`. It is an optional parameter that allows you to pass additional
-     * configuration options when creating a new instance of the `DoublyLinkedList` class.
-     * @returns An instance of the `DoublyLinkedList` class with an empty array and the provided options
-     * is being returned, cast as the current class type.
+     * (Protected) Get the previous node of a given node.
+     * @remarks Time O(1), Space O(1)
+     * @param node - A node in the list.
+     * @returns Previous node or undefined.
      */
-    protected _createInstance(options?: DoublyLinkedListOptions<E, R>): this;
+    protected _getPrevNode(node: DoublyLinkedListNode<E>): DoublyLinkedListNode<E> | undefined;
     /**
-     * The function `_getPrevNode` returns the previous node of a given node in a doubly linked list.
-     * @param node - The parameter `node` in the `_getPrevNode` method is of type
-     * `DoublyLinkedListNode<E>`, which represents a node in a doubly linked list containing an element
-     * of type `E`.
-     * @returns The `_getPrevNode` method is returning the previous node of the input `node` in a doubly
-     * linked list. If the input node has a previous node, it will return that node. Otherwise, it will
-     * return `undefined`.
+     * (Protected) Create an empty instance of the same concrete class.
+     * @remarks Time O(1), Space O(1)
+     * @param [options] - Options forwarded to the constructor.
+     * @returns An empty like-kind list instance.
      */
-    protected _getPrevNode(node: DoublyLinkedListNode<E>): DoublyLinkedListNode<E> | undefined;
+    protected _createInstance(options?: LinearBaseOptions<E, R>): this;
+    /**
+     * (Protected) Create a like-kind instance and seed it from an iterable.
+     * @remarks Time O(N), Space O(N)
+     * @template EM
+     * @template RM
+     * @param [elements] - Iterable used to seed the new list.
+     * @param [options] - Options forwarded to the constructor.
+     * @returns A like-kind DoublyLinkedList instance.
+     */
+    protected _createLike<EM = E, RM = R>(elements?: Iterable<EM> | Iterable<RM> | Iterable<DoublyLinkedListNode<EM>>, options?: DoublyLinkedListOptions<EM, RM>): DoublyLinkedList<EM, RM>;
+    protected _getIterator(): IterableIterator<E>;
+    protected _getReverseIterator(): IterableIterator<E>;
+    protected _getNodeIterator(): IterableIterator<DoublyLinkedListNode<E>>;
 }