solists 0.2.0

package/README.md

@@ -0,0 +1,179 @@
+# Self-organizing lists in TypeScript
+
+The library provides a powerful and flexible implementation of the [self-organizing list](https://en.wikipedia.org/wiki/Self-organizing_list) data structure written in TypeScript. It offers support for multiple heuristic algorithms such as [Frequency Count](#Frequency-Count), [Move to Front](#Move-to-Front) and [Transpose](#Transpose). In addition to custom methods, the data structure also includes a selection of methods with behavior equivalent to that of JavaScript's built-in [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) data structure.
+
+## Introduction
+
+A *self-organizing list* (aka *SoList*) is a list that reorders its elements based on some self-organizing heuristic to improve average access time. The aim of a self-organizing list is to improve efficiency of linear search by moving more frequently accessed items towards the head of the list. A self-organizing list achieves near constant time for element access in the best case. A self-organizing list uses a reorganizing algorithm to adapt to various query distributions at runtime.
+
+### Self-organizing techniques
+
+#### Frequency Count
+
+This technique involves counting the number of times each node is searched for, by keeping a separate counter variable for each node that is incremented every time the node is accessed.
+
+Pseudocode:
+```
+init: count(i) = 0 for each item i
+At t-th item selection:
+    if item i is searched:
+        count(i) = count(i) + 1
+        rearrange items based on count
+```
+
+#### Move to Front
+
+This technique moves the node which is accessed to the head of the list.
+
+Pseudocode:
+```
+At the t-th item selection:
+    if item i is selected:
+        move item i to head of the list
+```
+
+#### Transpose
+
+This technique involves swapping an accessed node with its predecessor. 
+
+Pseudocode:
+```
+At the t-th item selection:
+   if item i is selected:
+        if i is not the head of list:
+            swap item i with item (i - 1)
+```
+
+### Rearrange upon creation
+In literature, some self-organizing list implementations activate a heuristic after every creation operation (like `insert()`, `push()`, `unshift()`, etc.). This means that immediately after a new node is added to the list, the relevant heuristic is triggered and the list is rearranged.
+
+This library supports both of these approaches. By default, the list is only rearranged when searched. To activate the option for rearranging the list upon creation, use `rearrange_on_creation=true` when creating a new SoList instance. See the example below for more details.
+
+Methods which perform rearrange of the list:
+- Rearrange upon search: `at()`, `find()`, `findIndex()`, `findLast()`, `findLastIndex()`, `includes()`, `indexOf()` and `lastIndexOf`.
+- Rearrange upon creation: `constructor` (initialization from an iterable), `insert()`, `push()` and `unshift()`.
+
+## Installation
+```
+npm install solists
+```
+
+## Example
+```javascript
+const { FrequencyCountSoList, MoveToFrontSoList, TransposeSoList } = require("solists");
+
+/** Examples of SoList without rearrange upon creation **/
+
+// Example of SoList with Frequency Count heuristic
+const fcList1 = new FrequencyCountSoList(false,[1,2,3,4,5]);
+console.log(fcList1.toString()); // 1,2,3,4,5
+fcList1.includes(2);
+fcList1.includes(4);
+console.log(fcList1.toString()); // 2,4,1,3,5
+
+// Example of SoList with Move to Front heuristic
+const mtfList1 = new MoveToFrontSoList(false,[1,2,3,4,5]);
+console.log(mtfList1.toString()); // 1,2,3,4,5
+mtfList1.includes(2);
+mtfList1.includes(4);
+console.log(mtfList1.toString()); // 4,2,1,3,5
+
+// Example of SoList with Transpose heuristic
+const tList1 = new TransposeSoList(false,[1,2,3,4,5]);
+console.log(tList1.toString()); // 1,2,3,4,5
+tList1.includes(2);
+tList1.includes(4);
+console.log(tList1.toString()); // 2,1,4,3,5
+
+/** Examples of SoList with rearrange upon creation **/
+
+// Example of SoList with Frequency Count heuristic
+const fcList2 = new FrequencyCountSoList(true,[1,2,3,4,5]);
+console.log(fcList2.toString()); // 1,2,3,4,5
+fcList2.includes(2);
+fcList2.includes(4);
+console.log(fcList2.toString()); // 2,4,1,3,5
+
+// Example of SoList with Move to Front heuristic
+const mtfList2 = new MoveToFrontSoList(true,[1,2,3,4,5]);
+console.log(mtfList2.toString()); // 5,4,3,2,1
+mtfList2.includes(2);
+mtfList2.includes(4);
+console.log(mtfList2.toString()); // 4,2,5,3,1
+
+// Example of SoList with Transpose heuristic
+const tList2 = new TransposeSoList(true,[1,2,3,4,5]);
+console.log(tList2.toString()); // 2,3,4,5,1
+tList2.includes(2);
+tList2.includes(4);
+console.log(tList2.toString()); // 2,4,3,5,1
+
+```
+## Methods and properties
+
+List of properties of SoList:
+
+| Name | Description |
+| ------------- | ------------- |
+|`length`|Represents the number of elements in that SoList|
+
+List of methods of SoList:
+
+| Name | Description |
+| ------------- | ------------- |
+|`solist[Symbol.iterator]()`|Returns an iterator that yields the value of each index in the SoList|
+|`at()`|Returns the value at a given index|
+|`concat()`|Returns a new SoList consisting of merging the existing SoList with given iterable inputs|
+|`constructor`|Creates a new empty SoList instance or from a given iterable|
+|`copyWithin()`|Shallow copies part of a SoList to another location in the same SoList and returns it|
+|`entries()`|Returns a SoList iterator object of key/value pairs|
+|`every()`|Checks if every element in a SoList satisfies a predicate function|
+|`fill()`|Changes all elements in a SoList to a static value|
+|`filter()`|Creates a new SoList with every element in a SoList that satisfies a predicate function|
+|`find()`|Returns the value of the first element in a SoList that satisfies a predicate function|
+|`findIndex()`|Returns the index of the first element in a SoList that satisfies a predicate function|
+|`findLast()`|Returns the value of the last element in a SoList that satisfies a predicate function|
+|`findLastIndex()`|Returns the index of the last element in a SoList that satisfies a predicate function|
+|`flat()`|Creates a new SoList with all sub-SoList elements concatenated into it recursively up to the specified depth|
+|`forEach()`|Executes a provided function once for each SoList element|
+|`includes()`|Determines whether a SoList includes a certain value among its entries|
+|`indexOf()`|Returns the first index at which a given element can be found in a SoList|
+|`insert()`|Adds an element into a specific index of a SoList|
+|`isEqual()`|Checks if the SoList is equal to a given iterable|
+|`isEmpty()`|Checks if the SoList does not contain any elements|
+|`join()`|Joins all elements of SoList into a string separated by commas or a specified separator string|
+|`keys()`|Returns a SoList iterator object of keys|
+|`lastIndexOf()`|Returns the last index at which a given element can be found in a SoList|
+|`map()`|Creates a new SoList populated with the results of calling a provided function on every element of a SoList|
+|`pop()`|Removes the last element from a SoList and returns that element|
+|`push()`|Adds one or more elements to the end of a SoList and returns the new length of the SoList|
+|`reduce()`|Reduces the values of a SoList to a single value (going left-to-right)|
+|`reduceRight()`|Reduces the values of a SoList to a single value (going right-to-left)|
+|`remove()`|Removes an element by a specific index from a SoList|
+|`reverse()`|Reverses the order of the elements in a SoList|
+|`shift()`|removes the first element from a SoList and returns that removed element|
+|`slice()`|Returns a shallow copy of a portion of a SoList into a new SoList selected by positions|
+|`some()`|Checks if any of the elements in a SoList satisfy a predicate function|
+|`sort()`|Sorts the elements of a SoList and returns the reference to the same SoList, now sorted|
+|`splice()`|Changes the contents of a SoList by removing or replacing existing elements and/or adding new elements|
+|`toLocaleString()`|Returns a string representing the elements of the SoList using their `toLocaleString` methods|
+|`toString()`|Returns a string representing the specified SoList and its elements|
+|`unshift()`|Adds one or more elements to the beginning of a SoList and returns the new length of the SoList|
+|`values()`|Returns a SoList iterator object of values|
+
+## SoList vs JS-Array
+Although SoList implements most of the methods of JS-Array (with identical behavior), there are several differences and limitations:
+- Unlike JS-Array, SoList does not support empty items (for example `[1,,3]`).
+- Currently, the `every()`, `filter()`, `find()`, `findIndex()`, `findLast()`, `findLastIndex()`, `flatMap()` and `some()` don't support the `thisArg` argument.
+- Unsupported JS-Array methods: `group()` and `groupToMap()`.
+- Additional custom methods of SoList: `insert()`, `isEqual()`, `isEmpty()` and `remove()`.
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+Please make sure to update tests as appropriate and run existing ones using:
+
+```
+npm run test
+```

package/dist/DoublyLinkedList.d.ts

@@ -0,0 +1,72 @@
+import { Node } from './Node';
+export declare class DoublyLinkedList {
+    length: number;
+    protected head: Node | null;
+    protected tail: Node | null;
+    protected rearrangeOnCreation: boolean;
+    constructor(rearrangeOnCreation?: boolean, iterable?: null);
+    [Symbol.iterator](): Generator<any, any, unknown>;
+    at(index: number): unknown;
+    concat(...values: any[]): DoublyLinkedList;
+    copyWithin(target: any, start: any): DoublyLinkedList;
+    entries(): Generator<any, any, unknown>;
+    every(callbackFn: any): boolean;
+    fill(value: any): DoublyLinkedList;
+    filter(callbackFn: any): DoublyLinkedList;
+    find(callbackFn: any): unknown;
+    findIndex(callbackFn: any): number;
+    findLast(callbackFn: any): unknown;
+    findLastIndex(callbackFn: any): any;
+    flat(depth?: number): DoublyLinkedList;
+    flatMap(callbackFn: any): DoublyLinkedList;
+    forEach(callbackFn: any): void;
+    includes(searchedValue: any, fromIndex: any): boolean;
+    indexOf(searchedValue: any, fromIndex?: number): number;
+    join(separator: any): string;
+    keys(): Generator<number>;
+    lastIndexOf(searchElement: any): number;
+    map(callbackFn: any): DoublyLinkedList;
+    pop(): unknown;
+    push(...values: any): number;
+    reduce(callbackFn: any, initialValue: any): any;
+    reduceRight(callbackFn: any, initialValue: any): any;
+    reverse(): DoublyLinkedList;
+    shift(): unknown;
+    slice(startIndex: any, endIndex: any): DoublyLinkedList;
+    some(callbackFn: any): boolean;
+    sort(comparefn: any): DoublyLinkedList;
+    splice(start: any, deleteCount: any): DoublyLinkedList;
+    toLocaleString(locales: any, options: any): string;
+    toString(): string;
+    unshift(...values: any): number;
+    values(): Generator<any, any, unknown>;
+    insert(index: any, value: any): number | undefined;
+    isEmpty(): boolean;
+    isEqual(value: any): boolean;
+    remove(index: any): any;
+    protected _getIndexByNode(node: Node): number;
+    protected _getNode(index: number): Node | null;
+    protected _insertFirst(newNode: Node): void;
+    protected _insertBefore(existingNode: Node, newNode: Node): void;
+    protected _insertAfter(existingNode: Node, newNode: Node): void;
+    protected _rearrange(node: Node): number | undefined;
+    protected _remove(node: Node): void;
+    protected _removeLast(): void;
+    private _entries;
+    private _extend;
+    private _getSortCompare;
+    private _isCallable;
+    private _isIterable;
+    private _isStrictlyEqual;
+    private _keys;
+    private _merge;
+    private _mergeSort;
+    private _nodes;
+    private _nodesReverse;
+    private _sameValue;
+    private _sameValueZero;
+    private _toAbsoluteIndex;
+    private _toIntegerOrInfinity;
+    private _tryToString;
+    private _values;
+}

package/dist/DoublyLinkedList.js

@@ -0,0 +1,793 @@
+"use strict";
+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;
+        if (iterable !== null) {
+            this._extend(iterable);
+        }
+    }
+    [Symbol.iterator]() {
+        return this._values();
+    }
+    // Public Array-like 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);
+                }
+            }
+            else {
+                result.push(value);
+            }
+        }
+        return result;
+    }
+    copyWithin(target /* = 0 */, start /* = 0, end = @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;
+        }
+        return this;
+    }
+    entries() {
+        return this._entries();
+    }
+    // TODO: Support "thisArg" argument
+    every(callbackFn) {
+        for (const [index, node] of this._nodes(0, this.length)) {
+            if (!(callbackFn(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)) {
+            node.value = value;
+        }
+        return this;
+    }
+    // TODO: Support "thisArg" argument
+    filter(callbackFn) {
+        const result = new DoublyLinkedList();
+        for (const [index, node] of this._nodes(0, this.length)) {
+            if (callbackFn(node.value, index, this)) {
+                result.push(node.value);
+            }
+        }
+        return result;
+    }
+    // TODO: Support "thisArg" argument
+    find(callbackFn) {
+        for (const [index, node] of this._nodes(0, this.length)) {
+            if (callbackFn(node.value, index, this)) {
+                node.count += 1;
+                this._rearrange(node);
+                return node.value;
+            }
+        }
+        return undefined;
+    }
+    // TODO: Support "thisArg" argument
+    findIndex(callbackFn) {
+        for (const [index, node] of this._nodes(0, this.length)) {
+            if (callbackFn(node.value, index, this)) {
+                node.count += 1;
+                const result = this._rearrange(node);
+                return (result === undefined) ? index : result;
+            }
+        }
+        return -1;
+    }
+    // TODO: Support "thisArg" argument
+    findLast(callbackFn) {
+        for (const [index, node] of this._nodesReverse(0, this.length)) {
+            if (callbackFn(node.value, index, this)) {
+                node.count += 1;
+                this._rearrange(node);
+                return node.value;
+            }
+        }
+        return undefined;
+    }
+    // TODO: Support "thisArg" argument
+    findLastIndex(callbackFn) {
+        for (const [index, node] of this._nodesReverse(0, this.length)) {
+            if (callbackFn(node.value, index, this)) {
+                node.count += 1;
+                const result = this._rearrange(node);
+                return (result === undefined) ? index : result;
+            }
+        }
+        return -1;
+    }
+    flat(depth = 1) {
+        depth = this._toIntegerOrInfinity(depth);
+        if (depth < 1) {
+            return this.slice(0, this.length);
+        }
+        return this.reduce(function (flat, toFlatten) {
+            return flat.concat(((toFlatten instanceof DoublyLinkedList) && (depth > 1)) ? toFlatten.flat(depth - 1) : toFlatten);
+        }, new DoublyLinkedList());
+    }
+    // TODO: Support "thisArg" argument
+    flatMap(callbackFn) {
+        return this.map(callbackFn).flat();
+    }
+    forEach(callbackFn) {
+        for (const [index, node] of this._nodes(0, this.length)) {
+            callbackFn(node.value, index, this);
+        }
+        return undefined;
+    }
+    includes(searchedValue, 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)) {
+                node.count += 1;
+                this._rearrange(node);
+                return true;
+            }
+        }
+        return false;
+    }
+    indexOf(searchedValue, fromIndex = 0) {
+        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)) {
+                node.count += 1;
+                const result = this._rearrange(node);
+                return (result === undefined) ? index : result;
+            }
+        }
+        return -1;
+    }
+    join(separator) {
+        let result = '';
+        if (this.length === 0) {
+            return result;
+        }
+        if (separator === undefined) {
+            separator = ',';
+        }
+        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);
+            }
+        }
+        return result;
+    }
+    keys() {
+        return this._keys();
+    }
+    lastIndexOf(searchElement /* , fromIndex = @[*-1] */) {
+        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;
+        }
+        for (const [index, node] of this._nodesReverse(0, fromIndex + 1)) {
+            if (this._isStrictlyEqual(node.value, searchElement)) {
+                node.count += 1;
+                const result = this._rearrange(node);
+                return (result === undefined) ? index : result;
+            }
+        }
+        return -1;
+    }
+    map(callbackFn) {
+        const result = new DoublyLinkedList();
+        for (const [index, node] of this._nodes(0, this.length)) {
+            result.push(callbackFn(node.value, index, this));
+        }
+        return result;
+    }
+    pop() {
+        if (this.length === 0) {
+            return undefined;
+        }
+        const value = this.tail.value;
+        if (this.length === 1) {
+            this._removeLast();
+        }
+        else {
+            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]);
+            if (this.length === 0) {
+                this._insertFirst(newNode);
+            }
+            else if (this.tail !== null) {
+                this._insertAfter(this.tail, newNode);
+            }
+            else {
+                continue;
+            }
+            if (this.rearrangeOnCreation) {
+                this._rearrange(newNode);
+            }
+        }
+        return this.length;
+    }
+    reduce(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');
+        }
+        let accumulator = arguments.length > 1 ? 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);
+            }
+        }
+        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');
+        }
+        let accumulator = arguments.length > 1 ? 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);
+            }
+        }
+        return accumulator;
+    }
+    reverse() {
+        if (this.length > 1) {
+            let curr = this.head;
+            while (curr) {
+                const next = curr.next;
+                curr.next = curr.prev;
+                curr.prev = next;
+                if (curr.next === null) {
+                    this.tail = curr;
+                }
+                else if (curr.prev === null) {
+                    this.head = curr;
+                }
+                curr = next;
+            }
+        }
+        return this;
+    }
+    shift() {
+        if (this.length === 0) {
+            return undefined;
+        }
+        const value = this.head.value;
+        if (this.length === 1) {
+            this._removeLast();
+        }
+        else {
+            this.head = this.head.next;
+            this.head.prev = null;
+            this.length -= 1;
+        }
+        return value;
+    }
+    slice(startIndex, endIndex) {
+        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)) {
+            result.push(node.value);
+        }
+        return result;
+    }
+    // TODO: Support "thisArg" argument
+    some(callbackFn) {
+        for (const [index, node] of this._nodes(0, this.length)) {
+            if (callbackFn(node.value, index, this)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    sort(comparefn) {
+        if (this.length > 1) {
+            this._mergeSort(this._getSortCompare(comparefn));
+        }
+        return this;
+    }
+    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);
+        }
+        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) {
+                deleted.push(current.value);
+                current = current.next;
+                this.length -= 1;
+            }
+            if (prev === null) {
+                this.head = current;
+                prev = current;
+                if (current) {
+                    current.prev = null;
+                }
+            }
+            else {
+                prev.next = current;
+                if (current) {
+                    current.prev = prev;
+                }
+                else {
+                    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;
+            }
+            else {
+                current = this._getNode(start - 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;
+            }
+            current.next = next;
+            if (next) {
+                next.prev = current;
+            }
+            else {
+                this.tail = current;
+            }
+        }
+        return deleted;
+    }
+    toLocaleString(locales, options) {
+        let result = '';
+        if (this.length === 0) {
+            return result;
+        }
+        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;
+                }
+            }
+            else {
+                if (locales == null || options == null) {
+                    result = result.concat(value.toLocaleString());
+                }
+                else {
+                    result = result.concat(value.toLocaleString(locales, options));
+                }
+            }
+        }
+        return result;
+    }
+    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]);
+            if (this.length === 0) {
+                this._insertFirst(newNode);
+            }
+            else if (this.head !== null) {
+                this._insertBefore(this.head, newNode);
+            }
+            else {
+                continue;
+            }
+            if (this.rearrangeOnCreation) {
+                this._rearrange(newNode);
+            }
+        }
+        return this.length;
+    }
+    values() {
+        return this._values();
+    }
+    // Public custom methods
+    insert(index, value) {
+        if (index === undefined || arguments.length < 2) {
+            return undefined;
+        }
+        index = this._toAbsoluteIndex(index, this.length);
+        if (index === 0) {
+            return this.unshift(value);
+        }
+        if (index === this.length) {
+            return this.push(value);
+        }
+        const prev = this._getNode(index - 1);
+        if (prev === null) {
+            return undefined;
+        }
+        const newNode = new Node_1.Node(value);
+        this._insertAfter(prev, newNode);
+        if (this.rearrangeOnCreation) {
+            this._rearrange(newNode);
+        }
+        return this.length;
+    }
+    isEmpty() {
+        return this.length === 0;
+    }
+    isEqual(value) {
+        if (!(this._isIterable(value))) {
+            throw TypeError("The value should be iterable");
+        }
+        if (this.length !== value.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))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    remove(index) {
+        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) {
+            return undefined;
+        }
+        const value = node.value;
+        this._remove(node);
+        return value;
+    }
+    // Protected helping methods
+    _getIndexByNode(node) {
+        let count = 0;
+        while (node.prev) {
+            node = node.prev;
+            count += 1;
+        }
+        return count;
+    }
+    _getNode(index) {
+        if (index < 0 || index >= this.length) {
+            return null;
+        }
+        let node = this.head;
+        let counter = 0;
+        while (node) {
+            if (counter === index) {
+                break;
+            }
+            node = node.next;
+            counter = counter + 1;
+        }
+        return node;
+    }
+    _insertFirst(newNode) {
+        this.head = newNode;
+        this.tail = newNode;
+        this.length += 1;
+    }
+    _insertBefore(existingNode, newNode) {
+        if (existingNode.isEqual(this.head)) {
+            newNode.next = existingNode;
+            newNode.prev = null;
+            this.head = newNode;
+        }
+        else if (existingNode.prev !== null) {
+            newNode.next = existingNode;
+            newNode.prev = existingNode.prev;
+            existingNode.prev.next = newNode;
+        }
+        existingNode.prev = newNode;
+        this.length += 1;
+    }
+    _insertAfter(existingNode, newNode) {
+        newNode.prev = existingNode;
+        if (existingNode.isEqual(this.tail)) {
+            newNode.next = null;
+            this.tail = newNode;
+        }
+        else if (existingNode.next !== null) {
+            newNode.next = existingNode.next;
+            existingNode.next.prev = newNode;
+        }
+        existingNode.next = newNode;
+        this.length += 1;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _rearrange(node) {
+        return undefined;
+    }
+    _remove(node) {
+        if (node.isEqual(this.head)) {
+            this.shift();
+        }
+        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;
+        }
+    }
+    _removeLast() {
+        this.head = null;
+        this.tail = null;
+        this.length = 0;
+    }
+    // Private helping methods
+    *_entries() {
+        let node = this.head;
+        let counter = 0;
+        while (node) {
+            yield [counter, node.value];
+            node = node.next;
+            counter += 1;
+        }
+    }
+    _extend(iterable) {
+        if (!(this._isIterable(iterable))) {
+            throw TypeError("The value should be iterable");
+        }
+        for (const currentValue of iterable) {
+            this.push(currentValue);
+        }
+    }
+    _getSortCompare(comparefn) {
+        return function (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;
+        };
+    }
+    _isCallable(fn) {
+        return (typeof fn === 'function');
+    }
+    _isIterable(obj) {
+        if (obj == null) {
+            return false;
+        }
+        return typeof obj[Symbol.iterator] === 'function';
+    }
+    _isStrictlyEqual(x, y) {
+        return x === y;
+    }
+    *_keys() {
+        let node = this.head;
+        let counter = 0;
+        while (node) {
+            yield counter;
+            node = node.next;
+            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) {
+            head = node = head1;
+            head1 = head1.next;
+        }
+        else {
+            head = node = head2;
+            head2 = head2.next;
+        }
+        while (head1 !== null && head2 !== null) {
+            if (comparefn(head1.value, head2.value) <= 0) {
+                node.next = head1;
+                head1.prev = node;
+                node = head1;
+                head1 = head1.next;
+            }
+            else {
+                node.next = head2;
+                head2.prev = node;
+                node = head2;
+                head2 = head2.next;
+            }
+        }
+        if (head1 !== null) {
+            node.next = head1;
+            head1.prev = node;
+        }
+        else if (head2 !== null) {
+            node.next = head2;
+            head2.prev = node;
+        }
+        return head;
+    }
+    _mergeSort(comparefn) {
+        const lists = [];
+        let start = this.head;
+        let end;
+        while (start !== null) {
+            end = start;
+            while (end.next !== null && comparefn(end.value, end.next.value) <= 0) {
+                end = end.next;
+            }
+            const next = end.next;
+            start.prev = null;
+            end.next = null;
+            lists.push(start);
+            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));
+            }
+        }
+        this.tail = lists[0];
+        this.head = lists[0];
+        while (this.tail && this.tail.next) {
+            this.tail = this.tail.next;
+        }
+    }
+    *_nodes(startIndex, endIndex) {
+        let node = this.head;
+        let counter = 0;
+        while (node) {
+            if (startIndex <= counter && counter < endIndex) {
+                yield [counter, node];
+            }
+            node = node.next;
+            counter = counter + 1;
+        }
+    }
+    *_nodesReverse(startIndex, endIndex) {
+        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;
+        }
+    }
+    _sameValue(x, y) {
+        return Object.is(x, y);
+    }
+    _sameValueZero(x, y) {
+        return x === y || (Number.isNaN(x) && Number.isNaN(y));
+    }
+    _toAbsoluteIndex(index, length) {
+        const integer = this._toIntegerOrInfinity(index);
+        return integer < 0 ? Math.max(integer + length, 0) : Math.min(integer, length);
+    }
+    _toIntegerOrInfinity(argument) {
+        const number = +argument;
+        return number !== number || number === 0 ? 0 : Math.trunc(number);
+    }
+    _tryToString(argument) {
+        try {
+            return String(argument);
+        }
+        catch (error) {
+            return 'Object';
+        }
+    }
+    *_values() {
+        let node = this.head;
+        while (node) {
+            yield node.value;
+            node = node.next;
+        }
+    }
+}
+exports.DoublyLinkedList = DoublyLinkedList;

