data-structure-typed 1.16.1 → 1.17.3

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

@@ -1,37 +1,14 @@
 "use strict";
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
+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];
@@ -49,36 +26,24 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-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.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SinglyLinkedList = exports.SinglyLinkedListNode = void 0;
-/* The SinglyLinkedListNode class represents a node in a singly linked list and provides methods for inserting, removing,
-and accessing nodes. */
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 var SinglyLinkedListNode = /** @class */ (function () {
-    function SinglyLinkedListNode(val, prev, next, list) {
+    /**
+     * The constructor function initializes an instance of a class with a given value and sets the next property to null.
+     * @param {T} val - The "val" parameter is of type T, which means it can be any data type. It represents the value that
+     * will be stored in the node of a linked list.
+     */
+    function SinglyLinkedListNode(val) {
         this._val = val;
-        this._prev = prev || null;
-        this._next = next || null;
-        this._list = list || null;
+        this._next = null;
     }
     Object.defineProperty(SinglyLinkedListNode.prototype, "val", {
         get: function () {
@@ -90,16 +55,6 @@ var SinglyLinkedListNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(SinglyLinkedListNode.prototype, "prev", {
-        get: function () {
-            return this._prev;
-        },
-        set: function (value) {
-            this._prev = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
     Object.defineProperty(SinglyLinkedListNode.prototype, "next", {
         get: function () {
             return this._next;
@@ -110,78 +65,17 @@ var SinglyLinkedListNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(SinglyLinkedListNode.prototype, "list", {
-        get: function () {
-            return this._list;
-        },
-        set: function (value) {
-            this._list = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SinglyLinkedListNode.prototype, "index", {
-        get: function () {
-            var _this = this;
-            if (!this.list) {
-                return undefined;
-            }
-            return this.list.findIndex(function (value) { return value === _this.val; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * The `insertBefore` function inserts a new node with the given value before the current node in a singly linked list.
-     * @param {NodeVal} val - The parameter "val" is of type "NodeVal". It represents the value of the node that you want
-     * to insert before the current node.
-     * @returns The method is returning a SinglyLinkedList<NodeVal>.
-     */
-    SinglyLinkedListNode.prototype.insertBefore = function (val) {
-        return this.list !== null
-            ? this.list.insertBefore(this, val)
-            : new SinglyLinkedList(val, this.val);
-    };
-    /**
-     * The function inserts a new node with the given value after the current node in a singly linked list.
-     * @param {NodeVal} val - The parameter `val` is the value of the node that you want to insert after the current node.
-     * @returns The method is returning a SinglyLinkedList<NodeVal>.
-     */
-    SinglyLinkedListNode.prototype.insertAfter = function (val) {
-        return this.list !== null
-            ? this.list.insertAfter(this, val)
-            : new SinglyLinkedList(this.val, val);
-    };
-    /**
-     * The `remove()` function removes a node from a singly linked list.
-     * @returns The remove() method is returning a SinglyLinkedListNode<NodeVal> object.
-     */
-    SinglyLinkedListNode.prototype.remove = function () {
-        if (this.list === null) {
-            throw new ReferenceError('Node does not belong to any list');
-        }
-        return this.list.removeNode(this);
-    };
     return SinglyLinkedListNode;
 }());
 exports.SinglyLinkedListNode = SinglyLinkedListNode;
 var SinglyLinkedList = /** @class */ (function () {
     /**
-     * The constructor initializes a linked list with the given arguments as nodes.
-     * @param {NodeVal[]} args - args is a rest parameter that allows the constructor to accept an arbitrary number of
-     * arguments of type NodeVal.
+     * The constructor initializes the linked list with an empty head, tail, and length.
      */
     function SinglyLinkedList() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
         this._head = null;
         this._tail = null;
-        this._size = 0;
-        for (var i = 0; i < arguments.length; i++) {
-            this.append(args[i]);
-        }
+        this._length = 0;
     }
     Object.defineProperty(SinglyLinkedList.prototype, "head", {
         get: function () {
@@ -203,583 +97,408 @@ var SinglyLinkedList = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(SinglyLinkedList.prototype, "size", {
+    Object.defineProperty(SinglyLinkedList.prototype, "length", {
         get: function () {
-            return this._size;
+            return this._length;
         },
         set: function (value) {
-            this._size = value;
+            this._length = value;
         },
         enumerable: false,
         configurable: true
     });
     /**
-     * The `from` function in TypeScript creates a new SinglyLinkedList instance from an iterable object.
-     * @param iterable - The `iterable` parameter is an object that can be iterated over, such as an array or a string. It
-     * contains a collection of elements of type `T`.
-     * @returns The method is returning a new instance of the SinglyLinkedList class.
-     */
-    SinglyLinkedList.from = function (iterable) {
-        return new (SinglyLinkedList.bind.apply(SinglyLinkedList, __spreadArray([void 0], __read(iterable), false)))();
-    };
-    /**
-     * The `get` function returns the value of a node at a given index in a data structure.
-     * @param {number} index - The index parameter is a number that represents the position of the node in the data
-     * structure.
-     * @returns The method is returning the value of the node at the specified index if the node exists, otherwise it
-     * returns undefined.
-     */
-    SinglyLinkedList.prototype.get = function (index) {
-        var node = this.getNode(index);
-        return node !== undefined ? node.val : undefined;
-    };
-    /**
-     * The function `getNode` returns the node at a given index in a singly linked list.
-     * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
-     * retrieve from the linked list.
-     * @returns a SinglyLinkedListNode<NodeVal> object or undefined.
-     */
-    SinglyLinkedList.prototype.getNode = function (index) {
-        if (this.head === null || index < 0 || index >= this.size) {
-            return undefined;
-        }
-        var asc = index < this.size / 2;
-        var stopAt = asc ? index : this.size - index - 1;
-        var nextNode = asc ? 'next' : 'prev';
-        var currentNode = asc ? this.head : this.tail;
-        // TODO after no-non-null-assertion not ensure the logic
-        for (var currentIndex = 0; currentIndex < stopAt; currentIndex++) {
-            if (currentNode) {
-                currentNode = currentNode[nextNode];
-            }
-        }
-        return currentNode || undefined;
-    };
-    /**
-     * The function `findNodeIndex` searches for a node in a singly linked list that satisfies a given condition and
-     * returns its index and the node itself.
-     * @param callbackFn - The callbackFn parameter is a function that takes three arguments: data, index, and list. It is
-     * used to determine whether a node in the singly linked list matches a certain condition. The function should return a
-     * boolean value indicating whether the condition is met for the given node.
-     * @returns The function `findNodeIndex` returns an object with two properties: `node` and `index`. The `node` property
-     * contains the node that matches the condition specified in the `callbackFn` function, and the `index` property
-     * contains the index of that node in the linked list. If no node matches the condition, the function returns
-     * `undefined`.
-     */
-    SinglyLinkedList.prototype.findNodeIndex = function (callbackFn) {
-        var currentIndex = 0;
-        var currentNode = this.head;
-        while (currentNode) {
-            if (callbackFn(currentNode.val, currentIndex, this)) {
-                return {
-                    index: currentIndex,
-                    node: currentNode,
-                };
-            }
-            currentNode = currentNode.next;
-            currentIndex += 1;
-        }
-        return undefined;
-    };
-    /**
-     * The findNode function searches for a node in a singly linked list based on a given callback function.
-     * @param callbackFn - A callback function that takes three parameters: data, index, and list. It returns a boolean
-     * value indicating whether the current node matches the desired criteria.
-     * @returns The function `findNode` returns a `SinglyLinkedListNode<NodeVal>` if a node satisfying the condition
-     * specified by the `callbackFn` is found in the linked list. If no such node is found, it returns `undefined`.
-     */
-    SinglyLinkedList.prototype.findNode = function (callbackFn) {
-        var nodeIndex = this.findNodeIndex(callbackFn);
-        return nodeIndex !== undefined ? nodeIndex.node : undefined;
-    };
-    /**
-     * The `find` function in TypeScript searches for a node in a singly linked list based on a given callback function and
-     * returns the value of the found node.
-     * @param callbackFn - A callback function that takes three parameters: data, index, and list. It returns a boolean
-     * value indicating whether the condition is met for a particular node in the linked list.
-     * @returns The method `find` returns the `NodeVal` value of the first node in the linked list that satisfies the
-     * condition specified by the `callbackFn` function. If no node satisfies the condition, it returns `undefined`.
+     * The `fromArray` function creates a new SinglyLinkedList instance 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 `SinglyLinkedList` object.
      */
-    SinglyLinkedList.prototype.find = function (callbackFn) {
-        var nodeIndex = this.findNodeIndex(callbackFn);
-        return nodeIndex !== undefined ? nodeIndex.node.val : undefined;
-    };
-    /**
-     * The findIndex function returns the index of the first node in a singly linked list that satisfies a given condition,
-     * or -1 if no such node is found.
-     * @param callbackFn - A callback function that takes three parameters: data, index, and list. It returns a boolean
-     * value indicating whether the condition is met for a particular node in the singly linked list.
-     * @returns The method `findIndex` returns a number.
-     */
-    SinglyLinkedList.prototype.findIndex = function (callbackFn) {
-        var nodeIndex = this.findNodeIndex(callbackFn);
-        return nodeIndex !== undefined ? nodeIndex.index : -1;
-    };
-    /* The above code is a comment in TypeScript. It is using the triple hash symbol ( */
-    SinglyLinkedList.prototype.append = function () {
+    SinglyLinkedList.fromArray = function (data) {
         var e_1, _a;
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
+        var singlyLinkedList = new SinglyLinkedList();
         try {
-            for (var args_1 = __values(args), args_1_1 = args_1.next(); !args_1_1.done; args_1_1 = args_1.next()) {
-                var val = args_1_1.value;
-                var node = new SinglyLinkedListNode(val, this.tail, null, this);
-                if (this.head === null) {
-                    this.head = node;
-                }
-                if (this.tail !== null) {
-                    this.tail.next = node;
-                }
-                this.tail = node;
-                this.size += 1;
+            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;
+                singlyLinkedList.push(item);
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (args_1_1 && !args_1_1.done && (_a = args_1.return)) _a.call(args_1);
+                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 this;
+        return singlyLinkedList;
     };
-    /**
-     * The push function appends multiple NodeVal objects to a data structure and returns the new size of the data
-     * structure.
-     * @param {NodeVal[]} args - args is a rest parameter of type NodeVal[]. It allows the function to accept any number
-     * of arguments of type NodeVal.
-     * @returns The size of the data structure after the nodes are appended.
-     */
-    SinglyLinkedList.prototype.push = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        this.append.apply(this, __spreadArray([], __read(args), false));
-        return this.size;
+    SinglyLinkedList.prototype.getLength = function () {
+        return this._length;
     };
     /**
-     * The `prepend` function adds new nodes to the beginning of a singly linked list.
-     * @param {NodeVal[]} args - An array of NodeVal objects.
-     * @returns The `prepend` method is returning the updated `SinglyLinkedList` object.
+     * The `push` function adds a new node with the given data to the end of a singly linked list.
+     * @param {T} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
+     * any type (T) as specified in the generic type declaration of the class or function.
      */
-    SinglyLinkedList.prototype.prepend = function () {
-        var e_2, _a;
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
+    SinglyLinkedList.prototype.push = function (data) {
+        var newNode = new SinglyLinkedListNode(data);
+        if (!this.head) {
+            this.head = newNode;
+            this.tail = newNode;
         }
-        var reverseArgs = Array.from(args).reverse();
-        try {
-            for (var reverseArgs_1 = __values(reverseArgs), reverseArgs_1_1 = reverseArgs_1.next(); !reverseArgs_1_1.done; reverseArgs_1_1 = reverseArgs_1.next()) {
-                var val = reverseArgs_1_1.value;
-                var node = new SinglyLinkedListNode(val, null, this.head, this);
-                if (this.tail === null) {
-                    this.tail = node;
-                }
-                if (this.head !== null) {
-                    this.head.prev = node;
-                }
-                this.head = node;
-                this.size += 1;
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (reverseArgs_1_1 && !reverseArgs_1_1.done && (_a = reverseArgs_1.return)) _a.call(reverseArgs_1);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return this;
-    };
-    /**
-     * The `insertAt` function inserts a value at a specified index in a singly linked list.
-     * @param {number} index - The index parameter is a number that represents the position at which the new node should be
-     * inserted in the linked list.
-     * @param {NodeVal} val - The `val` parameter represents the value of the node that you want to insert into the linked
-     * list.
-     * @returns The method `insertAt` returns the updated `SinglyLinkedList` object.
-     */
-    SinglyLinkedList.prototype.insertAt = function (index, val) {
-        if (this.head === null) {
-            return this.append(val);
-        }
-        if (index <= 0) {
-            return this.prepend(val);
-        }
-        var currentNode = this.head;
-        var currentIndex = 0;
-        while (currentIndex < index - 1 && currentNode.next !== null) {
-            currentIndex += 1;
-            currentNode = currentNode.next;
+        else {
+            this.tail.next = newNode;
+            this.tail = newNode;
         }
-        currentNode.insertAfter(val);
-        return this;
+        this.length++;
     };
     /**
-     * The removeNode function removes a node from a singly linked list and updates the head, tail, and size properties
-     * accordingly.
-     * @param node - The `node` parameter is of type `SinglyLinkedListNode<NodeVal>`, which represents a node in a singly
-     * linked list.
-     * @returns the removed node.
+     * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
+     * pointers accordingly.
+     * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
+     * the linked list is empty, it returns `null`.
      */
-    SinglyLinkedList.prototype.removeNode = function (node) {
-        if (node.list !== this) {
-            throw new ReferenceError('Node does not belong to this list');
-        }
-        if (node.prev !== null) {
-            node.prev.next = node.next;
-        }
-        if (node.next !== null) {
-            node.next.prev = node.prev;
-        }
-        if (this.head === node) {
-            this.head = node.next;
+    SinglyLinkedList.prototype.pop = function () {
+        if (!this.head)
+            return null;
+        if (this.head === this.tail) {
+            var val_1 = this.head.val;
+            this.head = null;
+            this.tail = null;
+            this.length--;
+            return val_1;
         }
-        if (this.tail === node) {
-            this.tail = node.prev;
+        var current = this.head;
+        while (current.next !== this.tail) {
+            current = current.next;
         }
-        this.size -= 1;
-        node.next = null;
-        node.prev = null;
-        node.list = null;
-        return node;
+        var val = this.tail.val;
+        current.next = null;
+        this.tail = current;
+        this.length--;
+        return val;
     };
     /**
-     * The `removeAt` function removes a node at a specified index from a singly linked list.
-     * @param {number} index - The index parameter is a number that represents the position of the node to be removed in
-     * the singly linked list.
-     * @returns The method `removeAt` returns a `SinglyLinkedListNode<NodeVal>` if the node at the specified index is
-     * found and removed successfully. If the node is not found, it returns `undefined`.
+     * The `shift()` function removes and returns the value of the first node in a linked list.
+     * @returns The value of the node that is being removed from the beginning of the linked list.
      */
-    SinglyLinkedList.prototype.removeAt = function (index) {
-        var node = this.getNode(index);
-        return node !== undefined ? this.removeNode(node) : undefined;
+    SinglyLinkedList.prototype.shift = function () {
+        if (!this.head)
+            return null;
+        var removedNode = this.head;
+        this.head = this.head.next;
+        this.length--;
+        return removedNode.val;
     };
     /**
-     * The `insertBefore` function inserts a new node with a given value before a specified reference node in a singly
+     * The unshift function adds a new node with the given value to the beginning of a singly linked list.
+     * @param {T} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
      * linked list.
-     * @param referenceNode - The referenceNode parameter is the node in the linked list before which the new node will be
-     * inserted.
-     * @param {NodeVal} val - The value of the new node that will be inserted before the reference node.
-     * @returns The method is returning the updated SinglyLinkedList object.
      */
-    SinglyLinkedList.prototype.insertBefore = function (referenceNode, val) {
-        var node = new SinglyLinkedListNode(val, referenceNode.prev, referenceNode, this);
-        if (referenceNode.prev === null) {
-            this.head = node;
+    SinglyLinkedList.prototype.unshift = function (val) {
+        var newNode = new SinglyLinkedListNode(val);
+        if (!this.head) {
+            this.head = newNode;
+            this.tail = newNode;
         }
-        if (referenceNode.prev !== null) {
-            referenceNode.prev.next = node;
+        else {
+            newNode.next = this.head;
+            this.head = newNode;
         }
-        referenceNode.prev = node;
-        this.size += 1;
-        return this;
+        this.length++;
     };
     /**
-     * The `sort` function uses the quicksort algorithm to sort the elements of a singly linked list based on a provided
-     * comparison function.
-     * @param start - The `start` parameter is the starting node of the sublist that needs to be sorted.
-     * @param end - The `end` parameter is a reference to the last node in the linked list. It is used as the pivot element
-     * for the quicksort algorithm.
-     * @returns The `sort` method is returning the sorted `SinglyLinkedList` object.
+     * The function `getAt` returns the value at a specified index in a 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 element we want to
+     * retrieve from the list.
+     * @returns The method `getAt(index: number): T | null` returns the value at the specified index in the linked list, or
+     * `null` if the index is out of bounds.
      */
-    SinglyLinkedList.prototype.sort = function (compare) {
-        if (this.head === null || this.tail === null) {
-            return this;
+    SinglyLinkedList.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;
         }
-        if (this.size < 2) {
-            return this;
+        return current.val;
+    };
+    /**
+     * The function `getNodeAt` returns the node at a given index in a singly linked list.
+     * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
+     * retrieve from the linked list. It indicates the zero-based index of the node we want to access.
+     * @returns The method `getNodeAt(index: number)` returns a `SinglyLinkedListNode<T>` object if the node at the
+     * specified index exists, or `null` if the index is out of bounds.
+     */
+    SinglyLinkedList.prototype.getNodeAt = function (index) {
+        var current = this.head;
+        for (var i = 0; i < index; i++) {
+            current = current.next;
+        }
+        return current;
+    };
+    /**
+     * 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.
+     */
+    SinglyLinkedList.prototype.deleteAt = function (index) {
+        if (index < 0 || index >= this.length)
+            return null;
+        if (index === 0)
+            return this.shift();
+        if (index === this.length - 1)
+            return this.pop();
+        var prevNode = this.getNodeAt(index - 1);
+        var removedNode = prevNode.next;
+        prevNode.next = removedNode.next;
+        this.length--;
+        return removedNode.val;
+    };
+    /**
+     * The delete function removes a node with a specific value from a singly linked list.
+     * @param {T | SinglyLinkedListNode<T>} valueOrNode - The `valueOrNode` parameter can accept either a value of type `T`
+     * or a `SinglyLinkedListNode<T>` 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.
+     */
+    SinglyLinkedList.prototype.delete = function (valueOrNode) {
+        var value;
+        if (valueOrNode instanceof (SinglyLinkedListNode)) {
+            value = valueOrNode.val;
         }
-        var quicksort = function (start, end) {
-            if (start === end) {
-                return;
-            }
-            var pivotData = end.val;
-            var current = start;
-            var split = start;
-            while (current && current !== end) {
-                var sort = compare(current.val, pivotData);
-                if (sort) {
-                    if (current !== split) {
-                        var temp = split.val;
-                        split.val = current.val;
-                        current.val = temp;
+        else {
+            value = valueOrNode;
+        }
+        var current = this.head, prev = null;
+        while (current) {
+            if (current.val === value) {
+                if (prev === null) {
+                    this.head = current.next;
+                    if (current === this.tail) {
+                        this.tail = null;
                     }
-                    // TODO after no-non-null-assertion not ensure the logic
-                    if (split.next) {
-                        split = split.next;
+                }
+                else {
+                    prev.next = current.next;
+                    if (current === this.tail) {
+                        this.tail = prev;
                     }
                 }
-                current = current.next;
-            }
-            end.val = split.val;
-            split.val = pivotData;
-            if (start.next === end.prev) {
-                return;
-            }
-            if (split.prev && split !== start) {
-                quicksort(start, split.prev);
+                this.length--;
+                return true;
             }
-            if (split.next && split !== end) {
-                quicksort(split.next, end);
-            }
-        };
-        quicksort(this.head, this.tail);
-        return this;
+            prev = current;
+            current = current.next;
+        }
+        return false;
     };
     /**
-     * The `insertAfter` function inserts a new node with a given value after a specified reference node in a singly linked
-     * list.
-     * @param referenceNode - The referenceNode parameter is the node after which the new node will be inserted.
-     * @param {NodeVal} val - The value of the new node that will be inserted after the reference node.
-     * @returns The `insertAfter` method is returning the updated `SinglyLinkedList` object.
+     * The `insertAt` 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 {T} val - The `val` 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.
      */
-    SinglyLinkedList.prototype.insertAfter = function (referenceNode, val) {
-        var node = new SinglyLinkedListNode(val, referenceNode, referenceNode.next, this);
-        if (referenceNode.next === null) {
-            this.tail = node;
+    SinglyLinkedList.prototype.insertAt = function (index, val) {
+        if (index < 0 || index > this.length)
+            return false;
+        if (index === 0) {
+            this.unshift(val);
+            return true;
         }
-        if (referenceNode.next !== null) {
-            referenceNode.next.prev = node;
+        if (index === this.length) {
+            this.push(val);
+            return true;
         }
-        referenceNode.next = node;
-        this.size += 1;
-        return this;
-    };
-    /**
-     * The `shift()` function removes and returns the first element from a linked list.
-     * @returns The `shift()` method is returning a value of type `NodeVal` or `undefined`.
-     */
-    SinglyLinkedList.prototype.shift = function () {
-        return this.removeFromAnyEnd(this.head);
+        var newNode = new SinglyLinkedListNode(val);
+        var prevNode = this.getNodeAt(index - 1);
+        newNode.next = prevNode.next;
+        prevNode.next = newNode;
+        this.length++;
+        return true;
     };
     /**
-     * The `pop()` function removes and returns the last element from a linked list.
-     * @returns The `pop()` method is returning a value of type `NodeVal` or `undefined`.
+     * The function checks if the length of a data structure is equal to zero and returns a boolean value indicating
+     * whether it is empty or not.
+     * @returns A boolean value indicating whether the length of the object is equal to 0.
      */
-    SinglyLinkedList.prototype.pop = function () {
-        return this.removeFromAnyEnd(this.tail);
-    };
-    /**
-     * The merge function merges two singly linked lists by updating the next and prev pointers, as well as the head, tail,
-     * and size properties.
-     * @param list - The parameter "list" is a SinglyLinkedList object that contains nodes with data of type NodeVal.
-     */
-    SinglyLinkedList.prototype.merge = function (list) {
-        if (this.tail !== null) {
-            this.tail.next = list.head;
-        }
-        if (list.head !== null) {
-            list.head.prev = this.tail;
-        }
-        this.head = this.head || list.head;
-        this.tail = list.tail || this.tail;
-        this.size += list.size;
-        list.size = this.size;
-        list.head = this.head;
-        list.tail = this.tail;
+    SinglyLinkedList.prototype.isEmpty = function () {
+        return this.length === 0;
     };
     /**
-     * The clear() function resets the linked list by setting the head and tail to null and the size to 0.
-     * @returns The "this" object is being returned.
+     * The `clear` function resets the linked list by setting the head, tail, and length to null and 0 respectively.
      */
     SinglyLinkedList.prototype.clear = function () {
-        this.head = null;
-        this.tail = null;
-        this.size = 0;
-        return this;
+        this._head = null;
+        this._tail = null;
+        this._length = 0;
     };
     /**
-     * The `slice` function returns a new SinglyLinkedList containing a portion of the original list, starting from the
-     * specified index and ending at the optional end index.
-     * @param {number} start - The `start` parameter is a number that represents the index at which to start slicing the
-     * linked list.
-     * @param {number} [end] - The `end` parameter is an optional number that specifies the index at which to end the
-     * slicing. If no value is provided for `end`, or if the provided value is less than the `start` index, the slicing
-     * will continue until the end of the list.
-     * @returns a new SinglyLinkedList containing the sliced elements from the original list.
+     * The `toArray` function converts a linked list into an array.
+     * @returns The `toArray()` method is returning an array of type `T[]`.
      */
-    SinglyLinkedList.prototype.slice = function (start, end) {
-        var list = new SinglyLinkedList();
-        var finish = end;
-        if (this.head === null || this.tail === null) {
-            return list;
-        }
-        if (finish === undefined || finish < start) {
-            finish = this.size;
-        }
-        var head = this.getNode(start);
-        for (var i = 0; i < finish - start && head !== null && head !== undefined; i++) {
-            list.append(head.val);
-            head = head.next;
+    SinglyLinkedList.prototype.toArray = function () {
+        var array = [];
+        var current = this.head;
+        while (current) {
+            array.push(current.val);
+            current = current.next;
         }
-        return list;
+        return array;
     };
     /**
-     * The reverse() function reverses the order of nodes in a singly linked list.
-     * @returns The reverse() method is returning the reversed SinglyLinkedList.
+     * The `reverse` function reverses the order of the nodes in a singly linked list.
+     * @returns The reverse() method does not return anything. It has a return type of void.
      */
     SinglyLinkedList.prototype.reverse = function () {
-        var currentNode = this.head;
-        while (currentNode) {
-            var next = currentNode.next;
-            currentNode.next = currentNode.prev;
-            currentNode.prev = next;
-            currentNode = currentNode.prev;
+        var _a;
+        if (!this.head || this.head === this.tail)
+            return;
+        var prev = null;
+        var current = this.head;
+        var next = null;
+        while (current) {
+            next = current.next;
+            current.next = prev;
+            prev = current;
+            current = next;
+        }
+        _a = __read([this.tail, this.head], 2), this.head = _a[0], this.tail = _a[1];
+    };
+    /**
+     * 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`.
+     */
+    SinglyLinkedList.prototype.find = function (callback) {
+        var current = this.head;
+        while (current) {
+            if (callback(current.val)) {
+                return current.val;
+            }
+            current = current.next;
         }
-        var tail = this.tail;
-        this.tail = this.head;
-        this.head = tail;
-        return this;
+        return null;
     };
     /**
-     * The `forEach` function iterates over a singly linked list and applies a callback function to each node, either in
-     * forward or reverse order.
-     * @param callbackFn - A callback function that will be called for each element in the linked list. It takes three
-     * parameters:
-     * @param [reverse=false] - A boolean value indicating whether to iterate over the linked list in reverse order. If set
-     * to true, the iteration will start from the tail of the linked list and move towards the head. If set to false
-     * (default), the iteration will start from the head and move towards the tail.
+     * The `indexOf` function returns the index of the first occurrence of a given value in a linked list.
+     * @param {T} 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.
      */
-    SinglyLinkedList.prototype.forEach = function (callbackFn, reverse) {
-        if (reverse === void 0) { reverse = false; }
-        var currentIndex = reverse ? this.size - 1 : 0;
-        var currentNode = reverse ? this.tail : this.head;
-        var modifier = reverse ? -1 : 1;
-        var nextNode = reverse ? 'prev' : 'next';
-        while (currentNode) {
-            callbackFn(currentNode.val, currentIndex, this);
-            currentNode = currentNode[nextNode];
-            currentIndex += modifier;
+    SinglyLinkedList.prototype.indexOf = function (value) {
+        var index = 0;
+        var current = this.head;
+        while (current) {
+            if (current.val === value) {
+                return index;
+            }
+            index++;
+            current = current.next;
         }
+        return -1;
     };
     /**
-     * The map function takes a callback function and applies it to each element in the linked list, returning a new linked
-     * list with the results.
-     * @param callbackFn - A callback function that will be applied to each element in the linked list. It takes three
-     * parameters:
-     * @param [reverse=false] - The `reverse` parameter is a boolean value that determines whether the mapping should be
-     * done in reverse order or not. If `reverse` is set to `true`, the mapping will be done in reverse order. If `reverse`
-     * is set to `false` or not provided, the mapping will be
-     * @returns The `map` function is returning a new `SinglyLinkedList` object.
-     */
-    SinglyLinkedList.prototype.map = function (callbackFn, reverse) {
-        var _this = this;
-        if (reverse === void 0) { reverse = false; }
-        var list = new SinglyLinkedList();
-        this.forEach(function (val, index) { return list.append(callbackFn(val, index, _this)); }, reverse);
-        return list;
-    };
-    /**
-     * The `filter` function filters the elements of a singly linked list based on a given callback function.
-     * @param callbackFn - A callback function that takes three parameters: data, index, and list. It should return a
-     * boolean value indicating whether the current element should be included in the filtered list or not.
-     * @param [reverse=false] - The `reverse` parameter is a boolean value that determines whether the filtered list should
-     * be reversed or not. If `reverse` is set to `true`, the filtered list will be in reverse order. If `reverse` is set
-     * to `false` or not provided, the filtered list will be in
-     * @returns The `filter` method is returning a new `SinglyLinkedList` object.
+     * The function finds a node in a singly linked list by its value and returns the node if found, otherwise returns
+     * null.
+     * @param {T} value - The value parameter is the value that we want to search for in the linked list.
+     * @returns a `SinglyLinkedListNode<T>` 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 `null`.
      */
-    SinglyLinkedList.prototype.filter = function (callbackFn, reverse) {
-        var _this = this;
-        if (reverse === void 0) { reverse = false; }
-        var list = new SinglyLinkedList();
-        this.forEach(function (val, index) {
-            if (callbackFn(val, index, _this)) {
-                list.append(val);
+    SinglyLinkedList.prototype.findNode = function (value) {
+        var current = this.head;
+        while (current) {
+            if (current.val === value) {
+                return current;
             }
-        }, reverse);
-        return list;
+            current = current.next;
+        }
+        return null;
     };
     /**
-     * The `reduce` function iterates over a singly linked list and applies a callback function to each element,
-     * accumulating a single value.
-     * @param callbackFn - A callback function that will be called for each element in the linked list. It takes four
-     * parameters:
-     * @param {any} [start] - The `start` parameter is an optional initial value for the accumulator. If provided, the
-     * `reduce` function will start accumulating from this value. If not provided, the `reduce` function will use the value
-     * of the first element in the linked list as the initial value.
-     * @param [reverse=false] - A boolean value indicating whether to iterate over the linked list in reverse order. If set
-     * to true, the iteration will start from the tail of the linked list and move towards the head. If set to false
-     * (default), the iteration will start from the head and move towards the tail.
-     * @returns The `reduce` method returns the accumulated value after applying the callback function to each element in
-     * the linked list.
+     * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
+     * @param {T | SinglyLinkedListNode<T>} 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 {T} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
+     * @returns The method `insertBefore` returns a boolean value. It returns `true` if the new value was successfully
+     * inserted before the existing value, and `false` otherwise.
      */
-    SinglyLinkedList.prototype.reduce = function (callbackFn, start, reverse) {
-        if (reverse === void 0) { reverse = false; }
-        var currentIndex = reverse ? this.size - 1 : 0;
-        var modifier = reverse ? -1 : 1;
-        var nextNode = reverse ? 'prev' : 'next';
-        var currentElement = reverse ? this.tail : this.head;
-        var result;
-        if (start !== undefined) {
-            result = start;
-        }
-        else if (currentElement) {
-            result = currentElement.val;
-            currentElement = currentElement[nextNode];
+    SinglyLinkedList.prototype.insertBefore = function (existingValueOrNode, newValue) {
+        if (!this.head)
+            return false;
+        var existingValue;
+        if (existingValueOrNode instanceof (SinglyLinkedListNode)) {
+            existingValue = existingValueOrNode.val;
         }
         else {
-            throw new TypeError('Reduce of empty LinkedList with no initial value');
-        }
-        while (currentElement) {
-            result = callbackFn(result, currentElement.val, currentIndex, this);
-            currentIndex += modifier;
-            currentElement = currentElement[nextNode];
+            existingValue = existingValueOrNode;
+        }
+        if (this.head.val === existingValue) {
+            this.unshift(newValue);
+            return true;
+        }
+        var current = this.head;
+        while (current.next) {
+            if (current.next.val === existingValue) {
+                var newNode = new SinglyLinkedListNode(newValue);
+                newNode.next = current.next;
+                current.next = newNode;
+                this.length++;
+                return true;
+            }
+            current = current.next;
         }
-        return result;
-    };
-    /**
-     * The toArray() function converts a NodeVal object into an array of NodeVal objects.
-     * @returns An array of NodeVal objects.
-     */
-    SinglyLinkedList.prototype.toArray = function () {
-        return __spreadArray([], __read(this), false);
-    };
-    /**
-     * The `toString` function takes an optional separator and returns a string representation of an array, with each
-     * element separated by the specified separator.
-     * @param [separator= ] - The separator parameter is a string that specifies the character(s) to be used as a separator
-     * between each element in the array when converting it to a string. By default, the separator is set to a space
-     * character (' ').
-     * @returns The toString method is being returned as a string.
-     */
-    SinglyLinkedList.prototype.toString = function (separator) {
-        if (separator === void 0) { separator = ' '; }
-        return this.reduce(function (s, val) { return "".concat(s).concat(separator).concat(val); });
+        return false;
     };
     /**
-     * The function is an iterator that returns the values of each node in a linked list.
+     * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
+     * @param {T | SinglyLinkedListNode<T>} 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 {T} 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.
      */
-    SinglyLinkedList.prototype[Symbol.iterator] = function () {
-        var element;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    element = this.head;
-                    _a.label = 1;
-                case 1:
-                    if (!(element !== null)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, element.val];
-                case 2:
-                    _a.sent();
-                    element = element.next;
-                    return [3 /*break*/, 1];
-                case 3: return [2 /*return*/];
+    SinglyLinkedList.prototype.insertAfter = function (existingValueOrNode, newValue) {
+        var existingNode;
+        if (existingValueOrNode instanceof SinglyLinkedListNode) {
+            existingNode = existingValueOrNode;
+        }
+        else {
+            existingNode = this.findNode(existingValueOrNode);
+        }
+        if (existingNode) {
+            var newNode = new SinglyLinkedListNode(newValue);
+            newNode.next = existingNode.next;
+            existingNode.next = newNode;
+            if (existingNode === this.tail) {
+                this.tail = newNode;
             }
-        });
+            this.length++;
+            return true;
+        }
+        return false;
     };
     /**
-     * The function removes a node from either end of a singly linked list and returns its value.
-     * @param {SinglyLinkedListNode<NodeVal> | null} node - The `node` parameter is a reference to a node in a singly
-     * linked list. It can be either a `SinglyLinkedListNode` object or `null`.
-     * @returns The value of the removed node if the node is not null, otherwise undefined.
+     * The function counts the number of occurrences of a given value in a linked list.
+     * @param {T} 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.
      */
-    SinglyLinkedList.prototype.removeFromAnyEnd = function (node) {
-        return node !== null ? this.removeNode(node).val : undefined;
+    SinglyLinkedList.prototype.countOccurrences = function (value) {
+        var count = 0;
+        var current = this.head;
+        while (current) {
+            if (current.val === value) {
+                count++;
+            }
+            current = current.next;
+        }
+        return count;
     };
     return SinglyLinkedList;
 }());