data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,4 +1,71 @@
 "use strict";
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+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 __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;
+};
+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;
 /**
@@ -7,8 +74,8 @@ exports.SinglyLinkedList = exports.SinglyLinkedListNode = void 0;
  * const node = new SinglyLinkedListNode(1, null, null, null);
  * ```
  */
-class SinglyLinkedListNode {
-    constructor(
+var SinglyLinkedListNode = /** @class */ (function () {
+    function SinglyLinkedListNode(
     /** Data stored on the node */
     val, 
     /** The previous node in the list */
@@ -22,27 +89,36 @@ class SinglyLinkedListNode {
         this.next = next;
         this.list = list;
     }
-    /**
-     * Alias to .val
-     * ```ts
-     * new LinkedList(1, 2, 3).head.value; // 1
-     * ```
-     */
-    get value() {
-        return this.val;
-    }
-    /**
-     * Get the index of this node
-     * ```ts
-     * new LinkedList(1, 2, 3).head.index; // 0
-     * ```
-     */
-    get index() {
-        if (!this.list) {
-            return undefined;
-        }
-        return this.list.findIndex((value) => value === this.value);
-    }
+    Object.defineProperty(SinglyLinkedListNode.prototype, "value", {
+        /**
+         * Alias to .val
+         * ```ts
+         * new LinkedList(1, 2, 3).head.value; // 1
+         * ```
+         */
+        get: function () {
+            return this.val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SinglyLinkedListNode.prototype, "index", {
+        /**
+         * Get the index of this node
+         * ```ts
+         * new LinkedList(1, 2, 3).head.index; // 0
+         * ```
+         */
+        get: function () {
+            var _this = this;
+            if (!this.list) {
+                return undefined;
+            }
+            return this.list.findIndex(function (value) { return value === _this.value; });
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Insert a new node before this one
      * ```ts
@@ -50,11 +126,11 @@ class SinglyLinkedListNode {
      * ```
      * @param val Data to save in the node
      */
-    insertBefore(val) {
+    SinglyLinkedListNode.prototype.insertBefore = function (val) {
         return this.list !== null
             ? this.list.insertBefore(this, val)
             : new SinglyLinkedList(val, this.val);
-    }
+    };
     /**
      * Insert new val after this node
      * ```ts
@@ -62,24 +138,25 @@ class SinglyLinkedListNode {
      * ```
      * @param val Data to be saved in the node
      */
-    insertAfter(val) {
+    SinglyLinkedListNode.prototype.insertAfter = function (val) {
         return this.list !== null
             ? this.list.insertAfter(this, val)
             : new SinglyLinkedList(this.val, val);
-    }
+    };
     /**
      * Remove this node
      * ```ts
      * new LinkedList(1, 2, 3, 4).tail.remove(); // 1 <=> 2 <=> 3
      * ```
      */
-    remove() {
+    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;
 /**
  * A doubly linked list
@@ -88,13 +165,29 @@ exports.SinglyLinkedListNode = SinglyLinkedListNode;
  * const listFromArray = LinkedList.from([1, 2, 3]);
  * ```
  */
-class SinglyLinkedList {
-    /**
-     * The length of the list
-     */
-    get length() {
-        return this.size;
+var SinglyLinkedList = /** @class */ (function () {
+    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]);
+        }
     }
+    Object.defineProperty(SinglyLinkedList.prototype, "length", {
+        /**
+         * The length of the list
+         */
+        get: function () {
+            return this.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Convert any iterable to a new linked list
      * ```javascript
@@ -103,17 +196,9 @@ class SinglyLinkedList {
      * ```
      * @param iterable Any iterable datatype like Array or Map
      */
-    static from(iterable) {
-        return new SinglyLinkedList(...iterable);
-    }
-    constructor(...args) {
-        this.head = null;
-        this.tail = null;
-        this.size = 0;
-        for (let i = 0; i < arguments.length; i++) {
-            this.append(args[i]);
-        }
-    }
+    SinglyLinkedList.from = function (iterable) {
+        return new (SinglyLinkedList.bind.apply(SinglyLinkedList, __spreadArray([void 0], __read(iterable), false)))();
+    };
     /**
      * Get the node val at a specified index, zero based
      * ```ts
@@ -121,10 +206,10 @@ class SinglyLinkedList {
      * ```
      * @param index to retrieve val at
      */
-    get(index) {
-        const node = this.getNode(index);
+    SinglyLinkedList.prototype.get = function (index) {
+        var node = this.getNode(index);
         return node !== undefined ? node.val : undefined;
-    }
+    };
     /**
      * Get the node at index, zero based
      * ```ts
@@ -132,22 +217,22 @@ class SinglyLinkedList {
      * // { prev: null, val: 1, next: SinglyLinkedListNode }
      * ```
      */
-    getNode(index) {
+    SinglyLinkedList.prototype.getNode = function (index) {
         if (this.head === null || index < 0 || index >= this.length) {
             return undefined;
         }
-        const asc = index < this.length / 2;
-        const stopAt = asc ? index : this.length - index - 1;
-        const nextNode = asc ? 'next' : 'prev';
-        let currentNode = asc ? this.head : this.tail;
+        var asc = index < this.length / 2;
+        var stopAt = asc ? index : this.length - 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 (let currentIndex = 0; currentIndex < stopAt; currentIndex++) {
+        for (var currentIndex = 0; currentIndex < stopAt; currentIndex++) {
             if (currentNode) {
                 currentNode = currentNode[nextNode];
             }
         }
         return currentNode || undefined;
-    }
+    };
     /**
      * Return the first node and its index in the list that
      * satisfies the testing function
@@ -157,9 +242,9 @@ class SinglyLinkedList {
      * ```
      * @param f A function to be applied to the val of each node
      */
-    findNodeIndex(f) {
-        let currentIndex = 0;
-        let currentNode = this.head;
+    SinglyLinkedList.prototype.findNodeIndex = function (f) {
+        var currentIndex = 0;
+        var currentNode = this.head;
         while (currentNode) {
             if (f(currentNode.val, currentIndex, this)) {
                 return {
@@ -171,7 +256,7 @@ class SinglyLinkedList {
             currentIndex += 1;
         }
         return undefined;
-    }
+    };
     /**
      * Returns the first node in the list that
      * satisfies the provided testing function. Otherwise undefined is returned.
@@ -181,10 +266,10 @@ class SinglyLinkedList {
      * ```
      * @param f Function to test val against
      */
-    findNode(f) {
-        const nodeIndex = this.findNodeIndex(f);
+    SinglyLinkedList.prototype.findNode = function (f) {
+        var nodeIndex = this.findNodeIndex(f);
         return nodeIndex !== undefined ? nodeIndex.node : undefined;
-    }
+    };
     /**
      * Returns the value of the first element in the list that
      * satisfies the provided testing function. Otherwise undefined is returned.
@@ -193,10 +278,10 @@ class SinglyLinkedList {
      * ```
      * @param f Function to test val against
      */
-    find(f) {
-        const nodeIndex = this.findNodeIndex(f);
+    SinglyLinkedList.prototype.find = function (f) {
+        var nodeIndex = this.findNodeIndex(f);
         return nodeIndex !== undefined ? nodeIndex.node.val : undefined;
-    }
+    };
     /**
      * Returns the index of the first node in the list that
      * satisfies the provided testing function. Ohterwise -1 is returned.
@@ -205,10 +290,10 @@ class SinglyLinkedList {
      * ```
      * @param f Function to test val against
      */
-    findIndex(f) {
-        const nodeIndex = this.findNodeIndex(f);
+    SinglyLinkedList.prototype.findIndex = function (f) {
+        var nodeIndex = this.findNodeIndex(f);
         return nodeIndex !== undefined ? nodeIndex.index : -1;
-    }
+    };
     /**
      * Append one or any number of nodes to the end of the list.
      * This modifies the list in place and returns the list itself
@@ -218,20 +303,35 @@ class SinglyLinkedList {
      * ```
      * @param args Data to be stored in the node, takes any number of arguments
      */
-    append(...args) {
-        for (const val of args) {
-            const node = new SinglyLinkedListNode(val, this.tail, null, this);
-            if (this.head === null) {
-                this.head = node;
+    SinglyLinkedList.prototype.append = function () {
+        var e_1, _a;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        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;
             }
-            if (this.tail !== null) {
-                this.tail.next = node;
+        }
+        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);
             }
-            this.tail = node;
-            this.size += 1;
+            finally { if (e_1) throw e_1.error; }
         }
         return this;
-    }
+    };
     /**
      * Synonym for append
      * ```ts
@@ -239,10 +339,14 @@ class SinglyLinkedList {
      * ```
      * @param args Data to be stored, takes any number of arguments
      */
-    push(...args) {
-        this.append(...args);
+    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.length;
-    }
+    };
     /**
      * Prepend any number of val arguments to the list. The
      * argument list is prepended as a block to reduce confusion:
@@ -251,21 +355,36 @@ class SinglyLinkedList {
      * ```
      * @param args Data to be stored in the node, accepts any number of arguments
      */
-    prepend(...args) {
-        const reverseArgs = Array.from(args).reverse();
-        for (const val of reverseArgs) {
-            const node = new SinglyLinkedListNode(val, null, this.head, this);
-            if (this.tail === null) {
-                this.tail = node;
+    SinglyLinkedList.prototype.prepend = function () {
+        var e_2, _a;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        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;
             }
-            if (this.head !== null) {
-                this.head.prev = node;
+        }
+        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);
             }
-            this.head = node;
-            this.size += 1;
+            finally { if (e_2) throw e_2.error; }
         }
         return this;
-    }
+    };
     /**
      * Insert a new node at a given index position. If index is
      * out of bounds, the node is appended, if index is negative
@@ -276,22 +395,22 @@ class SinglyLinkedList {
      * @param index The index to insert the new node at
      * @param val Data to be stored on the new node
      */
-    insertAt(index, val) {
+    SinglyLinkedList.prototype.insertAt = function (index, val) {
         if (this.head === null) {
             return this.append(val);
         }
         if (index <= 0) {
             return this.prepend(val);
         }
-        let currentNode = this.head;
-        let currentIndex = 0;
+        var currentNode = this.head;
+        var currentIndex = 0;
         while (currentIndex < index - 1 && currentNode.next !== null) {
             currentIndex += 1;
             currentNode = currentNode.next;
         }
         currentNode.insertAfter(val);
         return this;
-    }
+    };
     /**
      * Remove the specified node from the list and return the removed
      * node afterwards.
@@ -301,7 +420,7 @@ class SinglyLinkedList {
      * ```
      * @param node The node to be removed
      */
-    removeNode(node) {
+    SinglyLinkedList.prototype.removeNode = function (node) {
         if (node.list !== this) {
             throw new ReferenceError('Node does not belong to this list');
         }
@@ -322,7 +441,7 @@ class SinglyLinkedList {
         node.prev = null;
         node.list = null;
         return node;
-    }
+    };
     /**
      * Remove the node at the specified index
      * ```ts
@@ -330,10 +449,10 @@ class SinglyLinkedList {
      * ```
      * @param index Index at which to remove
      */
-    removeAt(index) {
-        const node = this.getNode(index);
+    SinglyLinkedList.prototype.removeAt = function (index) {
+        var node = this.getNode(index);
         return node !== undefined ? this.removeNode(node) : undefined;
-    }
+    };
     /**
      * Insert a new node before the reference node
      * ```ts
@@ -343,8 +462,8 @@ class SinglyLinkedList {
      * @param referenceNode The node reference
      * @param val Data to save in the node
      */
-    insertBefore(referenceNode, val) {
-        const node = new SinglyLinkedListNode(val, referenceNode.prev, referenceNode, this);
+    SinglyLinkedList.prototype.insertBefore = function (referenceNode, val) {
+        var node = new SinglyLinkedListNode(val, referenceNode.prev, referenceNode, this);
         if (referenceNode.prev === null) {
             this.head = node;
         }
@@ -354,7 +473,7 @@ class SinglyLinkedList {
         referenceNode.prev = node;
         this.size += 1;
         return this;
-    }
+    };
     /**
      * Sorts the linked list using the provided compare function
      * @param compare A function used to compare the val of two nodes. It should return
@@ -362,25 +481,25 @@ class SinglyLinkedList {
      *                (a, b) => a < b or (1, 2) => 1 < 2 === true, 2 will be inserted after 1,
      *                the sort order will be ascending.
      */
-    sort(compare) {
+    SinglyLinkedList.prototype.sort = function (compare) {
         if (this.head === null || this.tail === null) {
             return this;
         }
         if (this.length < 2) {
             return this;
         }
-        const quicksort = (start, end) => {
+        var quicksort = function (start, end) {
             if (start === end) {
                 return;
             }
-            const pivotData = end.val;
-            let current = start;
-            let split = start;
+            var pivotData = end.val;
+            var current = start;
+            var split = start;
             while (current && current !== end) {
-                const sort = compare(current.val, pivotData);
+                var sort = compare(current.val, pivotData);
                 if (sort) {
                     if (current !== split) {
-                        const temp = split.val;
+                        var temp = split.val;
                         split.val = current.val;
                         current.val = temp;
                     }
@@ -405,7 +524,7 @@ class SinglyLinkedList {
         };
         quicksort(this.head, this.tail);
         return this;
-    }
+    };
     /**
      * Insert a new node after this one
      * ```ts
@@ -415,8 +534,8 @@ class SinglyLinkedList {
      * @param referenceNode The reference node
      * @param val Data to be saved in the node
      */
-    insertAfter(referenceNode, val) {
-        const node = new SinglyLinkedListNode(val, referenceNode, referenceNode.next, this);
+    SinglyLinkedList.prototype.insertAfter = function (referenceNode, val) {
+        var node = new SinglyLinkedListNode(val, referenceNode, referenceNode.next, this);
         if (referenceNode.next === null) {
             this.tail = node;
         }
@@ -426,7 +545,7 @@ class SinglyLinkedList {
         referenceNode.next = node;
         this.size += 1;
         return this;
-    }
+    };
     /**
      * Remove the first node from the list and return the val of the removed node
      * or undefined
@@ -434,9 +553,9 @@ class SinglyLinkedList {
      * new LinkedList(1, 2, 3).shift(); // 1
      * ```
      */
-    shift() {
+    SinglyLinkedList.prototype.shift = function () {
         return this.removeFromAnyEnd(this.head);
-    }
+    };
     /**
      * Remove the last node from the list and return the val of the removed node
      * or undefined if the list was empty
@@ -444,9 +563,9 @@ class SinglyLinkedList {
      * new LinkedList(1, 2, 3).pop(); // 3
      * ```
      */
-    pop() {
+    SinglyLinkedList.prototype.pop = function () {
         return this.removeFromAnyEnd(this.tail);
-    }
+    };
     /**
      * Merge the current list with another. Both lists will be
      * equal after merging.
@@ -458,7 +577,7 @@ class SinglyLinkedList {
      * ```
      * @param list The list to be merged
      */
-    merge(list) {
+    SinglyLinkedList.prototype.merge = function (list) {
         if (this.tail !== null) {
             this.tail.next = list.head;
         }
@@ -471,7 +590,7 @@ class SinglyLinkedList {
         list.size = this.size;
         list.head = this.head;
         list.tail = this.tail;
-    }
+    };
     /**
      * Removes all nodes from a list
      *
@@ -479,12 +598,12 @@ class SinglyLinkedList {
      * list.clear();
      * ```
      */
-    clear() {
+    SinglyLinkedList.prototype.clear = function () {
         this.head = null;
         this.tail = null;
         this.size = 0;
         return this;
-    }
+    };
     /**
      * The slice() method returns a shallow copy of a
      * portion of a list into a new list object selected
@@ -498,22 +617,22 @@ class SinglyLinkedList {
      * @param end End index, optional
      */
     // eslint-disable-next-line @typescript-eslint/ban-types
-    slice(start, end) {
-        const list = new SinglyLinkedList();
-        let finish = end;
+    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.length;
         }
-        let head = this.getNode(start);
-        for (let i = 0; i < finish - start && head !== null && head !== undefined; i++) {
+        var head = this.getNode(start);
+        for (var i = 0; i < finish - start && head !== null && head !== undefined; i++) {
             list.append(head.val);
             head = head.next;
         }
         return list;
-    }
+    };
     /**
      * The reverse() function reverses the list in place and returns the list
      * itself.
@@ -521,19 +640,19 @@ class SinglyLinkedList {
      * new LinkedList(1, 2, 3).reverse(); // 3 <=> 2 <=> 1
      * ```
      */
-    reverse() {
-        let currentNode = this.head;
+    SinglyLinkedList.prototype.reverse = function () {
+        var currentNode = this.head;
         while (currentNode) {
-            const next = currentNode.next;
+            var next = currentNode.next;
             currentNode.next = currentNode.prev;
             currentNode.prev = next;
             currentNode = currentNode.prev;
         }
-        const tail = this.tail;
+        var tail = this.tail;
         this.tail = this.head;
         this.head = tail;
         return this;
-    }
+    };
     /**
      * The forEach() method executes a provided function once for each list node.
      * ```ts
@@ -542,17 +661,18 @@ class SinglyLinkedList {
      * @param f Function to execute for each element, taking up to three arguments.
      * @param reverse Indicates if the list should be walked in reverse order, default is false
      */
-    forEach(f, reverse = false) {
-        let currentIndex = reverse ? this.length - 1 : 0;
-        let currentNode = reverse ? this.tail : this.head;
-        const modifier = reverse ? -1 : 1;
-        const nextNode = reverse ? 'prev' : 'next';
+    SinglyLinkedList.prototype.forEach = function (f, reverse) {
+        if (reverse === void 0) { reverse = false; }
+        var currentIndex = reverse ? this.length - 1 : 0;
+        var currentNode = reverse ? this.tail : this.head;
+        var modifier = reverse ? -1 : 1;
+        var nextNode = reverse ? 'prev' : 'next';
         while (currentNode) {
             f(currentNode.val, currentIndex, this);
             currentNode = currentNode[nextNode];
             currentIndex += modifier;
         }
-    }
+    };
     /**
      * The map() method creates a new list with the results of
      * calling a provided function on every node in the calling list.
@@ -563,11 +683,13 @@ class SinglyLinkedList {
      * @param reverse Indicates if the list should be mapped in reverse order, default is false
      */
     // eslint-disable-next-line @typescript-eslint/ban-types
-    map(f, reverse = false) {
-        const list = new SinglyLinkedList();
-        this.forEach((val, index) => list.append(f(val, index, this)), reverse);
+    SinglyLinkedList.prototype.map = function (f, reverse) {
+        var _this = this;
+        if (reverse === void 0) { reverse = false; }
+        var list = new SinglyLinkedList();
+        this.forEach(function (val, index) { return list.append(f(val, index, _this)); }, reverse);
         return list;
-    }
+    };
     /**
      * The filter() method creates a new list with all nodes
      * that pass the test implemented by the provided function.
@@ -578,15 +700,17 @@ class SinglyLinkedList {
      * @param reverse Indicates if the list should be filtered in reverse order, default is false
      */
     // eslint-disable-next-line @typescript-eslint/ban-types
-    filter(f, reverse = false) {
-        const list = new SinglyLinkedList();
-        this.forEach((val, index) => {
-            if (f(val, index, this)) {
+    SinglyLinkedList.prototype.filter = function (f, reverse) {
+        var _this = this;
+        if (reverse === void 0) { reverse = false; }
+        var list = new SinglyLinkedList();
+        this.forEach(function (val, index) {
+            if (f(val, index, _this)) {
                 list.append(val);
             }
         }, reverse);
         return list;
-    }
+    };
     /**
      * Reduce over each node in the list
      * ```ts
@@ -596,12 +720,13 @@ class SinglyLinkedList {
      * @param start An initial value
      * @returns The final state of the accumulator
      */
-    reduce(f, start, reverse = false) {
-        let currentIndex = reverse ? this.length - 1 : 0;
-        const modifier = reverse ? -1 : 1;
-        const nextNode = reverse ? 'prev' : 'next';
-        let currentElement = reverse ? this.tail : this.head;
-        let result;
+    SinglyLinkedList.prototype.reduce = function (f, start, reverse) {
+        if (reverse === void 0) { reverse = false; }
+        var currentIndex = reverse ? this.length - 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;
         }
@@ -618,16 +743,16 @@ class SinglyLinkedList {
             currentElement = currentElement[nextNode];
         }
         return result;
-    }
+    };
     /**
      * Convert the linked list to an array
      * ```ts
      * new LinkedList(1, 2, 3).toArray(); // [1, 2, 3]
      * ```
      */
-    toArray() {
-        return [...this];
-    }
+    SinglyLinkedList.prototype.toArray = function () {
+        return __spreadArray([], __read(this), false);
+    };
     /**
      * Convert a linked list to string
      * ```ts
@@ -635,9 +760,10 @@ class SinglyLinkedList {
      * ```
      * @param separator Optional string to be placed in between val nodes, default is one space
      */
-    toString(separator = ' ') {
-        return this.reduce((s, val) => `${s}${separator}${val}`);
-    }
+    SinglyLinkedList.prototype.toString = function (separator) {
+        if (separator === void 0) { separator = ' '; }
+        return this.reduce(function (s, val) { return "".concat(s).concat(separator).concat(val); });
+    };
     /**
      * The iterator implementation
      * ```ts
@@ -645,16 +771,28 @@ class SinglyLinkedList {
      * for (const val of list) { log(val); } // 1 2 3
      * ```
      */
-    *[Symbol.iterator]() {
-        let element = this.head;
-        while (element !== null) {
-            yield element.val;
-            element = element.next;
-        }
-    }
+    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*/];
+            }
+        });
+    };
     /** Private helper function to reduce duplication of pop() and shift() methods */
-    removeFromAnyEnd(node) {
+    SinglyLinkedList.prototype.removeFromAnyEnd = function (node) {
         return node !== null ? this.removeNode(node).val : undefined;
-    }
-}
+    };
+    return SinglyLinkedList;
+}());
 exports.SinglyLinkedList = SinglyLinkedList;