package/dist/FrequencyCountSoList.d.ts

@@ -0,0 +1,6 @@
+import { DoublyLinkedList } from './DoublyLinkedList';
+import { Node } from './Node';
+export declare class FrequencyCountSoList extends DoublyLinkedList {
+    constructor(...args: any);
+    protected _rearrange(node: Node): number;
+}

package/dist/FrequencyCountSoList.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrequencyCountSoList = void 0;
+const DoublyLinkedList_1 = require("./DoublyLinkedList");
+class FrequencyCountSoList extends DoublyLinkedList_1.DoublyLinkedList {
+    constructor(...args) {
+        super(...args);
+    }
+    _rearrange(node) {
+        let prev = node.prev;
+        let next = node.next;
+        if (prev !== null && prev.count < node.count) {
+            while (!(node.isEqual(this.head))) {
+                if (prev !== null && prev.count < node.count) {
+                    this._remove(node);
+                    this._insertBefore(prev, node);
+                }
+                else {
+                    break;
+                }
+                prev = node.prev;
+            }
+        }
+        else if (next !== null && next.count > node.count) {
+            while (!(node.isEqual(this.tail))) {
+                if (next !== null && next.count > node.count) {
+                    this._remove(node);
+                    this._insertAfter(next, node);
+                }
+                else {
+                    break;
+                }
+                next = node.next;
+            }
+        }
+        return this._getIndexByNode(node);
+    }
+}
+exports.FrequencyCountSoList = FrequencyCountSoList;

