solists 0.2.0 → 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2023 Emmanuel Ferdman
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,179 +1,213 @@
-# Self-organizing lists in TypeScript
+<p align="center">
+  <a href="https://github.com/emmanuel-ferdman/solists">
+    <picture>
+      <img src="https://raw.githubusercontent.com/emmanuel-ferdman/solists/main/img/logo.png" height="128">
+    </picture>
+  </a>
+</p>
+
+<p align="center">
+  A TypeScript implementation of <a href="https://en.wikipedia.org/wiki/Self-organizing_list">self-organizing lists</a> with native Array methods.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/solists"><img src="https://img.shields.io/npm/v/solists.svg" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/solists"><img src="https://img.shields.io/npm/dm/solists.svg" alt="npm downloads"></a>
+  <a href="https://github.com/emmanuel-ferdman/solists/actions"><img src="https://github.com/emmanuel-ferdman/solists/workflows/CI/badge.svg" alt="CI"></a>
+  <a href="https://codecov.io/gh/emmanuel-ferdman/solists"><img src="https://codecov.io/gh/emmanuel-ferdman/solists/graph/badge.svg" alt="Coverage"></a>
+  <a href="https://github.com/emmanuel-ferdman/solists/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/solists.svg" alt="License"></a>
+</p>
 
-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
+## Installation
 
-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.
+```sh
+npm install solists
+```
 
-### Self-organizing techniques
+## Example
 
-#### Frequency Count
+<table width="100%">
+<tr>
+<th align="left">Code</th>
+<th align="left">Visualization</th>
+</tr>
+<tr>
+<td>
 
-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.
+```javascript
+const { FrequencyCountSoList } = require("solists");
 
-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
+const l = new FrequencyCountSoList(["A", "B", "C", "D", "E"]);
+l.includes("D"); // D(1) -> front
+l.includes("B"); // B(1) -> #2
+l.includes("B"); // B(2) overtakes D
+// Result: ["B", "D", "A", "C", "E"]
 ```
 
-#### Move to Front
+</td>
+<td align="center" valign="middle">
+<img src="https://raw.githubusercontent.com/emmanuel-ferdman/solists/main/img/frequency-count.gif" width="400">
+</td>
+</tr>
+<tr>
+<td>
 
-This technique moves the node which is accessed to the head of the list.
+```javascript
+const { KInARowSoList } = require("solists");
 
-Pseudocode:
+const l = new KInARowSoList(["A", "B", "C", "D", "E"], { k: 2 });
+l.includes("D"); // D: 1st access, no move
+l.includes("D"); // D: 2nd access, -> front
+l.includes("B"); // B: 1st access, no move
+// Result: ["D", "A", "B", "C", "E"]
 ```
-At the t-th item selection:
-    if item i is selected:
-        move item i to head of the list
+
+</td>
+<td align="center" valign="middle">
+<img src="https://raw.githubusercontent.com/emmanuel-ferdman/solists/main/img/k-in-a-row.gif" width="400">
+</td>
+</tr>
+<tr>
+<td>
+
+```javascript
+const { MoveAheadKSoList } = require("solists");
+
+const l = new MoveAheadKSoList(["A", "B", "C", "D", "E"], { k: 2 });
+l.includes("D"); // D moves 2 ahead
+l.includes("E"); // E moves 2 ahead
+l.includes("B"); // B moves 2 ahead
+// Result: ["A", "B", "D", "E", "C"]
 ```
 
-#### Transpose
+</td>
+<td align="center" valign="middle">
+<img src="https://raw.githubusercontent.com/emmanuel-ferdman/solists/main/img/move-ahead-k.gif" width="400">
+</td>
+</tr>
+<tr>
+<td>
 
-This technique involves swapping an accessed node with its predecessor. 
+```javascript
+const { MoveToFrontSoList } = require("solists");
 
-Pseudocode:
+const l = new MoveToFrontSoList(["A", "B", "C", "D", "E"]);
+l.includes("D"); // D -> front
+l.includes("B"); // B -> front
+l.includes("C"); // C -> front
+// Result: ["C", "B", "D", "A", "E"]
 ```
-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)
+
+</td>
+<td align="center" valign="middle">
+<img src="https://raw.githubusercontent.com/emmanuel-ferdman/solists/main/img/move-to-front.gif" width="400">
+</td>
+</tr>
+<tr>
+<td>
+
+```javascript
+const { TransposeSoList } = require("solists");
+
+const l = new TransposeSoList(["A", "B", "C", "D", "E"]);
+l.includes("D"); // D swaps with C
+l.includes("E"); // E swaps with C
+l.includes("B"); // B swaps with A
+// Result: ["B", "A", "D", "E", "C"]
 ```
 
