data-structure-typed 1.16.1 → 1.17.3

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -1,9 +1,48 @@
 "use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoublyLinkedList = exports.DoublyLinkedListNode = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 var DoublyLinkedListNode = /** @class */ (function () {
-    function DoublyLinkedListNode(nodeValue) {
-        this._val = nodeValue;
+    /**
+     * The constructor function initializes the value, next, and previous properties of an object.
+     * @param {T} val - The "val" 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 "T".
+     */
+    function DoublyLinkedListNode(val) {
+        this._val = val;
         this._next = null;
         this._prev = null;
     }
@@ -11,8 +50,8 @@ var DoublyLinkedListNode = /** @class */ (function () {
         get: function () {
             return this._val;
         },
-        set: function (v) {
-            this._val = v;
+        set: function (value) {
+            this._val = value;
         },
         enumerable: false,
         configurable: true
@@ -21,8 +60,8 @@ var DoublyLinkedListNode = /** @class */ (function () {
         get: function () {
             return this._next;
         },
-        set: function (v) {
-            this._next = v;
+        set: function (value) {
+            this._next = value;
         },
         enumerable: false,
         configurable: true
@@ -31,8 +70,8 @@ var DoublyLinkedListNode = /** @class */ (function () {
         get: function () {
             return this._prev;
         },
-        set: function (v) {
-            this._prev = v;
+        set: function (value) {
+            this._prev = value;
         },
         enumerable: false,
         configurable: true
@@ -41,325 +80,517 @@ var DoublyLinkedListNode = /** @class */ (function () {
 }());
 exports.DoublyLinkedListNode = DoublyLinkedListNode;
 var DoublyLinkedList = /** @class */ (function () {
+    /**
+     * The constructor initializes the linked list with an empty head, tail, and length.
+     */
     function DoublyLinkedList() {
-        this._first = null;
-        this._last = null;
-        this._size = 0;
+        this._head = null;
+        this._tail = null;
+        this._length = 0;
     }
-    Object.defineProperty(DoublyLinkedList.prototype, "first", {
+    Object.defineProperty(DoublyLinkedList.prototype, "head", {
         get: function () {
-            return this._first;
+            return this._head;
         },
-        set: function (v) {
-            this._first = v;
+        set: function (value) {
+            this._head = value;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(DoublyLinkedList.prototype, "last", {
+    Object.defineProperty(DoublyLinkedList.prototype, "tail", {
         get: function () {
-            return this._last;
+            return this._tail;
         },
-        set: function (v) {
-            this._last = v;
+        set: function (value) {
+            this._tail = value;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(DoublyLinkedList.prototype, "size", {
+    Object.defineProperty(DoublyLinkedList.prototype, "length", {
         get: function () {
-            return this._size;
+            return this._length;
         },
-        set: function (v) {
-            this._size = v;
+        set: function (value) {
+            this._length = value;
         },
         enumerable: false,
         configurable: true
     });
     /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
+     * given array.
+     * @param {T[]} data - The `data` parameter is an array of elements of type `T`.
+     * @returns The `fromArray` function returns a DoublyLinkedList object.
      */
-    DoublyLinkedList.prototype.getFirst = function () {
-        return this._first;
+    DoublyLinkedList.fromArray = function (data) {
+        var e_1, _a;
+        var doublyLinkedList = new DoublyLinkedList();
+        try {
+            for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
+                var item = data_1_1.value;
+                doublyLinkedList.push(item);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return doublyLinkedList;
+    };
+    DoublyLinkedList.prototype.getLength = function () {
+        return this._length;
     };
     /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     * The push function adds a new node with the given value to the end of the doubly linked list.
+     * @param {T} val - The value to be added to the linked list.
      */
-    DoublyLinkedList.prototype.getLast = function () {
-        return this._last;
+    DoublyLinkedList.prototype.push = function (val) {
+        var newNode = new DoublyLinkedListNode(val);
+        if (!this.head) {
+            this.head = newNode;
+            this.tail = newNode;
+        }
+        else {
+            newNode.prev = this.tail;
+            this.tail.next = newNode;
+            this.tail = newNode;
+        }
+        this.length++;
     };
     /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     * The `pop()` function removes and returns the value of the last node in a doubly linked list.
+     * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
+     * list is empty, it returns null.
      */
-    DoublyLinkedList.prototype.getSize = function () {
-        return this._size;
+    DoublyLinkedList.prototype.pop = function () {
+        if (!this.tail)
+            return null;
+        var removedNode = this.tail;
+        if (this.head === this.tail) {
+            this.head = null;
+            this.tail = null;
+        }
+        else {
+            this.tail = removedNode.prev;
+            this.tail.next = null;
+        }
+        this.length--;
+        return removedNode.val;
     };
     /**
-     * The function adds a new node with a given value to the beginning of a doubly linked list.
-     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of
-     * the doubly linked list.
-     * @returns A boolean value is being returned.
+     * The `shift()` function removes and returns the value of the first node in a doubly linked list.
+     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
+     * list.
      */
-    DoublyLinkedList.prototype.addFirst = function (val) {
-        var newNode = new DoublyLinkedListNode(val);
-        if (this._size === 0) {
-            this._first = newNode;
-            this._last = newNode;
+    DoublyLinkedList.prototype.shift = function () {
+        if (!this.head)
+            return null;
+        var removedNode = this.head;
+        if (this.head === this.tail) {
+            this.head = null;
+            this.tail = null;
         }
         else {
-            if (this._first)
-                this._first.prev = newNode;
-            newNode.next = this._first;
-            this._first = newNode;
+            this.head = removedNode.next;
+            this.head.prev = null;
         }
-        this._size++;
-        return true;
+        this.length--;
+        return removedNode.val;
     };
     /**
-     * The function adds a new node with a given value to the end of a doubly linked list.
-     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the end of the
+     * The unshift function adds a new node with the given value to the beginning of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the new node that will be added to the beginning of the
      * doubly linked list.
-     * @returns a boolean value, which is always true.
      */
-    DoublyLinkedList.prototype.addLast = function (val) {
+    DoublyLinkedList.prototype.unshift = function (val) {
         var newNode = new DoublyLinkedListNode(val);
-        if (this._size === 0) {
-            this._first = newNode;
-            this._last = newNode;
+        if (!this.head) {
+            this.head = newNode;
+            this.tail = newNode;
         }
         else {
-            if (this._last)
-                this._last.next = newNode;
-            newNode.prev = this._last;
-            this._last = newNode;
+            newNode.next = this.head;
+            this.head.prev = newNode;
+            this.head = newNode;
         }
-        this._size++;
-        return true;
+        this.length++;
     };
     /**
-     * The `peekFirst` function returns the first node or value in a doubly linked list, depending on the specified
-     * parameter.
-     * @param {DoublyLinkedListGetBy} [by] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy. It
-     * is used to specify whether to return the first node, the value of the first node, or the first node itself.
-     * @returns The method `peekFirst` returns either the first node of the doubly linked list (`DoublyLinkedListNode<T>`),
-     * the value of the first node (`T`), or `null` depending on the value of the `by` parameter.
+     * The `getAt` function returns the value at a specified index in a linked list, or null 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 null.
      */
-    DoublyLinkedList.prototype.peekFirst = function (by) {
-        var _a, _b, _c, _d, _e;
-        switch (by) {
-            case 'node':
-                return (_a = this._first) !== null && _a !== void 0 ? _a : null;
-            case 'val':
-                return (_c = (_b = this._first) === null || _b === void 0 ? void 0 : _b.val) !== null && _c !== void 0 ? _c : null;
-            default:
-                return (_e = (_d = this._first) === null || _d === void 0 ? void 0 : _d.val) !== null && _e !== void 0 ? _e : null;
+    DoublyLinkedList.prototype.getAt = function (index) {
+        if (index < 0 || index >= this.length)
+            return null;
+        var current = this.head;
+        for (var i = 0; i < index; i++) {
+            current = current.next;
         }
+        return current.val;
     };
     /**
-     * The `peekLast` function returns the last node or value in a doubly linked list.
-     * @param {DoublyLinkedListGetBy} [by=val] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy.
-     * It specifies whether to return the last node, the value of the last node, or both. The default value is 'val', which
-     * means that if no value is provided for the "by" parameter, the method
-     * @returns The method `peekLast` returns the last node, value, or null based on the specified `by` parameter.
+     * The function `getNodeAt` returns the node at a given index in a doubly linked list, or null 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<T>` object if the index is within the
+     * valid range of the linked list, otherwise it returns `null`.
      */
-    DoublyLinkedList.prototype.peekLast = function (by) {
-        var _a, _b, _c, _d, _e;
-        if (by === void 0) { by = 'val'; }
-        switch (by) {
-            case 'node':
-                return (_a = this._last) !== null && _a !== void 0 ? _a : null;
-            case 'val':
-                return (_c = (_b = this._last) === null || _b === void 0 ? void 0 : _b.val) !== null && _c !== void 0 ? _c : null;
-            default:
-                return (_e = (_d = this._last) === null || _d === void 0 ? void 0 : _d.val) !== null && _e !== void 0 ? _e : null;
+    DoublyLinkedList.prototype.getNodeAt = function (index) {
+        if (index < 0 || index >= this.length)
+            return null;
+        var current = this.head;
+        for (var i = 0; i < index; i++) {
+            current = current.next;
         }
+        return current;
     };
     /**
-     * The function `pollFirst` removes and returns the first element of a doubly linked list, either as a node or its
-     * value, depending on the specified parameter.
-     * @param {DoublyLinkedListGetBy} [by=val] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy.
-     * It specifies the criteria by which the first element should be retrieved from the doubly linked list. The default
-     * value is 'val', which means the first element will be retrieved by its value. Other possible values for "by
-     * @returns The method `pollFirst` returns either the value of the first node in the doubly linked list, the first node
-     * itself, or null if the list is empty. The specific return type depends on the value of the `by` parameter. If `by`
-     * is set to 'node', the method returns the first node. If `by` is set to 'val', the method returns the value
+     * 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 null.
+     * @param {T} val - The `val` parameter is the value that we want to search for in the doubly linked list.
+     * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<T>` if a node with the specified value `val`
+     * is found in the linked list. If no such node is found, it returns `null`.
      */
-    DoublyLinkedList.prototype.pollFirst = function (by) {
-        var _a, _b, _c;
-        if (by === void 0) { by = 'val'; }
-        if (this._size === 0)
-            return null;
-        var oldHead = this._first;
-        if (this._size === 1) {
-            this._first = null;
-            this._last = null;
+    DoublyLinkedList.prototype.findNode = function (val) {
+        var current = this.head;
+        while (current) {
+            if (current.val === val) {
+                return current;
+            }
+            current = current.next;
         }
-        else {
-            this._first = (_a = oldHead === null || oldHead === void 0 ? void 0 : oldHead.next) !== null && _a !== void 0 ? _a : null;
-            if (this._first)
-                this._first.prev = null;
-            if (oldHead)
-                oldHead.next = null;
-        }
-        this._size--;
-        switch (by) {
-            case 'node':
-                return oldHead !== null && oldHead !== void 0 ? oldHead : null;
-            case 'val':
-                return (_b = oldHead === null || oldHead === void 0 ? void 0 : oldHead.val) !== null && _b !== void 0 ? _b : null;
-            default:
-                return (_c = oldHead === null || oldHead === void 0 ? void 0 : oldHead.val) !== null && _c !== void 0 ? _c : null;
+        return null;
+    };
+    /**
+     * 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 {T} val - The `val` 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.
+     */
+    DoublyLinkedList.prototype.insertAt = function (index, val) {
+        if (index < 0 || index > this.length)
+            return false;
+        if (index === 0) {
+            this.unshift(val);
+            return true;
         }
+        if (index === this.length) {
+            this.push(val);
+            return true;
+        }
+        var newNode = new DoublyLinkedListNode(val);
+        var prevNode = this.getNodeAt(index - 1);
+        var nextNode = prevNode.next;
+        newNode.prev = prevNode;
+        newNode.next = nextNode;
+        prevNode.next = newNode;
+        nextNode.prev = newNode;
+        this.length++;
+        return true;
     };
     /**
-     * The function `pollLast` removes and returns the last element in a doubly linked list, either as a node or its value,
-     * depending on the specified parameter.
-     * @param {DoublyLinkedListGetBy} [by=val] - The parameter "by" is of type DoublyLinkedListGetBy, which is an enum that
-     * can have two possible values: 'node' or 'val'. It determines the type of value that will be returned by the pollLast
-     * method. If 'node' is specified, the method will return the
-     * @returns The method `pollLast` returns either a `DoublyLinkedListNode<T>`, the value of the node (`T`), or `null`.
-     * The specific type that is returned depends on the value of the `by` parameter. If `by` is set to `'node'`, then a
-     * `DoublyLinkedListNode<T>` is returned. If `by` is set to `'
+     * 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 `null` if the index is out of
+     * bounds.
      */
-    DoublyLinkedList.prototype.pollLast = function (by) {
-        var _a, _b, _c;
-        if (by === void 0) { by = 'val'; }
-        if (this._size === 0)
+    DoublyLinkedList.prototype.deleteAt = function (index) {
+        if (index < 0 || index >= this.length)
             return null;
-        var polled = this._last;
-        if (this._size === 1) {
-            this._first = null;
-            this._last = null;
+        if (index === 0)
+            return this.shift();
+        if (index === this.length - 1)
+            return this.pop();
+        var removedNode = this.getNodeAt(index);
+        var prevNode = removedNode.prev;
+        var nextNode = removedNode.next;
+        prevNode.next = nextNode;
+        nextNode.prev = prevNode;
+        this.length--;
+        return removedNode.val;
+    };
+    /**
+     * The `delete` function removes a node from a doubly linked list based on either the node itself or its value.
+     * @param {T | DoublyLinkedListNode<T>} valOrNode - The `valOrNode` parameter can accept either a value of type `T` or
+     * a `DoublyLinkedListNode<T>` 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.
+     */
+    DoublyLinkedList.prototype.delete = function (valOrNode) {
+        var node;
+        if (valOrNode instanceof (DoublyLinkedListNode)) {
+            node = valOrNode;
         }
         else {
-            this._last = (_a = polled === null || polled === void 0 ? void 0 : polled.prev) !== null && _a !== void 0 ? _a : null;
-            if (this._last)
-                this._last.next = null;
-            if (polled)
-                polled.prev = null;
-        }
-        this._size--;
-        switch (by) {
-            case 'node':
-                return polled !== null && polled !== void 0 ? polled : null;
-            case 'val':
-                return (_b = polled === null || polled === void 0 ? void 0 : polled.val) !== null && _b !== void 0 ? _b : null;
-            default:
-                return (_c = polled === null || polled === void 0 ? void 0 : polled.val) !== null && _c !== void 0 ? _c : null;
+            node = this.findNode(valOrNode);
+        }
+        if (node) {
+            if (node === this.head) {
+                this.shift();
+            }
+            else if (node === this.tail) {
+                this.pop();
+            }
+            else {
+                var prevNode = node.prev;
+                var nextNode = node.next;
+                prevNode.next = nextNode;
+                nextNode.prev = prevNode;
+                this.length--;
+            }
+            return true;
         }
+        return false;
     };
     /**
-     * Returns the node at the specified index of the linked list.
-     * If index = 0; first element in the list is returned.
-     * If index = 3; fourth element in the list is returned.
-     * @param index Index of the node to be retrieved
-     * @param by Return value type
+     * The `toArray` function converts a linked list into an array.
+     * @returns The `toArray()` method is returning an array of type `T[]`.
      */
-    DoublyLinkedList.prototype.get = function (index, by) {
-        var _a, _b;
-        if (by === void 0) { by = 'val'; }
-        if (index < 0 || index >= this._size)
-            return null;
-        var count, current;
-        if (index <= this._size / 2) {
-            count = 0;
-            current = this._first;
-            while (count !== index) {
-                current = current === null || current === void 0 ? void 0 : current.next;
-                count++;
+    DoublyLinkedList.prototype.toArray = function () {
+        var array = [];
+        var current = this.head;
+        while (current) {
+            array.push(current.val);
+            current = current.next;
+        }
+        return array;
+    };
+    /**
+     * The `clear` function resets the linked list by setting the head, tail, and length to null and 0 respectively.
+     */
+    DoublyLinkedList.prototype.clear = function () {
+        this._head = null;
+        this._tail = null;
+        this._length = 0;
+    };
+    /**
+     * The `find` function iterates through a linked list and returns the first element that satisfies a given condition.
+     * @param callback - A function that takes a value of type T as its parameter and returns a boolean value. This
+     * function is used to determine whether a particular value in the linked list satisfies a certain condition.
+     * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
+     * the callback function. If no element satisfies the condition, it returns `null`.
+     */
+    DoublyLinkedList.prototype.find = function (callback) {
+        var current = this.head;
+        while (current) {
+            if (callback(current.val)) {
+                return current.val;
             }
+            current = current.next;
         }
-        else {
-            count = this._size - 1;
-            current = this._last;
-            while (count !== index) {
-                current = current === null || current === void 0 ? void 0 : current.prev;
-                count--;
+        return null;
+    };
+    /**
+     * The function returns the index of the first occurrence of a given value in a linked list.
+     * @param {T} val - The parameter `val` is of type `T`, 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 `val` in the linked
+     * list. If the value is not found, it returns -1.
+     */
+    DoublyLinkedList.prototype.indexOf = function (val) {
+        var index = 0;
+        var current = this.head;
+        while (current) {
+            if (current.val === val) {
+                return index;
             }
+            index++;
+            current = current.next;
         }
-        switch (by) {
-            case 'node':
-                return current !== null && current !== void 0 ? current : null;
-            case 'val':
-                return (_a = current === null || current === void 0 ? void 0 : current.val) !== null && _a !== void 0 ? _a : null;
-            default:
-                return (_b = current === null || current === void 0 ? void 0 : current.val) !== null && _b !== void 0 ? _b : null;
+        return -1;
+    };
+    /**
+     * The `findLast` 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 null if no value satisfies the callback.
+     * @param callback - A function that takes a value of type T 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 `findLast` 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 `null`.
+     */
+    DoublyLinkedList.prototype.findLast = function (callback) {
+        var current = this.tail;
+        while (current) {
+            if (callback(current.val)) {
+                return current.val;
+            }
+            current = current.prev;
         }
+        return null;
     };
     /**
-     * Updates the value of the node at the specified index.
-     * If index = 0; Value of the first element in the list is updated.
-     * If index = 3; Value of the fourth element in the list is updated.
-     * @param index Index of the node to be updated
-     * @param val New value of the node
+     * The `toArrayReverse` function converts a doubly linked list into an array in reverse order.
+     * @returns The `toArrayReverse()` function returns an array of type `T[]`.
      */
-    DoublyLinkedList.prototype.set = function (index, val) {
-        var foundNode = this.get(index, 'node');
-        if (foundNode !== null) {
-            foundNode.val = val;
-            return true;
+    DoublyLinkedList.prototype.toArrayReverse = function () {
+        var array = [];
+        var current = this.tail;
+        while (current) {
+            array.push(current.val);
+            current = current.prev;
         }
-        return false;
+        return array;
     };
-    DoublyLinkedList.prototype.isEmpty = function () {
-        return this._size === 0;
+    /**
+     * The `reverse` function reverses the order of the elements in a doubly linked list.
+     */
+    DoublyLinkedList.prototype.reverse = function () {
+        var _a, _b;
+        var current = this.head;
+        _a = __read([this.tail, this.head], 2), this.head = _a[0], this.tail = _a[1];
+        while (current) {
+            var next = current.next;
+            _b = __read([current.next, current.prev], 2), current.prev = _b[0], current.next = _b[1];
+            current = next;
+        }
     };
-    // --- start extra methods ---
     /**
-     * Inserts a new node at the specified index.
-     * @param index Index at which the new node has to be inserted
-     * @param val Value of the new node to be inserted
+     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+     * @param callback - The callback parameter is a function that takes two arguments: val and index. The val argument
+     * represents the value of the current node in the linked list, and the index argument represents the index of the
+     * current node in the linked list.
      */
-    DoublyLinkedList.prototype.insert = function (index, val) {
-        if (index < 0 || index > this._size)
-            return false;
-        if (index === 0)
-            return !!this.addFirst(val);
-        if (index === this._size)
-            return !!this.addLast(val);
-        var newNode = new DoublyLinkedListNode(val);
-        var prevNode = this.get(index - 1, 'node');
-        var nextNode = prevNode === null || prevNode === void 0 ? void 0 : prevNode.next;
-        if (prevNode)
-            prevNode.next = newNode;
-        newNode.prev = prevNode;
-        newNode.next = nextNode !== null && nextNode !== void 0 ? nextNode : null;
-        if (nextNode)
-            nextNode.prev = newNode;
-        this._size++;
-        return true;
+    DoublyLinkedList.prototype.forEach = function (callback) {
+        var current = this.head;
+        var index = 0;
+        while (current) {
+            callback(current.val, index);
+            current = current.next;
+            index++;
+        }
     };
     /**
-     * The `remove` function removes an element at a specified index from a data structure, updating the links between
-     * nodes accordingly.
-     * @param {number} index - The index parameter represents the position of the element to be removed in the data
-     * structure. It is of type number.
-     * @returns The `remove` method returns the value of the removed element (`T`) if the removal is successful, or `null`
-     * if the index is out of bounds.
+     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
+     * DoublyLinkedList with the transformed values.
+     * @param callback - The callback parameter is a function that takes a value of type T (the type of values stored in
+     * the original DoublyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
+     * DoublyLinkedList).
+     * @returns The `map` function is returning a new instance of `DoublyLinkedList<U>` that contains the mapped values.
      */
-    DoublyLinkedList.prototype.remove = function (index) {
-        var _a, _b, _c;
-        if (index < 0 || index > this._size - 1)
-            return null;
-        else if (index === 0)
-            return this.pollFirst();
-        else if (index === this._size - 1)
-            return (_b = (_a = this.pollLast('node')) === null || _a === void 0 ? void 0 : _a.val) !== null && _b !== void 0 ? _b : null;
+    DoublyLinkedList.prototype.map = function (callback) {
+        var mappedList = new DoublyLinkedList();
+        var current = this.head;
+        while (current) {
+            mappedList.push(callback(current.val));
+            current = current.next;
+        }
+        return mappedList;
+    };
+    /**
+     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList containing only the
+     * elements that satisfy the given callback function.
+     * @param callback - The `callback` parameter is a function that takes a value of type `T` and returns a boolean value.
+     * It is used to determine whether a value should be included in the filtered list or not.
+     * @returns The filtered list, which is an instance of the DoublyLinkedList class.
+     */
+    DoublyLinkedList.prototype.filter = function (callback) {
+        var filteredList = new DoublyLinkedList();
+        var current = this.head;
+        while (current) {
+            if (callback(current.val)) {
+                filteredList.push(current.val);
+            }
+            current = current.next;
+        }
+        return filteredList;
+    };
+    /**
+     * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
+     * single value.
+     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `val`. It is
+     * used to perform a specific operation on each element of the linked list.
+     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * point for the reduction operation.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
+     * elements in the linked list.
+     */
+    DoublyLinkedList.prototype.reduce = function (callback, initialValue) {
+        var accumulator = initialValue;
+        var current = this.head;
+        while (current) {
+            accumulator = callback(accumulator, current.val);
+            current = current.next;
+        }
+        return accumulator;
+    };
+    /**
+     * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
+     * @param {T | DoublyLinkedListNode<T>} 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 {T} 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.
+     */
+    DoublyLinkedList.prototype.insertAfter = function (existingValueOrNode, newValue) {
+        var existingNode;
+        if (existingValueOrNode instanceof (DoublyLinkedListNode)) {
+            existingNode = existingValueOrNode;
+        }
         else {
-            var prevNode = this.get(index - 1, 'node');
-            var removeNode = prevNode === null || prevNode === void 0 ? void 0 : prevNode.next;
-            var nextNode = removeNode === null || removeNode === void 0 ? void 0 : removeNode.next;
-            if (prevNode)
-                prevNode.next = nextNode !== null && nextNode !== void 0 ? nextNode : null;
-            if (nextNode)
-                nextNode.prev = prevNode;
-            if (removeNode)
-                removeNode.next = null;
-            if (removeNode)
-                removeNode.prev = null;
-            this._size--;
-            return (_c = removeNode === null || removeNode === void 0 ? void 0 : removeNode.val) !== null && _c !== void 0 ? _c : null;
+            existingNode = this.findNode(existingValueOrNode);
+        }
+        if (existingNode) {
+            var newNode = new DoublyLinkedListNode(newValue);
+            newNode.next = existingNode.next;
+            if (existingNode.next) {
+                existingNode.next.prev = newNode;
+            }
+            newNode.prev = existingNode;
+            existingNode.next = newNode;
+            if (existingNode === this.tail) {
+                this.tail = newNode;
+            }
+            this.length++;
+            return true;
+        }
+        return false;
+    };
+    /**
+     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * @param {T | DoublyLinkedListNode<T>} 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 {T} 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.
+     */
+    DoublyLinkedList.prototype.insertBefore = function (existingValueOrNode, newValue) {
+        var existingNode;
+        if (existingValueOrNode instanceof (DoublyLinkedListNode)) {
+            existingNode = existingValueOrNode;
         }
+        else {
+            existingNode = this.findNode(existingValueOrNode);
+        }
+        if (existingNode) {
+            var newNode = new DoublyLinkedListNode(newValue);
+            newNode.prev = existingNode.prev;
+            if (existingNode.prev) {
+                existingNode.prev.next = newNode;
+            }
+            newNode.next = existingNode;
+            existingNode.prev = newNode;
+            if (existingNode === this.head) {
+                this.head = newNode;
+            }
+            this.length++;
+            return true;
+        }
+        return false;
     };
     return DoublyLinkedList;
 }());