package/dist/MoveToFrontSoList.d.ts

@@ -0,0 +1,6 @@
+import { DoublyLinkedList } from './DoublyLinkedList';
+import { Node } from './Node';
+export declare class MoveToFrontSoList extends DoublyLinkedList {
+    constructor(...args: any);
+    protected _rearrange(node: Node): number;
+}

package/dist/MoveToFrontSoList.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveToFrontSoList = void 0;
+const DoublyLinkedList_1 = require("./DoublyLinkedList");
+class MoveToFrontSoList extends DoublyLinkedList_1.DoublyLinkedList {
+    constructor(...args) {
+        super(...args);
+    }
+    _rearrange(node) {
+        if (!(node.isEqual(this.head))) {
+            if (this.head !== null) {
+                this._remove(node);
+                this._insertBefore(this.head, node);
+            }
+        }
+        return this._getIndexByNode(node);
+    }
+}
+exports.MoveToFrontSoList = MoveToFrontSoList;

package/dist/Node.d.ts

@@ -0,0 +1,8 @@
+export declare class Node {
+    value: unknown;
+    next: Node | null;
+    prev: Node | null;
+    count: number;
+    constructor(value: unknown, next?: null, prev?: null);
+    isEqual(other: Node | null): boolean;
+}

package/dist/Node.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = void 0;
+class Node {
+    constructor(value, next = null, prev = null) {
+        this.value = value;
+        this.next = next;
+        this.prev = prev;
+        this.count = 0;
+    }
+    isEqual(other) {
+        return this === other;
+    }
+}
+exports.Node = Node;