-### 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.
+</td>
+<td align="center" valign="middle">
+<img src="https://raw.githubusercontent.com/emmanuel-ferdman/solists/main/img/transpose.gif" width="400">
+</td>
+</tr>
+</table>
 
-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.
+## How It Works
 
-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()`.
+A self-organizing list (or _SoList_) reorders elements based on access patterns to improve search efficiency. Frequently accessed items move toward the head, achieving near constant-time access in the best case.
 
-## Installation
-```
-npm install solists
-```
+**Supported heuristics:**
 
-## 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
+- **Frequency Count** - Accessed elements ordered by access count
+- **k-in-a-Row** - Accessed element moves to front after k consecutive accesses
+- **Move-Ahead-k** - Accessed element moves k positions toward the head
+- **Move to Front** - Accessed element moves directly to the head
+- **Transpose** - Accessed element swaps with its predecessor
+
+### Access Only Mode
+
+By default (`accessOnly: true`), the list only rearranges on search operations. To also rearrange when adding elements, set `accessOnly: false`:
 
+```javascript
+const l = new MoveToFrontSoList([1, 2, 3], { accessOnly: false });
 ```
-## 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()`.
+
+**Methods that trigger rearrangement:**
+
+- Always: `at()`, `find()`, `findIndex()`, `findLast()`, `findLastIndex()`, `includes()`, `indexOf()`, `lastIndexOf()`
+- When `accessOnly: false`: `push()`, `unshift()`, `insert()`
+
+## API
+
+**Properties:**
+
+| Name     | Description                    |
+| :------- | :----------------------------- |
+| `length` | Number of elements in the list |
+
+**Methods:**
+
+| Name                  | Description                                                   |
+| :-------------------- | :------------------------------------------------------------ |
+| `[Symbol.iterator]()` | Returns an iterator that yields each value                    |
+| `at()`                | Returns the value at a given index                            |
+| `concat()`            | Returns a new SoList merged with given iterables              |
+| `copyWithin()`        | Shallow copies part of list to another location               |
+| `entries()`           | Returns an iterator of key/value pairs                        |
+| `every()`             | Checks if every element satisfies a predicate                 |
+| `fill()`              | Changes all elements to a static value                        |
+| `filter()`            | Creates a new SoList with elements satisfying a predicate     |
+| `find()`              | Returns the first element satisfying a predicate              |
+| `findIndex()`         | Returns the index of the first element satisfying a predicate |
+| `findLast()`          | Returns the last element satisfying a predicate               |
+| `findLastIndex()`     | Returns the index of the last element satisfying a predicate  |
+| `flat()`              | Creates a new SoList with sub-lists flattened                 |
+| `flatMap()`           | Maps then flattens the result by one level                    |
+| `forEach()`           | Executes a function for each element                          |
+| `includes()`          | Determines whether a value exists in the list                 |
+| `indexOf()`           | Returns the first index of a given element                    |
+| `insert()`            | Adds an element at a specific index                           |
+| `isEmpty()`           | Checks if the list contains no elements                       |
+| `isEqual()`           | Checks if the list equals a given iterable                    |
+| `join()`              | Joins all elements into a string                              |
+| `keys()`              | Returns an iterator of keys                                   |
+| `lastIndexOf()`       | Returns the last index of a given element                     |
+| `map()`               | Creates a new SoList with mapped values                       |
+| `pop()`               | Removes and returns the last element                          |
+| `push()`              | Adds elements to the end                                      |
+| `reduce()`            | Reduces values to a single value (left-to-right)              |
+| `reduceRight()`       | Reduces values to a single value (right-to-left)              |
+| `remove()`            | Removes the element at a specific index                       |
+| `reverse()`           | Reverses the order of elements                                |
+| `shift()`             | Removes and returns the first element                         |
+| `slice()`             | Returns a shallow copy of a portion                           |
+| `some()`              | Checks if any element satisfies a predicate                   |
+| `sort()`              | Sorts the elements                                            |
+| `splice()`            | Adds/removes elements                                         |
+| `toLocaleString()`    | Returns a localized string representation                     |
+| `toReversed()`        | Returns a reversed copy                                       |
+| `toSorted()`          | Returns a sorted copy                                         |
+| `toSpliced()`         | Returns a spliced copy                                        |
+| `toString()`          | Returns a string representation                               |
+| `unshift()`           | Adds elements to the beginning                                |
+| `values()`            | Returns an iterator of values                                 |
+| `with()`              | Returns copy with element at index replaced                   |
 
 ## Contributing
 
-Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change. For contribution guidelines, see [CONTRIBUTING.md](CONTRIBUTING.md).
 
-Please make sure to update tests as appropriate and run existing ones using:
+## License
 
-```
-npm run test
-```
+The library is freely distributable under the terms of the [MIT license](LICENSE).

package/dist/DoublyLinkedList.d.ts

