solists 0.2.0 → 1.0.0

package/dist/DoublyLinkedList.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoublyLinkedList = void 0;
 const Node_1 = require("./Node");
 class DoublyLinkedList {
-    constructor(rearrangeOnCreation = false, iterable = null) {
-        this.head = null;
-        this.tail = null;
-        this.length = 0;
-        this.rearrangeOnCreation = rearrangeOnCreation;
+    constructor(iterable = null, options = {}) {
+        var _a;
+        this._options = options;
+        this._head = null;
+        this._tail = null;
+        this._length = 0;
+        this._accessOnly = (_a = options.accessOnly) !== null && _a !== void 0 ? _a : true;
         if (iterable !== null) {
             this._extend(iterable);
         }
@@ -15,96 +17,94 @@ class DoublyLinkedList {
     [Symbol.iterator]() {
         return this._values();
     }
-    // Public Array-like methods
+    // Public native Array methods
     at(index) {
         if (this.length === 0 || Math.abs(index) >= this.length) {
             return undefined;
         }
         index = this._toAbsoluteIndex(index, this.length);
         const targetNode = this._getNode(index);
-        if (targetNode === null) {
-            return undefined;
-        }
         targetNode.count += 1;
         this._rearrange(targetNode);
         return targetNode.value;
     }
-    concat(...values) {
-        const { length: valuesLength } = values;
-        const result = this.slice(0, this.length);
-        for (let index = 0; index < valuesLength; index += 1) {
-            const value = values[index];
-            if (value instanceof DoublyLinkedList || Array.isArray(value)) {
-                for (const currentValue of value.values()) {
-                    result.push(currentValue);
+    concat(...items) {
+        const result = this.slice();
+        for (const item of items) {
+            if (Array.isArray(item) || item instanceof DoublyLinkedList) {
+                for (const value of item) {
+                    result.push(value);
                 }
             }
             else {
-                result.push(value);
+                result.push(item);
             }
         }
         return result;
     }
-    copyWithin(target /* = 0 */, start /* = 0, end = @length */) {
+    copyWithin(target, start, end) {
+        const targetIndex = this._toAbsoluteIndex(target, this.length);
         const sourceStart = this._toAbsoluteIndex(start, this.length);
-        const sourceEnd = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.length;
-        const targetStart = this._toAbsoluteIndex(target, this.length);
-        let count = Math.min((sourceEnd === this.length ? this.length : this._toAbsoluteIndex(sourceEnd, this.length)) - sourceStart, this.length - targetStart);
-        const tempSrcLst = this.slice(0, this.length);
-        const targetNodes = this._nodes(targetStart, targetStart + count);
-        const sourceNodes = tempSrcLst._nodes(sourceStart, sourceStart + count);
-        while (count > 0) {
-            const targetCurrentNode = targetNodes.next();
-            const sourceCurrentNode = sourceNodes.next();
-            const targetCurrentValue = targetCurrentNode.value;
-            const sourceCurrentValue = sourceCurrentNode.value;
-            targetCurrentValue[1].value = sourceCurrentValue[1].value;
-            count -= 1;
+        const sourceEnd = end === undefined ? this.length : this._toAbsoluteIndex(end, this.length);
+        let count = Math.min(sourceEnd - sourceStart, this.length - targetIndex);
+        if (count <= 0 || sourceStart === targetIndex)
+            return this;
+        if (sourceStart < targetIndex && targetIndex < sourceStart + count) {
+            let sourceNode = this._getNode(sourceStart + count - 1);
+            let targetNode = this._getNode(targetIndex + count - 1);
+            while (count > 0) {
+                targetNode.value = sourceNode.value;
+                sourceNode = sourceNode.prev;
+                targetNode = targetNode.prev;
+                count -= 1;
+            }
+        }
+        else {
+            let sourceNode = this._getNode(sourceStart);
+            let targetNode = this._getNode(targetIndex);
+            while (count > 0) {
+                targetNode.value = sourceNode.value;
+                sourceNode = sourceNode.next;
+                targetNode = targetNode.next;
+                count -= 1;
+            }
         }
         return this;
     }
     entries() {
         return this._entries();
     }
-    // TODO: Support "thisArg" argument
-    every(callbackFn) {
+    every(predicate, thisArg) {
+        this._aCallable(predicate);
         for (const [index, node] of this._nodes(0, this.length)) {
-            if (!(callbackFn(node.value, index, this))) {
+            if (!predicate.call(thisArg, node.value, index, this)) {
                 return false;
             }
         }
         return true;
     }
-    fill(value) {
-        let startIndex = undefined;
-        if (arguments.length > 1) {
-            startIndex = arguments[1];
-        }
-        startIndex = this._toAbsoluteIndex(startIndex, this.length);
-        let endIndex = undefined;
-        if (arguments.length > 2) {
-            endIndex = arguments[2];
-        }
-        endIndex = (endIndex === undefined) ? this.length : this._toAbsoluteIndex(endIndex, this.length);
-        for (const [/* index */ , node] of this._nodes(startIndex, endIndex)) {
+    fill(value, start, end) {
+        const startIndex = this._toAbsoluteIndex(start, this.length);
+        const endIndex = end === undefined ? this.length : this._toAbsoluteIndex(end, this.length);
+        for (const [, node] of this._nodes(startIndex, endIndex)) {
             node.value = value;
         }
         return this;
     }
-    // TODO: Support "thisArg" argument
-    filter(callbackFn) {
+    filter(predicate, thisArg) {
+        this._aCallable(predicate);
         const result = new DoublyLinkedList();
         for (const [index, node] of this._nodes(0, this.length)) {
-            if (callbackFn(node.value, index, this)) {
+            if (predicate.call(thisArg, node.value, index, this)) {
                 result.push(node.value);
             }
         }
         return result;
     }
-    // TODO: Support "thisArg" argument
-    find(callbackFn) {
+    find(predicate, thisArg) {
+        this._aCallable(predicate);
         for (const [index, node] of this._nodes(0, this.length)) {
-            if (callbackFn(node.value, index, this)) {
+            if (predicate.call(thisArg, node.value, index, this)) {
                 node.count += 1;
                 this._rearrange(node);
                 return node.value;
@@ -112,21 +112,21 @@ class DoublyLinkedList {
         }
         return undefined;
     }
-    // TODO: Support "thisArg" argument
-    findIndex(callbackFn) {
+    findIndex(predicate, thisArg) {
+        this._aCallable(predicate);
         for (const [index, node] of this._nodes(0, this.length)) {
-            if (callbackFn(node.value, index, this)) {
+            if (predicate.call(thisArg, node.value, index, this)) {
                 node.count += 1;
                 const result = this._rearrange(node);
-                return (result === undefined) ? index : result;
+                return result === undefined ? index : result;
             }
         }
         return -1;
     }
-    // TODO: Support "thisArg" argument
-    findLast(callbackFn) {
+    findLast(predicate, thisArg) {
+        this._aCallable(predicate);
         for (const [index, node] of this._nodesReverse(0, this.length)) {
-            if (callbackFn(node.value, index, this)) {
+            if (predicate.call(thisArg, node.value, index, this)) {
                 node.count += 1;
                 this._rearrange(node);
                 return node.value;
@@ -134,43 +134,56 @@ class DoublyLinkedList {
         }
         return undefined;
     }
-    // TODO: Support "thisArg" argument
-    findLastIndex(callbackFn) {
+    findLastIndex(predicate, thisArg) {
+        this._aCallable(predicate);
         for (const [index, node] of this._nodesReverse(0, this.length)) {
-            if (callbackFn(node.value, index, this)) {
+            if (predicate.call(thisArg, node.value, index, this)) {
                 node.count += 1;
                 const result = this._rearrange(node);
-                return (result === undefined) ? index : result;
+                return result === undefined ? index : result;
             }
         }
         return -1;
     }
-    flat(depth = 1) {
-        depth = this._toIntegerOrInfinity(depth);
-        if (depth < 1) {
-            return this.slice(0, this.length);
+    flat(depth) {
+        const d = depth === undefined ? 1 : this._toIntegerOrInfinity(depth);
+        if (d < 1) {
+            return this.slice();
         }
-        return this.reduce(function (flat, toFlatten) {
-            return flat.concat(((toFlatten instanceof DoublyLinkedList) && (depth > 1)) ? toFlatten.flat(depth - 1) : toFlatten);
-        }, new DoublyLinkedList());
+        const result = new DoublyLinkedList();
+        for (const [, node] of this._nodes(0, this.length)) {
+            const value = node.value;
+            if (Array.isArray(value) || value instanceof DoublyLinkedList) {
+                const flattened = value instanceof DoublyLinkedList
+                    ? value.flat(d - 1)
+                    : new DoublyLinkedList(value).flat(d - 1);
+                for (const item of flattened) {
+                    result.push(item);
+                }
+            }
+            else {
+                result.push(value);
+            }
+        }
+        return result;
     }
-    // TODO: Support "thisArg" argument
-    flatMap(callbackFn) {
-        return this.map(callbackFn).flat();
+    flatMap(callback, thisArg) {
+        this._aCallable(callback);
+        return this.map(callback, thisArg).flat();
     }
-    forEach(callbackFn) {
+    forEach(callbackfn, thisArg) {
+        this._aCallable(callbackfn);
         for (const [index, node] of this._nodes(0, this.length)) {
-            callbackFn(node.value, index, this);
+            callbackfn.call(thisArg, node.value, index, this);
         }
-        return undefined;
     }
-    includes(searchedValue, fromIndex) {
+    includes(searchElement, fromIndex) {
         if (this.length === 0) {
             return false;
         }
-        fromIndex = this._toAbsoluteIndex(fromIndex, this.length);
-        for (const [/* index */ , node] of this._nodes(fromIndex, this.length)) {
-            if (this._sameValueZero(node.value, searchedValue)) {
+        const startIndex = this._toAbsoluteIndex(fromIndex, this.length);
+        for (const [, node] of this._nodes(startIndex, this.length)) {
+            if (this._sameValueZero(node.value, searchElement)) {
                 node.count += 1;
                 this._rearrange(node);
                 return true;
@@ -178,66 +191,62 @@ class DoublyLinkedList {
         }
         return false;
     }
-    indexOf(searchedValue, fromIndex = 0) {
+    indexOf(searchElement, fromIndex) {
         if (this.length === 0) {
             return -1;
         }
-        fromIndex = this._toAbsoluteIndex(fromIndex, this.length);
-        for (const [index, node] of this._nodes(fromIndex, this.length)) {
-            if (this._isStrictlyEqual(node.value, searchedValue)) {
+        const startIndex = this._toAbsoluteIndex(fromIndex !== null && fromIndex !== void 0 ? fromIndex : 0, this.length);
+        for (const [index, node] of this._nodes(startIndex, this.length)) {
+            if (this._isStrictlyEqual(node.value, searchElement)) {
                 node.count += 1;
                 const result = this._rearrange(node);
-                return (result === undefined) ? index : result;
+                return result === undefined ? index : result;
             }
         }
         return -1;
     }
     join(separator) {
-        let result = '';
         if (this.length === 0) {
-            return result;
-        }
-        if (separator === undefined) {
-            separator = ',';
+            return "";
         }
+        const sep = separator === undefined ? "," : String(separator);
+        let result = "";
         for (const [index, node] of this._nodes(0, this.length)) {
-            const value = node.value == null ? "" : node.value;
-            if (index !== this.length - 1) {
-                result = result.concat(value) + separator;
-            }
-            else {
-                result = result.concat(value);
-            }
+            const value = node.value == null ? "" : String(node.value);
+            result += index === 0 ? value : sep + value;
         }
         return result;
     }
     keys() {
         return this._keys();
     }
-    lastIndexOf(searchElement /* , fromIndex = @[*-1] */) {
+    get length() {
+        return this._length;
+    }
+    lastIndexOf(searchElement, fromIndex) {
         if (this.length === 0) {
             return -1;
         }
-        let fromIndex = this.length - 1;
-        if (arguments.length > 1) {
-            fromIndex = Math.min(fromIndex, this._toIntegerOrInfinity(arguments[1]));
-        }
-        if (fromIndex < 0) {
-            fromIndex = this.length + fromIndex;
+        let startIndex = arguments.length > 1
+            ? Math.min(this._toIntegerOrInfinity(fromIndex), this.length - 1)
+            : this.length - 1;
+        if (startIndex < 0) {
+            startIndex = this.length + startIndex;
         }
-        for (const [index, node] of this._nodesReverse(0, fromIndex + 1)) {
+        for (const [index, node] of this._nodesReverse(0, startIndex + 1)) {
             if (this._isStrictlyEqual(node.value, searchElement)) {
                 node.count += 1;
                 const result = this._rearrange(node);
-                return (result === undefined) ? index : result;
+                return result === undefined ? index : result;
             }
         }
         return -1;
     }
-    map(callbackFn) {
+    map(callbackfn, thisArg) {
+        this._aCallable(callbackfn);
         const result = new DoublyLinkedList();
         for (const [index, node] of this._nodes(0, this.length)) {
-            result.push(callbackFn(node.value, index, this));
+            result.push(callbackfn.call(thisArg, node.value, index, this));
         }
         return result;
     }
@@ -245,78 +254,72 @@ class DoublyLinkedList {
         if (this.length === 0) {
             return undefined;
         }
-        const value = this.tail.value;
+        const value = this._tail.value;
         if (this.length === 1) {
             this._removeLast();
         }
         else {
-            this.tail = this.tail.prev;
-            this.tail.next = null;
-            this.length -= 1;
+            this._tail = this._tail.prev;
+            this._tail.next = null;
+            this._length -= 1;
         }
         return value;
     }
-    push(...values) {
-        const { length: valuesLength } = values;
-        for (let index = 0; index < valuesLength; index += 1) {
-            const newNode = new Node_1.Node(values[index]);
+    push(...items) {
+        for (const item of items) {
+            const newNode = new Node_1.Node(item);
             if (this.length === 0) {
                 this._insertFirst(newNode);
             }
-            else if (this.tail !== null) {
-                this._insertAfter(this.tail, newNode);
-            }
             else {
-                continue;
+                this._insertAfter(this._tail, newNode);
             }
-            if (this.rearrangeOnCreation) {
+            if (!this._accessOnly) {
                 this._rearrange(newNode);
             }
         }
         return this.length;
     }
-    reduce(callbackFn, initialValue) {
-        if (!(this._isCallable(callbackFn))) {
-            throw TypeError(this._tryToString(callbackFn) + ' is not a function');
+    reduce(callbackfn, initialValue) {
+        this._aCallable(callbackfn);
+        const hasInitial = arguments.length > 1;
+        if (this.length === 0 && !hasInitial) {
+            throw TypeError("Reduce of empty list with no initial value");
         }
-        if (this.length === 0 && arguments.length < 2) {
-            throw TypeError('Reduce of empty list with no initial value');
-        }
-        let accumulator = arguments.length > 1 ? initialValue : this.head.value;
+        let accumulator = hasInitial ? initialValue : this._head.value;
         for (const [index, node] of this._nodes(0, this.length)) {
-            if (arguments.length > 1 || index > 0) {
-                accumulator = callbackFn(accumulator, node.value, index, this);
+            if (hasInitial || index > 0) {
+                accumulator = callbackfn(accumulator, node.value, index, this);
             }
         }
         return accumulator;
     }
-    reduceRight(callbackFn, initialValue) {
-        if (!(this._isCallable(callbackFn))) {
-            throw TypeError(this._tryToString(callbackFn) + ' is not a function');
-        }
-        if (this.length === 0 && arguments.length < 2) {
-            throw TypeError('Reduce of empty list with no initial value');
+    reduceRight(callbackfn, initialValue) {
+        this._aCallable(callbackfn);
+        const hasInitial = arguments.length > 1;
+        if (this.length === 0 && !hasInitial) {
+            throw TypeError("Reduce of empty list with no initial value");
         }
-        let accumulator = arguments.length > 1 ? initialValue : this.tail.value;
+        let accumulator = hasInitial ? initialValue : this._tail.value;
         for (const [index, node] of this._nodesReverse(0, this.length)) {
-            if (index < this.length - 1) {
-                accumulator = callbackFn(accumulator, node.value, index, this);
+            if (hasInitial || index < this.length - 1) {
+                accumulator = callbackfn(accumulator, node.value, index, this);
             }
         }
         return accumulator;
     }
     reverse() {
         if (this.length > 1) {
-            let curr = this.head;
+            let curr = this._head;
             while (curr) {
                 const next = curr.next;
                 curr.next = curr.prev;
                 curr.prev = next;
                 if (curr.next === null) {
-                    this.tail = curr;
+                    this._tail = curr;
                 }
                 else if (curr.prev === null) {
-                    this.head = curr;
+                    this._head = curr;
                 }
                 curr = next;
             }
@@ -327,68 +330,66 @@ class DoublyLinkedList {
         if (this.length === 0) {
             return undefined;
         }
-        const value = this.head.value;
+        const value = this._head.value;
         if (this.length === 1) {
             this._removeLast();
         }
         else {
-            this.head = this.head.next;
-            this.head.prev = null;
-            this.length -= 1;
+            this._head = this._head.next;
+            this._head.prev = null;
+            this._length -= 1;
         }
         return value;
     }
-    slice(startIndex, endIndex) {
+    slice(start, end) {
         const result = new DoublyLinkedList();
-        if (startIndex === undefined) {
-            startIndex = 0;
-        }
-        startIndex = this._toAbsoluteIndex(startIndex, this.length);
-        endIndex = this._toAbsoluteIndex(endIndex === undefined ? this.length : endIndex, this.length);
-        for (const [/* index */ , node] of this._nodes(startIndex, endIndex)) {
+        const startIndex = this._toAbsoluteIndex(start, this.length);
+        const endIndex = end === undefined ? this.length : this._toAbsoluteIndex(end, this.length);
+        for (const [, node] of this._nodes(startIndex, endIndex)) {
             result.push(node.value);
         }
         return result;
     }
-    // TODO: Support "thisArg" argument
-    some(callbackFn) {
+    some(predicate, thisArg) {
+        this._aCallable(predicate);
         for (const [index, node] of this._nodes(0, this.length)) {
-            if (callbackFn(node.value, index, this)) {
+            if (predicate.call(thisArg, node.value, index, this)) {
                 return true;
             }
         }
         return false;
     }
-    sort(comparefn) {
+    sort(compareFn) {
         if (this.length > 1) {
-            this._mergeSort(this._getSortCompare(comparefn));
+            const compare = this._getSortCompare(compareFn);
+            if (this.length < 8) {
+                this._insertionSort(compare);
+            }
+            else {
+                this._mergeSort(compare);
+            }
         }
         return this;
     }
-    splice(start, deleteCount /* , ...items */) {
+    splice(start, deleteCount, ...items) {
         if (arguments.length === 0) {
-            deleteCount = 0;
-        }
-        else if (arguments.length === 1) {
-            start = this._toAbsoluteIndex(start, this.length);
-            deleteCount = this.length - start;
-        }
-        else {
-            start = this._toAbsoluteIndex(start, this.length);
-            deleteCount = Math.min(Math.max(this._toIntegerOrInfinity(deleteCount), 0), this.length - start);
+            return new DoublyLinkedList();
         }
+        const startIndex = this._toAbsoluteIndex(start, this.length);
+        const delCount = arguments.length === 1
+            ? this.length - startIndex
+            : Math.min(Math.max(this._toIntegerOrInfinity(deleteCount), 0), this.length - startIndex);
         const deleted = new DoublyLinkedList();
-        if (this.length > 0 && deleteCount > 0) {
-            let prev = this._getNode(start - 1);
-            let current = prev ? prev.next : this.head;
-            for (let index = 0; index < deleteCount; index += 1) {
+        if (this.length > 0 && delCount > 0) {
+            const prev = this._getNode(startIndex - 1);
+            let current = prev ? prev.next : this._head;
+            for (let i = 0; i < delCount; i++) {
                 deleted.push(current.value);
                 current = current.next;
-                this.length -= 1;
+                this._length -= 1;
             }
             if (prev === null) {
-                this.head = current;
-                prev = current;
+                this._head = current;
                 if (current) {
                     current.prev = null;
                 }
@@ -399,83 +400,99 @@ class DoublyLinkedList {
                     current.prev = prev;
                 }
                 else {
-                    this.tail = prev;
+                    this._tail = prev;
                 }
             }
         }
-        const items = Array.prototype.slice.call(arguments, 2, arguments.length);
         if (items.length > 0) {
-            let current, next;
-            if (start === 0) {
-                next = this.head;
-                this.head = new Node_1.Node(items.shift());
-                current = this.head;
-                this.length += 1;
+            let current;
+            let next;
+            if (startIndex === 0) {
+                next = this._head;
+                this._head = new Node_1.Node(items.shift());
+                current = this._head;
+                this._length += 1;
             }
             else {
-                current = this._getNode(start - 1);
+                current = this._getNode(startIndex - 1);
                 next = current.next;
             }
             for (const item of items) {
                 current.next = new Node_1.Node(item);
                 current.next.prev = current;
                 current = current.next;
-                this.length += 1;
+                this._length += 1;
             }
             current.next = next;
             if (next) {
                 next.prev = current;
             }
             else {
-                this.tail = current;
+                this._tail = current;
             }
         }
         return deleted;
     }
     toLocaleString(locales, options) {
-        let result = '';
         if (this.length === 0) {
-            return result;
+            return "";
         }
-        const separator = ',';
-        for (const [index, node] of this._nodes(0, this.length)) {
-            const value = node.value == null ? "" : node.value;
-            if (index !== this.length - 1) {
-                if (locales == null || options == null) {
-                    result = result.concat(value.toLocaleString()) + separator;
-                }
-                else {
-                    result = result.concat(value.toLocaleString(locales, options)) + separator;
-                }
+        const parts = [];
+        for (const [, node] of this._nodes(0, this.length)) {
+            const value = node.value;
+            if (value == null) {
+                parts.push("");
             }
             else {
-                if (locales == null || options == null) {
-                    result = result.concat(value.toLocaleString());
-                }
-                else {
-                    result = result.concat(value.toLocaleString(locales, options));
-                }
+                parts.push(value.toLocaleString(locales, options));
             }
         }
-        return result;
+        return parts.join(",");
+    }
+    toReversed() {
+        return this.slice().reverse();
+    }
+    toSorted(compareFn) {
+        if (compareFn !== undefined && !this._isCallable(compareFn)) {
+            let value;
+            if (compareFn === null)
+                value = "null";
+            else if (Array.isArray(compareFn))
+                value = Object.prototype.toString.call(compareFn);
+            else if (typeof compareFn === "object")
+                value = "#<Object>";
+            else
+                value = String(compareFn);
+            throw TypeError(`The comparison function must be either a function or undefined: ${value}`);
+        }
+        return this.slice().sort(compareFn);
+    }
+    toSpliced(start, deleteCount, ...items) {
+        const copy = this.slice();
+        if (arguments.length === 0) {
+            return copy;
+        }
+        else if (arguments.length === 1) {
+            copy.splice(start);
+        }
+        else {
+            copy.splice(start, deleteCount, ...items);
+        }
+        return copy;
     }
     toString() {
         return this.join(",");
     }
-    unshift(...values) {
-        const { length: valuesLength } = values;
-        for (let index = valuesLength - 1; index >= 0; index -= 1) {
-            const newNode = new Node_1.Node(values[index]);
+    unshift(...items) {
+        for (let i = items.length - 1; i >= 0; i--) {
+            const newNode = new Node_1.Node(items[i]);
             if (this.length === 0) {
                 this._insertFirst(newNode);
             }
-            else if (this.head !== null) {
-                this._insertBefore(this.head, newNode);
-            }
             else {
-                continue;
+                this._insertBefore(this._head, newNode);
             }
-            if (this.rearrangeOnCreation) {
+            if (!this._accessOnly) {
                 this._rearrange(newNode);
             }
         }
@@ -484,25 +501,35 @@ class DoublyLinkedList {
     values() {
         return this._values();
     }
+    with(index, value) {
+        const relativeIndex = this._toIntegerOrInfinity(index);
+        const actualIndex = relativeIndex < 0 ? this.length + relativeIndex : relativeIndex;
+        if (actualIndex >= this.length || actualIndex < 0) {
+            throw new RangeError("Invalid index : " + index);
+        }
+        const copy = this.slice();
+        const node = copy._getNode(actualIndex);
+        if (node !== null) {
+            node.value = value;
+        }
+        return copy;
+    }
     // Public custom methods
     insert(index, value) {
         if (index === undefined || arguments.length < 2) {
             return undefined;
         }
-        index = this._toAbsoluteIndex(index, this.length);
-        if (index === 0) {
+        const idx = this._toAbsoluteIndex(index, this.length);
+        if (idx === 0) {
             return this.unshift(value);
         }
-        if (index === this.length) {
+        if (idx === this.length) {
             return this.push(value);
         }
-        const prev = this._getNode(index - 1);
-        if (prev === null) {
-            return undefined;
-        }
+        const prev = this._getNode(idx - 1);
         const newNode = new Node_1.Node(value);
         this._insertAfter(prev, newNode);
-        if (this.rearrangeOnCreation) {
+        if (!this._accessOnly) {
             this._rearrange(newNode);
         }
         return this.length;
@@ -510,17 +537,17 @@ class DoublyLinkedList {
     isEmpty() {
         return this.length === 0;
     }
-    isEqual(value) {
-        if (!(this._isIterable(value))) {
+    isEqual(other) {
+        if (!this._isIterable(other)) {
             throw TypeError("The value should be iterable");
         }
-        if (this.length !== value.length) {
+        if (this.length !== other.length) {
             return false;
         }
-        const values = value.values();
-        for (const [/* index */ , node] of this._nodes(0, this.length)) {
-            const currentValue = values.next();
-            if (!(this._sameValue(node.value, currentValue.value))) {
+        const otherIterator = other[Symbol.iterator]();
+        for (const [, node] of this._nodes(0, this.length)) {
+            const otherValue = otherIterator.next();
+            if (!this._sameValue(node.value, otherValue.value)) {
                 return false;
             }
         }
@@ -530,23 +557,21 @@ class DoublyLinkedList {
         if (this.length === 0 || index === undefined) {
             return undefined;
         }
-        index = this._toAbsoluteIndex(index, this.length);
-        if (index >= this.length) {
-            return undefined;
-        }
-        const node = this._getNode(index);
-        if (node === null) {
+        const idx = this._toAbsoluteIndex(index, this.length);
+        if (idx >= this.length) {
             return undefined;
         }
+        const node = this._getNode(idx);
         const value = node.value;
         this._remove(node);
         return value;
     }
-    // Protected helping methods
+    // Protected methods
     _getIndexByNode(node) {
         let count = 0;
-        while (node.prev) {
-            node = node.prev;
+        let current = node;
+        while (current.prev) {
+            current = current.prev;
             count += 1;
         }
         return count;
@@ -555,27 +580,27 @@ class DoublyLinkedList {
         if (index < 0 || index >= this.length) {
             return null;
         }
-        let node = this.head;
+        let node = this._head;
         let counter = 0;
         while (node) {
             if (counter === index) {
                 break;
             }
             node = node.next;
-            counter = counter + 1;
+            counter += 1;
         }
         return node;
     }
     _insertFirst(newNode) {
-        this.head = newNode;
-        this.tail = newNode;
-        this.length += 1;
+        this._head = newNode;
+        this._tail = newNode;
+        this._length += 1;
     }
     _insertBefore(existingNode, newNode) {
-        if (existingNode.isEqual(this.head)) {
+        if (existingNode.isEqual(this._head)) {
             newNode.next = existingNode;
             newNode.prev = null;
-            this.head = newNode;
+            this._head = newNode;
         }
         else if (existingNode.prev !== null) {
             newNode.next = existingNode;
@@ -583,46 +608,46 @@ class DoublyLinkedList {
             existingNode.prev.next = newNode;
         }
         existingNode.prev = newNode;
-        this.length += 1;
+        this._length += 1;
     }
     _insertAfter(existingNode, newNode) {
         newNode.prev = existingNode;
-        if (existingNode.isEqual(this.tail)) {
+        if (existingNode.isEqual(this._tail)) {
             newNode.next = null;
-            this.tail = newNode;
+            this._tail = newNode;
         }
         else if (existingNode.next !== null) {
             newNode.next = existingNode.next;
             existingNode.next.prev = newNode;
         }
         existingNode.next = newNode;
-        this.length += 1;
+        this._length += 1;
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _rearrange(node) {
+    _rearrange(_node) {
         return undefined;
     }
     _remove(node) {
-        if (node.isEqual(this.head)) {
+        if (node.isEqual(this._head)) {
             this.shift();
         }
-        else if (node.isEqual(this.tail)) {
+        else if (node.isEqual(this._tail)) {
             this.pop();
         }
         else if (node.next !== null && node.prev !== null) {
             node.next.prev = node.prev;
             node.prev.next = node.next;
-            this.length -= 1;
+            this._length -= 1;
         }
     }
     _removeLast() {
-        this.head = null;
-        this.tail = null;
-        this.length = 0;
+        this._head = null;
+        this._tail = null;
+        this._length = 0;
     }
-    // Private helping methods
+    // Private methods
     *_entries() {
-        let node = this.head;
+        let node = this._head;
         let counter = 0;
         while (node) {
             yield [counter, node.value];
@@ -631,38 +656,54 @@ class DoublyLinkedList {
         }
     }
     _extend(iterable) {
-        if (!(this._isIterable(iterable))) {
+        if (!this._isIterable(iterable)) {
             throw TypeError("The value should be iterable");
         }
-        for (const currentValue of iterable) {
-            this.push(currentValue);
+        for (const value of iterable) {
+            const newNode = new Node_1.Node(value);
+            if (this.length === 0) {
+                this._insertFirst(newNode);
+            }
+            else {
+                this._insertAfter(this._tail, newNode);
+            }
         }
     }
-    _getSortCompare(comparefn) {
-        return function (x, y) {
+    _getSortCompare(compareFn) {
+        return (x, y) => {
             if (y === undefined)
                 return -1;
             if (x === undefined)
                 return 1;
-            if (comparefn !== undefined)
-                return +comparefn(x, y) || 0;
-            return String(x) > String(y) ? 1 : -1;
+            if (compareFn !== undefined)
+                return +compareFn(x, y) || 0;
+            const xStr = String(x);
+            const yStr = String(y);
+            return xStr > yStr ? 1 : xStr < yStr ? -1 : 0;
         };
     }
     _isCallable(fn) {
-        return (typeof fn === 'function');
+        return typeof fn === "function";
+    }
+    _aCallable(argument) {
+        if (this._isCallable(argument))
+            return argument;
+        const type = typeof argument;
+        const value = this._tryToString(argument);
+        const typePrefix = type !== "undefined" ? type + " " : "";
+        throw TypeError(`${typePrefix}${value} is not a function`);
     }
     _isIterable(obj) {
         if (obj == null) {
             return false;
         }
-        return typeof obj[Symbol.iterator] === 'function';
+        return typeof obj[Symbol.iterator] === "function";
     }
     _isStrictlyEqual(x, y) {
         return x === y;
     }
     *_keys() {
-        let node = this.head;
+        let node = this._head;
         let counter = 0;
         while (node) {
             yield counter;
@@ -670,15 +711,10 @@ class DoublyLinkedList {
             counter += 1;
         }
     }
-    _merge(head1, head2, comparefn) {
-        if (head1 == null) {
-            return head2;
-        }
-        else if (head2 == null) {
-            return head1;
-        }
-        let node, head;
-        if (comparefn(head1.value, head2.value) <= 0) {
+    _merge(head1, head2, compareFn) {
+        let node;
+        let head;
+        if (compareFn(head1.value, head2.value) <= 0) {
             head = node = head1;
             head1 = head1.next;
         }
@@ -687,7 +723,7 @@ class DoublyLinkedList {
             head2 = head2.next;
         }
         while (head1 !== null && head2 !== null) {
-            if (comparefn(head1.value, head2.value) <= 0) {
+            if (compareFn(head1.value, head2.value) <= 0) {
                 node.next = head1;
                 head1.prev = node;
                 node = head1;
@@ -710,13 +746,12 @@ class DoublyLinkedList {
         }
         return head;
     }
-    _mergeSort(comparefn) {
-        const lists = [];
-        let start = this.head;
-        let end;
+    _mergeSort(compareFn) {
+        let lists = [];
+        let start = this._head;
         while (start !== null) {
-            end = start;
-            while (end.next !== null && comparefn(end.value, end.next.value) <= 0) {
+            let end = start;
+            while (end.next !== null && compareFn(end.value, end.next.value) <= 0) {
                 end = end.next;
             }
             const next = end.next;
@@ -726,38 +761,79 @@ class DoublyLinkedList {
             start = next;
         }
         while (lists.length > 1) {
-            const first = lists.shift();
-            const second = lists.shift();
-            if (first !== undefined && second !== undefined) {
-                lists.push(this._merge(first, second, comparefn));
+            const merged = [];
+            for (let i = 0; i < lists.length; i += 2) {
+                if (i + 1 < lists.length) {
+                    merged.push(this._merge(lists[i], lists[i + 1], compareFn));
+                }
+                else {
+                    merged.push(lists[i]);
+                }
             }
+            lists = merged;
         }
-        this.tail = lists[0];
-        this.head = lists[0];
-        while (this.tail && this.tail.next) {
-            this.tail = this.tail.next;
+        this._tail = lists[0];
+        this._head = lists[0];
+        while (this._tail && this._tail.next) {
+            this._tail = this._tail.next;
+        }
+    }
+    _insertionSort(compareFn) {
+        let current = this._head.next;
+        while (current !== null) {
+            const next = current.next;
+            let position = current.prev;
+            while (position !== null && compareFn(position.value, current.value) > 0) {
+                position = position.prev;
+            }
+            if (position !== current.prev) {
+                if (current.prev) {
+                    current.prev.next = current.next;
+                }
+                if (current.next) {
+                    current.next.prev = current.prev;
+                }
+                else {
+                    this._tail = current.prev;
+                }
+                if (position === null) {
+                    current.prev = null;
+                    current.next = this._head;
+                    this._head.prev = current;
+                    this._head = current;
+                }
+                else {
+                    current.prev = position;
+                    current.next = position.next;
+                    if (position.next) {
+                        position.next.prev = current;
+                    }
+                    position.next = current;
+                }
+            }
+            current = next;
         }
     }
     *_nodes(startIndex, endIndex) {
-        let node = this.head;
+        let node = this._head;
         let counter = 0;
         while (node) {
             if (startIndex <= counter && counter < endIndex) {
                 yield [counter, node];
             }
             node = node.next;
-            counter = counter + 1;
+            counter += 1;
         }
     }
     *_nodesReverse(startIndex, endIndex) {
-        let node = this.tail;
+        let node = this._tail;
         let counter = this.length - 1;
         while (node) {
             if (startIndex <= counter && counter < endIndex) {
                 yield [counter, node];
             }
             node = node.prev;
-            counter = counter - 1;
+            counter -= 1;
         }
     }
     _sameValue(x, y) {
@@ -771,6 +847,8 @@ class DoublyLinkedList {
         return integer < 0 ? Math.max(integer + length, 0) : Math.min(integer, length);
     }
     _toIntegerOrInfinity(argument) {
+        if (argument === undefined)
+            return 0;
         const number = +argument;
         return number !== number || number === 0 ? 0 : Math.trunc(number);
     }
@@ -778,12 +856,12 @@ class DoublyLinkedList {
         try {
             return String(argument);
         }
-        catch (error) {
-            return 'Object';
+        catch (_a) {
+            return "Object";
         }
     }
     *_values() {
-        let node = this.head;
+        let node = this._head;
         while (node) {
             yield node.value;
             node = node.next;