package/dist/TransposeSoList.d.ts

@@ -0,0 +1,6 @@
+import { DoublyLinkedList } from './DoublyLinkedList';
+import { Node } from './Node';
+export declare class TransposeSoList extends DoublyLinkedList {
+    constructor(...args: any);
+    protected _rearrange(node: Node): number;
+}

package/dist/TransposeSoList.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransposeSoList = void 0;
+const DoublyLinkedList_1 = require("./DoublyLinkedList");
+class TransposeSoList extends DoublyLinkedList_1.DoublyLinkedList {
+    constructor(...args) {
+        super(...args);
+    }
+    _rearrange(node) {
+        if (!(node.isEqual(this.head))) {
+            const prev = node.prev;
+            if (prev !== null) {
+                this._remove(node);
+                this._insertBefore(prev, node);
+            }
+        }
+        return this._getIndexByNode(node);
+    }
+}
+exports.TransposeSoList = TransposeSoList;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { FrequencyCountSoList } from './FrequencyCountSoList';
+import { MoveToFrontSoList } from './MoveToFrontSoList';
+import { TransposeSoList } from './TransposeSoList';
+export { FrequencyCountSoList, MoveToFrontSoList, TransposeSoList };

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransposeSoList = exports.MoveToFrontSoList = exports.FrequencyCountSoList = void 0;
+const FrequencyCountSoList_1 = require("./FrequencyCountSoList");
+Object.defineProperty(exports, "FrequencyCountSoList", { enumerable: true, get: function () { return FrequencyCountSoList_1.FrequencyCountSoList; } });
+const MoveToFrontSoList_1 = require("./MoveToFrontSoList");
+Object.defineProperty(exports, "MoveToFrontSoList", { enumerable: true, get: function () { return MoveToFrontSoList_1.MoveToFrontSoList; } });
+const TransposeSoList_1 = require("./TransposeSoList");
+Object.defineProperty(exports, "TransposeSoList", { enumerable: true, get: function () { return TransposeSoList_1.TransposeSoList; } });

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "solists",
+  "version": "0.2.0",
+  "description": "Implementation of self-organizing lists",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rimraf ./dist",
+    "coverage": "nyc --reporter=html ts-mocha tests/test.ts",
+    "lint": "eslint ./src ./tests",
+    "test": "ts-mocha tests/test.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/emmanuel-ferdman/solists.git"
+  },
+  "keywords": [
+    "data-structure",
+    "self-organizing-list"
+  ],
+  "author": "Emmanuel Ferdman",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/emmanuel-ferdman/solists/issues"
+  },
+  "homepage": "https://github.com/emmanuel-ferdman/solists#readme",
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.46.0",
+    "@typescript-eslint/parser": "^5.46.0",
+    "eslint": "^8.29.0",
+    "nyc": "^15.1.0",
+    "ts-mocha": "^10.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.4"
+  },
+  "files": [
+    "dist"
+  ]
+}