@@ -1,66 +1,83 @@
-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;
+import { Node } from "./Node";
+export interface SoListOptions {
+    accessOnly?: boolean;
+}
+export declare class DoublyLinkedList<T, O extends SoListOptions = SoListOptions> {
+    protected _accessOnly: boolean;
+    protected _head: Node<T> | null;
+    protected _options: O;
+    protected _tail: Node<T> | null;
+    private _length;
+    constructor(iterable?: Iterable<T> | null, options?: O);
+    [Symbol.iterator](): Generator<T>;
+    at(index: number): T | undefined;
+    concat(...items: (T | ConcatArray<T>)[]): DoublyLinkedList<T>;
+    copyWithin(target: number, start: number, end?: number): this;
+    entries(): Generator<[number, T]>;
+    every(predicate: (value: T, index: number, list: DoublyLinkedList<T>) => unknown, thisArg?: any): boolean;
+    fill(value: T, start?: number, end?: number): this;
+    filter(predicate: (value: T, index: number, list: DoublyLinkedList<T>) => unknown, thisArg?: any): DoublyLinkedList<T>;
+    find(predicate: (value: T, index: number, list: DoublyLinkedList<T>) => unknown, thisArg?: any): T | undefined;
+    findIndex(predicate: (value: T, index: number, list: DoublyLinkedList<T>) => unknown, thisArg?: any): number;
+    findLast(predicate: (value: T, index: number, list: DoublyLinkedList<T>) => unknown, thisArg?: any): T | undefined;
+    findLastIndex(predicate: (value: T, index: number, list: DoublyLinkedList<T>) => unknown, thisArg?: any): number;
+    flat<D extends number = 1>(depth?: D): DoublyLinkedList<unknown>;
+    flatMap<U>(callback: (value: T, index: number, list: DoublyLinkedList<T>) => U | ReadonlyArray<U>, thisArg?: any): DoublyLinkedList<U>;
+    forEach(callbackfn: (value: T, index: number, list: DoublyLinkedList<T>) => void, thisArg?: any): void;
+    includes(searchElement: T, fromIndex?: number): boolean;
+    indexOf(searchElement: T, fromIndex?: number): number;
+    join(separator?: string): 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;
+    get length(): number;
+    lastIndexOf(searchElement: T, fromIndex?: any): number;
+    map<U>(callbackfn: (value: T, index: number, list: DoublyLinkedList<T>) => U, thisArg?: any): DoublyLinkedList<U>;
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, list: DoublyLinkedList<T>) => T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, list: DoublyLinkedList<T>) => T, initialValue: T): T;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, list: DoublyLinkedList<T>) => U, initialValue: U): U;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, list: DoublyLinkedList<T>) => T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, list: DoublyLinkedList<T>) => T, initialValue: T): T;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, list: DoublyLinkedList<T>) => U, initialValue: U): U;
+    reverse(): this;
+    shift(): T | undefined;
+    slice(start?: any, end?: any): DoublyLinkedList<T>;
+    some(predicate: (value: T, index: number, list: DoublyLinkedList<T>) => unknown, thisArg?: any): boolean;
+    sort(compareFn?: (a: T, b: T) => number): this;
+    splice(start?: any, deleteCount?: any, ...items: T[]): DoublyLinkedList<T>;
+    toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+    toReversed(): DoublyLinkedList<T>;
+    toSorted(compareFn?: (a: T, b: T) => number): DoublyLinkedList<T>;
+    toSpliced(start?: any, deleteCount?: any, ...items: T[]): DoublyLinkedList<T>;
     toString(): string;
-    unshift(...values: any): number;
-    values(): Generator<any, any, unknown>;
-    insert(index: any, value: any): number | undefined;
+    unshift(...items: T[]): number;
+    values(): Generator<T>;
+    with(index: number, value: T): DoublyLinkedList<T>;
+    insert(index: any, value: T): 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;
+    isEqual(other: Iterable<T> & {
+        length: number;
+    }): boolean;
+    remove(index: number): T | undefined;
+    protected _getIndexByNode(node: Node<T>): number;
+    protected _getNode(index: number): Node<T> | null;
+    protected _insertFirst(newNode: Node<T>): void;
+    protected _insertBefore(existingNode: Node<T>, newNode: Node<T>): void;
+    protected _insertAfter(existingNode: Node<T>, newNode: Node<T>): void;
+    protected _rearrange(_node: Node<T>): number | undefined;
+    protected _remove(node: Node<T>): void;
     protected _removeLast(): void;
     private _entries;
     private _extend;
     private _getSortCompare;
     private _isCallable;
+    private _aCallable;
     private _isIterable;
     private _isStrictlyEqual;
     private _keys;
     private _merge;
     private _mergeSort;
+    private _insertionSort;
     private _nodes;
     private _nodesReverse;
     private _sameValue;