Init

node_modules/sweet-collections/.eslintrc.json

@@ -0,0 +1,24 @@
+{
+  "env": {
+    "browser": true,
+    "commonjs": true,
+    "es2021": true,
+    "jest/globals": true,
+    "node": true
+  },
+  "extends": [
+    "standard",
+    "prettier"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": 2018
+  },
+  "plugins": [
+    "@typescript-eslint",
+    "jest"
+  ],
+  "ignorePatterns": ["dist/**/*.js"],
+  "rules": {
+  }
+}

node_modules/sweet-collections/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Nasreddine Bac Ali
+
+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.

node_modules/sweet-collections/README.md

@@ -0,0 +1,302 @@
+# Sweet Collections
+
+![Build](https://github.com/bacali95/sweet-collections/workflows/Build/badge.svg)
+[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
+![Coverage](coverage/badge.svg)
+[![npm version](https://badge.fury.io/js/sweet-collections.svg)](https://badge.fury.io/js/sweet-collections)
+
+Typescript implementations of in-memory cache data-structures for Node and Browser. These data-structures are:
+
+- **LruMap**: A fixed size `Map` which removes the least recently used entry.
+- **LruSet**: A fixed size `Set` which removes the least recently used entry. (Backed by a `LruMap`)
+- **LfuMap**: A fixed size `Map` which removes the least frequently used entry.
+- **LfuSet**: A fixed size `Set` which removes the least frequently used entry. (Backed by a `LfuMap`)
+- **SortedArray**: An `Array` that stays sorted after any modification.
+- **SortedMap**: A `Map` with entries stays sorted by key after any modification. (Backed by a `SortedArray`)
+- **SortedSet**: A `Set` with entries stays sorted after any modification. (Backed by a `SortedArray`)
+- **Heap**: A collection that have always the largest, smallest or most relevant value on top.
+- **Stack**: A collection that have always the last added value on top.
+- **Queue**: A collection that have always the first added value on top.
+
+## Install
+
+```sh
+npm install --save sweet-collections
+```
+
+or
+
+```sh
+yarn add sweet-collections
+```
+
+## Usage
+
+<details>
+    <summary>LruMap</summary>
+
+```Typescript
+import { LruMap } from 'sweet-collections';
+
+const map = new LruMap<number, number>(3);
+map.set(1, 1);
+map.set(2, 2);
+map.set(3, 3);              // least recent used: 1
+console.log(map.has(1))     // true, least recent used: 2
+console.log(map.get(2))     // 1, least recent used: 3
+
+map.set(4, 4);
+console.log(map.has(3))     // false
+console.log(map.get(3))     // undefined
+
+console.log(map.isFull())   // true
+map.delete(1);
+console.log(map.size)       // 2
+
+map.clear();
+console.log(map.size)       // 0
+```
+
+</details>
+
+<details>
+    <summary>LruSet</summary>
+
+```Typescript
+import { LruSet } from 'sweet-collections';
+
+const set = new LruSet<number>(3);
+set.add(1);
+set.add(2);
+set.add(3);                 // least recent used: 1
+console.log(set.has(1))     // true, least recent used: 2
+
+set.add(4);
+console.log(set.has(2))     // false
+
+console.log(set.isFull())   // true
+set.delete(1);
+console.log(set.size)       // 2
+
+set.clear();
+console.log(set.size)       // 0
+```
+
+</details>
+
+<details>
+    <summary>LfuMap</summary>
+
+```Typescript
+import { LfuMap } from 'sweet-collections';
+
+const map = new LfuMap<number, number>(3);
+map.set(1, 1);
+map.set(2, 2);
+map.set(3, 3);              // least frequently used: 1
+console.log(map.has(1))     // true, least frequently used: 2
+console.log(map.get(2))     // 1, least frequently used: 3
+
+map.set(4, 4);
+console.log(map.has(3))     // false
+console.log(map.get(3))     // undefined
+
+console.log(map.isFull())   // true
+map.delete(1);
+console.log(map.size)       // 2
+
+map.clear();
+console.log(map.size)       // 0
+```
+
+</details>
+
+<details>
+    <summary>LfuSet</summary>
+
+```Typescript
+import { LfuSet } from 'sweet-collections';
+
+const set = new LfuSet<number>(3);
+set.add(1);
+set.add(2);
+set.add(3);                 // least frequently used: 1
+console.log(set.has(1))     // true, least frequently used: 2
+console.log(set.has(2))     // true, least frequently used: 3
+
+set.add(4);
+console.log(set.has(3))     // false
+
+console.log(set.isFull())   // true
+set.delete(1);
+console.log(set.size)       // 2
+
+set.clear();
+console.log(set.size)       // 0
+```
+
+</details>
+
+<details>
+    <summary>SortedArray</summary>
+
+```Typescript
+import { SortedArray } from 'sweet-collections';
+
+// Increasing order sorted array
+const array = new SortedArray<number>((a: number, b: number) => a - b);
+array.push(4);
+array.push(1);
+array.push(2);
+array.push(3);
+array.push(5);
+console.log(array.toArray());       // [1, 2, 3, 4, 5]
+console.log(array.get(2));          // 3
+console.log(array.get(4));          // 5
+console.log(array.length);          // 5
+
+array.delete(4);
+console.log(array.toArray());       // [1, 2, 3, 5]
+console.log(array.includes(4));     // false
+
+array.push(1);
+console.log(array.toArray());       // [1, 1, 2, 3, 5]
+console.log(array.count(1));        // 2
+console.log(array.firstIndexOf(1)); // 0
+console.log(array.lastIndexOf(1));  // 1
+
+console.log(array.shift());         // 1
+console.log(array.pop());           // 1
+console.log(array.min());           // 1
+console.log(array.max());           // 3
+console.log(array.toArray());       // [1, 2, 3]
+```
+
+</details>
+
+<details>
+    <summary>SortedMap</summary>
+
+```Typescript
+import { SortedMap } from 'sweet-collections';
+
+// Increasing order sorted map
+const map = new SortedMap<number, string>((a: number, b: number) => a - b);
+map.set(3, 'c');
+map.set(2, 'd');
+map.set(5, 'a');
+map.set(4, 'b');
+map.set(1, 'e');
+console.log([...map.keys()]);       // [1, 2, 3, 4, 5]
+console.log([...map.values()]);     // ["e", "d", "c", "b", "a"]
+console.log(map.get(2));            // "d"
+console.log(map.get(4));            // "b"
+console.log(map.size);              // 5
+
+map.delete(4);
+console.log([...map.keys()]);       // [1, 2, 3, 5]
+console.log([...map.values()]);     // ["e", "d", "c", "a"]
+console.log(map.has(4));            // false
+```
+
+</details>
+
+<details>
+    <summary>SortedSet</summary>
+
+```Typescript
+import { SortedSet } from 'sweet-collections';
+
+// Increasing order sorted set
+const set = new SortedSet<number>((a: number, b: number) => a - b);
+set.add(3);
+set.add(2);
+set.add(5);
+set.add(4);
+set.add(1);
+console.log([...set.keys()]);       // [1, 2, 3, 4, 5]
+console.log(set.has(2));            // true
+console.log(set.has(4));            // true
+console.log(set.size);              // 5
+
+set.delete(4);
+console.log([...set.keys()]);       // [1, 2, 3, 5]
+console.log(set.has(4));            // false
+```
+
+</details>
+
+<details>
+    <summary>Heap</summary>
+
+```Typescript
+import { Heap } from 'sweet-collections';
+
+// Heap with the maximum value on top
+const heap = new Heap<number>((a: number, b: number) => a > b);
+heap.push(3);
+heap.push(2);
+heap.push(5);
+heap.push(4);
+heap.push(1);
+console.log(heap.peek());        // 5
+console.log(heap.pop());         // 5
+console.log(heap.peek());        // 4
+console.log(heap.replace(0));    // 4
+console.log(heap.peek());        // 3
+```
+
+</details>
+
+<details>
+    <summary>Stack</summary>
+
+```Typescript
+import { Stack } from 'sweet-collections';
+
+const stack = new Stack<number>();
+stack.push(3);
+stack.push(2);
+console.log(stack.top());         // 2
+stack.push(5, 4, 1);
+console.log(stack.pop());         // 1
+console.log(stack.top());         // 4
+console.log(stack.size);          // 4
+```
+
+</details>
+
+<details>
+    <summary>Queue</summary>
+
+```Typescript
+import { Queue } from 'sweet-collections';
+
+const queue = new Queue<number>();
+queue.push(3);
+queue.push(2);
+console.log(queue.pop());         // 3
+queue.push(5, 4, 1);
+console.log(queue.pop());         // 2
+console.log(queue.peek());        // 5
+console.log(queue.size);          // 3
+```
+
+</details>
+
+## Author
+
+👤 **Nasreddine Bac Ali**
+
+- Website: [nasreddinebacali.info](https://nasreddinebacali.info)
+- Github: [@bacali95](https://github.com/bacali95)
+- LinkedIn: [@bacali](https://linkedin.com/in/bacali)
+
+## Show your support
+
+Give a ⭐️ if this project helped you!
+
+## 📝 License
+
+Copyright © 2021 [Nasreddine Bac Ali](https://github.com/bacali95). This project
+is [ISC](https://github.com/bacali95/sweet-collections/blob/master/LICENSE) licensed.

node_modules/sweet-collections/dist/array/SortedArray.d.ts

@@ -0,0 +1,32 @@
+export declare class SortedArray<T> {
+    private root;
+    private readonly comparator;
+    private readonly unique;
+    constructor(comparator: (a: T, b: T) => number, unique?: boolean);
+    push(...items: T[]): number;
+    get(index: number): T | undefined;
+    clear(): void;
+    firstIndexOf(data: T): number;
+    lastIndexOf(data: T): number;
+    count(data: T): number;
+    includes(data: T): boolean;
+    delete(value: T): boolean;
+    toArray(): T[];
+    shift(): T | undefined;
+    pop(): T | undefined;
+    min(): T | undefined;
+    max(): T | undefined;
+    get length(): number;
+    private _min;
+    private _max;
+    private find;
+    private findIndex;
+    private height;
+    private _size;
+    private _insert;
+    private getBalance;
+    private rightRotate;
+    private leftRotate;
+    private _delete;
+    private _toArray;
+}

node_modules/sweet-collections/dist/array/SortedArray.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortedArray = void 0;
+class SortedArray {
+    constructor(comparator, unique = false) {
+        this.comparator = comparator;
+        this.unique = unique;
+        this.root = undefined;
+    }
+    push(...items) {
+        for (const item of items) {
+            this.root = this._insert(item, this.root);
+        }
+        return this.length;
+    }
+    get(index) {
+        if (index < 0 || index >= this.length)
+            return undefined;
+        let node = this.root;
+        index++;
+        while (true) {
+            if (node.left) {
+                if (index <= this._size(node.left)) {
+                    node = node.left;
+                    continue;
+                }
+                index -= this._size(node.left);
+            }
+            if (index > 0 && index <= node.count)
+                break;
+            index -= node.count;
+            node = node.right;
+        }
+        return node.data;
+    }
+    clear() {
+        this.root = undefined;
+    }
+    firstIndexOf(data) {
+        return this.findIndex(data);
+    }
+    lastIndexOf(data) {
+        return this.findIndex(data, true);
+    }
+    count(data) {
+        var _a, _b;
+        return (_b = (_a = this.find(data)) === null || _a === void 0 ? void 0 : _a.count) !== null && _b !== void 0 ? _b : 0;
+    }
+    includes(data) {
+        return this.count(data) > 0;
+    }
+    delete(value) {
+        const oldLength = this.length;
+        this.root = this._delete(value, this.root);
+        return oldLength !== this.length;
+    }
+    toArray() {
+        return this._toArray(this.root);
+    }
+    shift() {
+        const min = this.min();
+        if (!min)
+            return undefined;
+        this.delete(min);
+        return min;
+    }
+    pop() {
+        const max = this.max();
+        if (!max)
+            return undefined;
+        this.delete(max);
+        return max;
+    }
+    min() {
+        return this._min(this.root);
+    }
+    max() {
+        return this._max(this.root);
+    }
+    get length() {
+        return this._size(this.root);
+    }
+    _min(node) {
+        if (!node)
+            return undefined;
+        let min = node.data;
+        while (node.left) {
+            min = node.left.data;
+            node = node.left;
+        }
+        return min;
+    }
+    _max(node) {
+        if (!node)
+            return undefined;
+        let max = node.data;
+        while (node.right) {
+            max = node.right.data;
+            node = node.right;
+        }
+        return max;
+    }
+    find(data) {
+        let node = this.root;
+        let comp;
+        while (node) {
+            comp = this.comparator(data, node.data);
+            if (comp > 0) {
+                node = node.right;
+            }
+            else if (comp < 0) {
+                node = node.left;
+            }
+            else {
+                return node;
+            }
+        }
+        return undefined;
+    }
+    findIndex(data, last = false) {
+        let node = this.root;
+        let index = 0;
+        let comp;
+        while (node) {
+            comp = this.comparator(data, node.data);
+            if (comp > 0) {
+                index += this._size(node.left) + node.count;
+                node = node.right;
+            }
+            else if (comp < 0) {
+                node = node.left;
+            }
+            else {
+                return index + this._size(node.left) + (last ? node.count - 1 : 0);
+            }
+        }
+        return -1;
+    }
+    height(node) {
+        return node ? node.height : 0;
+    }
+    _size(node) {
+        return node ? node.nbrOfChildren + node.count : 0;
+    }
+    _insert(data, node) {
+        if (!node) {
+            return {
+                data: data,
+                height: 1,
+                count: 1,
+                nbrOfChildren: 0,
+            };
+        }
+        const comp = this.comparator(data, node.data);
+        if (comp > 0) {
+            node.right = this._insert(data, node.right);
+        }
+        else if (comp < 0) {
+            node.left = this._insert(data, node.left);
+        }
+        else {
+            node.data = data;
+            if (!this.unique)
+                node.count++;
+            return node;
+        }
+        node.height = Math.max(this.height(node.left), this.height(node.right)) + 1;
+        node.nbrOfChildren = this._size(node.left) + this._size(node.right);
+        const balance = this.getBalance(node);
+        const compRight = node.right ? this.comparator(data, node.right.data) : 0;
+        const compLeft = node.left ? this.comparator(data, node.left.data) : 0;
+        if (node.left && balance > 1 && compLeft < 0) {
+            return this.rightRotate(node);
+        }
+        if (node.right && balance < -1 && compRight > 0) {
+            return this.leftRotate(node);
+        }
+        if (node.left && balance > 1 && compLeft > 0) {
+            node.left = this.leftRotate(node.left);
+            return this.rightRotate(node);
+        }
+        if (node.right && balance < -1 && compRight < 0) {
+            node.right = this.rightRotate(node.right);
+            return this.leftRotate(node);
+        }
+        return node;
+    }
+    getBalance(node) {
+        return node ? this.height(node.left) - this.height(node.right) : 0;
+    }
+    rightRotate(node) {
+        const aux = node.left;
+        node.left = aux.right;
+        aux.right = node;
+        node.height = Math.max(this.height(node.left), this.height(node.right)) + 1;
+        node.nbrOfChildren = this._size(node.left) + this._size(node.right);
+        aux.height = Math.max(this.height(aux.left), this.height(aux.right)) + 1;
+        aux.nbrOfChildren = this._size(aux.left) + this._size(aux.right);
+        return aux;
+    }
+    leftRotate(node) {
+        const aux = node.right;
+        node.right = aux.left;
+        aux.left = node;
+        node.height = Math.max(this.height(node.left), this.height(node.right)) + 1;
+        node.nbrOfChildren = this._size(node.left) + this._size(node.right);
+        aux.height = Math.max(this.height(aux.left), this.height(aux.right)) + 1;
+        aux.nbrOfChildren = this._size(aux.left) + this._size(aux.right);
+        return aux;
+    }
+    _delete(value, node, removed = false) {
+        if (!node)
+            return node;
+        const comp = this.comparator(value, node.data);
+        if (comp < 0) {
+            node.left = this._delete(value, node.left, removed);
+        }
+        else if (comp > 0) {
+            node.right = this._delete(value, node.right, removed);
+        }
+        else {
+            if (!removed)
+                node.count--;
+            if (!node.count || removed) {
+                if (!node.left) {
+                    node = node.right;
+                }
+                else if (!node.right) {
+                    node = node.left;
+                }
+                else {
+                    node.data = this._min(node.right);
+                    node.count = node.right.count;
+                    node.right = this._delete(node.right.data, node.right, true);
+                }
+            }
+        }
+        if (!node)
+            return node;
+        node.height = Math.max(this.height(node.left), this.height(node.right)) + 1;
+        node.nbrOfChildren = this._size(node.left) + this._size(node.right);
+        const balance = this.getBalance(node);
+        if (balance > 1 && this.getBalance(node.left) >= 0) {
+            return this.rightRotate(node);
+        }
+        if (balance > 1 && this.getBalance(node.left) < 0) {
+            node.left = this.leftRotate(node.left);
+            return this.rightRotate(node);
+        }
+        if (balance < -1 && this.getBalance(node.right) <= 0) {
+            return this.leftRotate(node);
+        }
+        if (balance < -1 && this.getBalance(node.right) > 0) {
+            node.right = this.rightRotate(node.right);
+            return this.leftRotate(node);
+        }
+        return node;
+    }
+    _toArray(node) {
+        return node
+            ? [...this._toArray(node.left), ...new Array(node.count).fill(node.data), ...this._toArray(node.right)]
+            : [];
+    }
+}
+exports.SortedArray = SortedArray;

node_modules/sweet-collections/dist/array/index.d.ts

@@ -0,0 +1 @@
+export * from './SortedArray';

node_modules/sweet-collections/dist/array/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SortedArray"), exports);

node_modules/sweet-collections/dist/heap/Heap.d.ts

@@ -0,0 +1,16 @@
+export declare class Heap<T> {
+    private heap;
+    private readonly comparator;
+    constructor(comparator: (a: T, b: T) => boolean);
+    push(...values: T[]): this;
+    peek(): T;
+    pop(): T;
+    replace(value: T): T;
+    clear(): void;
+    toArray(): T[];
+    get size(): number;
+    private greater;
+    private swap;
+    private siftUp;
+    private siftDown;
+}

node_modules/sweet-collections/dist/heap/Heap.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heap = void 0;
+const parent = (i) => ((i + 1) >>> 1) - 1;
+const left = (i) => (i << 1) + 1;
+const right = (i) => (i + 1) << 1;
+class Heap {
+    constructor(comparator) {
+        this.comparator = comparator;
+        this.heap = [];
+    }
+    push(...values) {
+        for (const item of values) {
+            this.heap.push(item);
+            this.siftUp();
+        }
+        return this;
+    }
+    peek() {
+        return this.heap[0];
+    }
+    pop() {
+        const poppedValue = this.peek();
+        const bottom = this.size - 1;
+        if (bottom > 0) {
+            this.swap(0, bottom);
+        }
+        this.heap.pop();
+        this.siftDown();
+        return poppedValue;
+    }
+    replace(value) {
+        const replacedValue = this.peek();
+        this.heap[0] = value;
+        this.siftDown();
+        return replacedValue;
+    }
+    clear() {
+        this.heap = [];
+    }
+    toArray() {
+        return this.heap;
+    }
+    get size() {
+        return this.heap.length;
+    }
+    greater(i, j) {
+        return this.comparator(this.heap[i], this.heap[j]);
+    }
+    swap(i, j) {
+        [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
+    }
+    siftUp() {
+        let node = this.size - 1;
+        while (node > 0 && this.greater(node, parent(node))) {
+            this.swap(node, parent(node));
+            node = parent(node);
+        }
+    }
+    siftDown() {
+        let node = 0;
+        while ((left(node) < this.size && this.greater(left(node), node)) ||
+            (right(node) < this.size && this.greater(right(node), node))) {
+            const maxChild = right(node) < this.size && this.greater(right(node), left(node)) ? right(node) : left(node);
+            this.swap(node, maxChild);
+            node = maxChild;
+        }
+    }
+}
+exports.Heap = Heap;

node_modules/sweet-collections/dist/heap/index.d.ts

@@ -0,0 +1 @@
+export * from './Heap';

node_modules/sweet-collections/dist/heap/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Heap"), exports);

node_modules/sweet-collections/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './array';
+export * from './heap';
+export * from './map';
+export * from './queue';
+export * from './set';
+export * from './stack';

node_modules/sweet-collections/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./array"), exports);
+__exportStar(require("./heap"), exports);
+__exportStar(require("./map"), exports);
+__exportStar(require("./queue"), exports);
+__exportStar(require("./set"), exports);
+__exportStar(require("./stack"), exports);

node_modules/sweet-collections/dist/map/LfuMap.d.ts

@@ -0,0 +1,17 @@
+import { SizedMap } from './SizedMap';
+export declare class LfuMap<K, V> extends SizedMap<K, V> {
+    private queue;
+    private frequencies;
+    private leastFrequent;
+    has(key: K): boolean;
+    get(key: K, _default?: V): V | undefined;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    clear(): void;
+    private initQueue;
+    private queuePop;
+    private moveToTop;
+    private removeNode;
+    private increaseFrequency;
+    private decreaseFrequency;
+}

node_modules/sweet-collections/dist/map/LfuMap.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LfuMap = void 0;
+const SizedMap_1 = require("./SizedMap");
+class LfuMap extends SizedMap_1.SizedMap {
+    constructor() {
+        super(...arguments);
+        this.queue = {};
+        this.frequencies = { 1: { index: 1, count: 0 } };
+        this.leastFrequent = this.frequencies[1];
+    }
+    has(key) {
+        const node = this.map.get(key);
+        if (node) {
+            this.removeNode(node);
+            this.moveToTop(node);
+            return true;
+        }
+        return false;
+    }
+    get(key, _default) {
+        const node = this.map.get(key);
+        if (node) {
+            this.removeNode(node);
+            this.moveToTop(node);
+            return node.value;
+        }
+        return _default;
+    }
+    set(key, value) {
+        if (!this.limit)
+            return this;
+        let node = this.map.get(key);
+        if (node) {
+            node.value = value;
+            this.removeNode(node);
+            this.moveToTop(node);
+        }
+        else {
+            node = {
+                key: key,
+                value: value,
+                used: 0,
+            };
+            if (this.isFull()) {
+                super.delete(this.queuePop().key);
+            }
+            this.moveToTop(node);
+            this.map.set(key, node);
+        }
+        return this;
+    }
+    delete(key) {
+        const node = this.map.get(key);
+        if (node) {
+            this.removeNode(node);
+            return super.delete(key);
+        }
+        return false;
+    }
+    clear() {
+        this.queue = {};
+        this.frequencies = { 1: { index: 1, count: 0 } };
+        this.leastFrequent = this.frequencies[1];
+        super.clear();
+    }
+    initQueue(used) {
+        if (!this.queue[used]) {
+            this.queue[used] = {};
+        }
+    }
+    queuePop() {
+        const min = this.leastFrequent.index;
+        const node = this.queue[min].tail;
+        this.removeNode(node);
+        return node;
+    }
+    moveToTop(node) {
+        const used = ++node.used;
+        this.increaseFrequency(used);
+        this.initQueue(used);
+        node.next = this.queue[used].head;
+        node.previous = undefined;
+        if (this.queue[used].head) {
+            this.queue[used].head.previous = node;
+        }
+        this.queue[used].head = node;
+        if (!this.queue[used].tail) {
+            this.queue[used].tail = this.queue[used].head;
+        }
+    }
+    removeNode(node) {
+        const used = node.used;
+        this.decreaseFrequency(used);
+        this.initQueue(used);
+        if (node.previous) {
+            node.previous.next = node.next;
+        }
+        else {
+            this.queue[used].head = node.next;
+        }
+        if (node.next) {
+            node.next.previous = node.previous;
+        }
+        else {
+            this.queue[used].tail = node.previous;
+        }
+    }
+    increaseFrequency(index) {
+        if (!this.frequencies[index]) {
+            this.frequencies[index] = { index: index, count: 0 };
+            this.frequencies[index].next = this.frequencies[index - 1].next;
+            this.frequencies[index].previous = this.frequencies[index - 1].count
+                ? this.frequencies[index - 1]
+                : this.frequencies[index - 1].previous;
+        }
+        if (!this.frequencies[index].count) {
+            if (this.frequencies[index].previous) {
+                this.frequencies[index].next = this.frequencies[index].previous.next;
+                this.frequencies[index].previous.next = this.frequencies[index];
+            }
+            if (this.frequencies[index].next) {
+                this.frequencies[index].previous = this.frequencies[index].next.previous;
+                this.frequencies[index].next.previous = this.frequencies[index];
+            }
+        }
+        this.frequencies[index].count++;
+        if (!this.leastFrequent || index < this.leastFrequent.index) {
+            this.leastFrequent = this.frequencies[index];
+        }
+    }
+    decreaseFrequency(index) {
+        this.frequencies[index].count--;
+        if (!this.frequencies[index].count) {
+            if (this.frequencies[index].previous) {
+                this.frequencies[index].previous.next = this.frequencies[index].next;
+            }
+            if (this.frequencies[index].next) {
+                this.frequencies[index].next.previous = this.frequencies[index].previous;
+            }
+        }
+        if (!this.leastFrequent || !this.leastFrequent.count) {
+            this.leastFrequent = this.leastFrequent.next;
+        }
+    }
+}
+exports.LfuMap = LfuMap;

node_modules/sweet-collections/dist/map/LruMap.d.ts

@@ -0,0 +1,12 @@
+import { SizedMap } from './SizedMap';
+export declare class LruMap<K, V> extends SizedMap<K, V> {
+    private head?;
+    private tail?;
+    has(key: K): boolean;
+    get(key: K, _default?: V): V | undefined;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    clear(): void;
+    private moveToTop;
+    private removeNode;
+}

node_modules/sweet-collections/dist/map/LruMap.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LruMap = void 0;
+const SizedMap_1 = require("./SizedMap");
+class LruMap extends SizedMap_1.SizedMap {
+    has(key) {
+        const node = this.map.get(key);
+        if (node) {
+            this.removeNode(node);
+            this.moveToTop(node);
+            return true;
+        }
+        return false;
+    }
+    get(key, _default) {
+        const node = this.map.get(key);
+        if (node) {
+            this.removeNode(node);
+            this.moveToTop(node);
+            return node.value;
+        }
+        return _default;
+    }
+    set(key, value) {
+        let node = this.map.get(key);
+        if (node) {
+            node.value = value;
+            this.removeNode(node);
+            this.moveToTop(node);
+        }
+        else {
+            node = {
+                key: key,
+                value: value,
+            };
+            if (this.isFull()) {
+                this.delete(this.tail.key);
+            }
+            this.moveToTop(node);
+            this.map.set(key, node);
+        }
+        return this;
+    }
+    delete(key) {
+        const node = this.map.get(key);
+        if (node) {
+            this.removeNode(node);
+            return super.delete(key);
+        }
+        return false;
+    }
+    clear() {
+        this.head = this.tail = undefined;
+        super.clear();
+    }
+    moveToTop(node) {
+        node.next = this.head;
+        node.previous = undefined;
+        if (this.head) {
+            this.head.previous = node;
+        }
+        this.head = node;
+        if (!this.tail) {
+            this.tail = this.head;
+        }
+    }
+    removeNode(node) {
+        if (node.previous) {
+            node.previous.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next) {
+            node.next.previous = node.previous;
+        }
+        else {
+            this.tail = node.previous;
+        }
+    }
+}
+exports.LruMap = LruMap;

node_modules/sweet-collections/dist/map/SizedMap.d.ts

@@ -0,0 +1,25 @@
+export interface Node<K, V> {
+    key: K;
+    value: V;
+    used?: number;
+    previous?: Node<K, V>;
+    next?: Node<K, V>;
+}
+export declare abstract class SizedMap<K, V> implements Map<K, V> {
+    readonly limit: number;
+    protected readonly map: Map<K, Node<K, V>>;
+    constructor(limit: number);
+    abstract has(key: K): boolean;
+    abstract get(key: K, _default?: V): V | undefined;
+    abstract set(key: K, value: V): this;
+    delete(key: K): boolean;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    isFull(): boolean;
+    clear(): void;
+    readonly [Symbol.toStringTag]: string;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    forEach(cb: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get size(): number;
+}

node_modules/sweet-collections/dist/map/SizedMap.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SizedMap = void 0;
+class SizedMap {
+    constructor(limit) {
+        if (limit < 0) {
+            throw new Error('Map size limit should positive.');
+        }
+        this.limit = limit;
+        this.map = new Map();
+    }
+    delete(key) {
+        return this.map.delete(key);
+    }
+    keys() {
+        return this.map.keys();
+    }
+    values() {
+        return [...this.map.values()].map((node) => node.value)[Symbol.iterator]();
+    }
+    entries() {
+        return [...this.map.values()]
+            .map((node) => [node.key, node.value])[Symbol.iterator]();
+    }
+    isFull() {
+        return this.size === this.limit;
+    }
+    clear() {
+        this.map.clear();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    forEach(cb, thisArg) {
+        this.map.forEach((item) => cb.call(thisArg, item.value, item.key, this));
+    }
+    get size() {
+        return this.map.size;
+    }
+}
+exports.SizedMap = SizedMap;

node_modules/sweet-collections/dist/map/SortedMap.d.ts

@@ -0,0 +1,17 @@
+export declare class SortedMap<K, V> implements Map<K, V> {
+    private array;
+    private readonly comparator;
+    constructor(comparator: (a: K, b: K) => number);
+    has(key: K): boolean;
+    get(key: K, _default?: V): V | undefined;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    clear(): void;
+    readonly [Symbol.toStringTag]: string;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    forEach(cb: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get size(): number;
+}

node_modules/sweet-collections/dist/map/SortedMap.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortedMap = void 0;
+const array_1 = require("../array");
+class SortedMap {
+    constructor(comparator) {
+        this.comparator = comparator;
+        this.array = new array_1.SortedArray((a, b) => comparator(a.key, b.key), true);
+    }
+    has(key) {
+        return this.array.includes({ key: key, value: undefined });
+    }
+    get(key, _default) {
+        var _a, _b;
+        const index = this.array.firstIndexOf({ key: key, value: undefined });
+        return (_b = (_a = this.array.get(index)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : _default;
+    }
+    set(key, value) {
+        this.array.push({ key, value });
+        return this;
+    }
+    delete(key) {
+        return this.array.delete({ key: key, value: undefined });
+    }
+    keys() {
+        return this.array
+            .toArray()
+            .map((n) => n.key)[Symbol.iterator]();
+    }
+    values() {
+        return this.array
+            .toArray()
+            .map((n) => n.value)[Symbol.iterator]();
+    }
+    entries() {
+        return this.array
+            .toArray()
+            .map((n) => [n.key, n.value])[Symbol.iterator]();
+    }
+    clear() {
+        this.array.clear();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    forEach(cb, thisArg) {
+        this.array.toArray().forEach((item) => cb.call(thisArg, item.value, item.key, this));
+    }
+    get size() {
+        return this.array.length;
+    }
+}
+exports.SortedMap = SortedMap;

node_modules/sweet-collections/dist/map/index.d.ts

@@ -0,0 +1,3 @@
+export * from './LruMap';
+export * from './LfuMap';
+export * from './SortedMap';

node_modules/sweet-collections/dist/map/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LruMap"), exports);
+__exportStar(require("./LfuMap"), exports);
+__exportStar(require("./SortedMap"), exports);

node_modules/sweet-collections/dist/queue/Queue.d.ts

@@ -0,0 +1,11 @@
+export declare class Queue<T> {
+    private head?;
+    private tail?;
+    private _size;
+    push(...values: T[]): this;
+    pop(_default?: T): T | undefined;
+    peek(): T | undefined;
+    isEmpty(): boolean;
+    clear(): void;
+    get size(): number;
+}

node_modules/sweet-collections/dist/queue/Queue.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+class Queue {
+    constructor() {
+        this._size = 0;
+    }
+    push(...values) {
+        for (const value of values) {
+            const node = { value };
+            if (this.tail) {
+                this.tail.next = node;
+            }
+            this.tail = node;
+            if (!this.head) {
+                this.head = this.tail;
+            }
+            this._size++;
+        }
+        return this;
+    }
+    pop(_default) {
+        if (this.head) {
+            const value = this.head.value;
+            this.head = this.head.next;
+            if (!this.head) {
+                this.tail = undefined;
+            }
+            this._size--;
+            return value;
+        }
+        return _default;
+    }
+    peek() {
+        return this.head.value;
+    }
+    isEmpty() {
+        return this.head === undefined;
+    }
+    clear() {
+        this.head = this.tail = undefined;
+        this._size = 0;
+    }
+    get size() {
+        return this._size;
+    }
+}
+exports.Queue = Queue;

node_modules/sweet-collections/dist/queue/index.d.ts

@@ -0,0 +1 @@
+export * from './Queue';

node_modules/sweet-collections/dist/queue/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Queue"), exports);

node_modules/sweet-collections/dist/set/LfuSet.d.ts

@@ -0,0 +1,15 @@
+export declare class LfuSet<T> implements Set<T> {
+    private readonly map;
+    constructor(limit: number);
+    has(value: T): boolean;
+    add(value: T): this;
+    delete(value: T): boolean;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    entries(): IterableIterator<[T, T]>;
+    clear(): void;
+    [Symbol.toStringTag]: string;
+    [Symbol.iterator](): IterableIterator<T>;
+    forEach(cb: (value: T, key: T, set: Set<T>) => void, thisArg?: any): void;
+    get size(): number;
+}

node_modules/sweet-collections/dist/set/LfuSet.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LfuSet = void 0;
+const map_1 = require("../map");
+class LfuSet {
+    constructor(limit) {
+        this.map = new map_1.LfuMap(limit);
+    }
+    has(value) {
+        return this.map.has(value);
+    }
+    add(value) {
+        this.map.set(value, value);
+        return this;
+    }
+    delete(value) {
+        return this.map.delete(value);
+    }
+    keys() {
+        return this.map.keys();
+    }
+    values() {
+        return this.map.values();
+    }
+    entries() {
+        return this.map.entries();
+    }
+    clear() {
+        this.map.clear();
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    forEach(cb, thisArg) {
+        this.map.forEach((item) => cb.call(thisArg, item, item, this));
+    }
+    get size() {
+        return this.map.size;
+    }
+}
+exports.LfuSet = LfuSet;

node_modules/sweet-collections/dist/set/LruSet.d.ts

@@ -0,0 +1,15 @@
+export declare class LruSet<T> implements Set<T> {
+    private readonly map;
+    constructor(limit: number);
+    has(value: T): boolean;
+    add(value: T): this;
+    delete(value: T): boolean;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    entries(): IterableIterator<[T, T]>;
+    clear(): void;
+    [Symbol.toStringTag]: string;
+    [Symbol.iterator](): IterableIterator<T>;
+    forEach(cb: (value: T, key: T, set: Set<T>) => void, thisArg?: any): void;
+    get size(): number;
+}

node_modules/sweet-collections/dist/set/LruSet.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LruSet = void 0;
+const map_1 = require("../map");
+class LruSet {
+    constructor(limit) {
+        this.map = new map_1.LruMap(limit);
+    }
+    has(value) {
+        return this.map.has(value);
+    }
+    add(value) {
+        this.map.set(value, value);
+        return this;
+    }
+    delete(value) {
+        return this.map.delete(value);
+    }
+    keys() {
+        return this.map.keys();
+    }
+    values() {
+        return this.map.values();
+    }
+    entries() {
+        return this.map.entries();
+    }
+    clear() {
+        this.map.clear();
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    forEach(cb, thisArg) {
+        this.map.forEach((item) => cb.call(thisArg, item, item, this));
+    }
+    get size() {
+        return this.map.size;
+    }
+}
+exports.LruSet = LruSet;

node_modules/sweet-collections/dist/set/SortedSet.d.ts

@@ -0,0 +1,15 @@
+export declare class SortedSet<T> implements Set<T> {
+    private array;
+    constructor(comparator: (a: T, b: T) => number);
+    has(value: T): boolean;
+    add(...values: T[]): this;
+    delete(value: T): boolean;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    entries(): IterableIterator<[T, T]>;
+    clear(): void;
+    readonly [Symbol.toStringTag]: string;
+    [Symbol.iterator](): IterableIterator<T>;
+    forEach(cb: (value: T, key: T, set: Set<T>) => void, thisArg?: any): void;
+    get size(): number;
+}

node_modules/sweet-collections/dist/set/SortedSet.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortedSet = void 0;
+const array_1 = require("../array");
+class SortedSet {
+    constructor(comparator) {
+        this.array = new array_1.SortedArray(comparator, true);
+    }
+    has(value) {
+        return this.array.includes(value);
+    }
+    add(...values) {
+        this.array.push(...values);
+        return this;
+    }
+    delete(value) {
+        return this.array.delete(value);
+    }
+    keys() {
+        return this.array.toArray()[Symbol.iterator]();
+    }
+    values() {
+        return this.array.toArray()[Symbol.iterator]();
+    }
+    entries() {
+        return this.array
+            .toArray()
+            .map((value) => [value, value])[Symbol.iterator]();
+    }
+    clear() {
+        this.array.clear();
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    forEach(cb, thisArg) {
+        this.array.toArray().forEach((item) => cb.call(thisArg, item, item, this));
+    }
+    get size() {
+        return this.array.length;
+    }
+}
+exports.SortedSet = SortedSet;

node_modules/sweet-collections/dist/set/index.d.ts

@@ -0,0 +1,3 @@
+export * from './LruSet';
+export * from './LfuSet';
+export * from './SortedSet';

node_modules/sweet-collections/dist/set/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LruSet"), exports);
+__exportStar(require("./LfuSet"), exports);
+__exportStar(require("./SortedSet"), exports);

node_modules/sweet-collections/dist/stack/Stack.d.ts

@@ -0,0 +1,10 @@
+export declare class Stack<T> {
+    private head?;
+    private _size;
+    push(...values: T[]): this;
+    pop(_default?: T): T | undefined;
+    top(): T | undefined;
+    isEmpty(): boolean;
+    clear(): void;
+    get size(): number;
+}

node_modules/sweet-collections/dist/stack/Stack.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stack = void 0;
+class Stack {
+    constructor() {
+        this._size = 0;
+    }
+    push(...values) {
+        for (const value of values) {
+            this.head = { value, next: this.head };
+            this._size++;
+        }
+        return this;
+    }
+    pop(_default) {
+        if (this.head) {
+            const value = this.head.value;
+            this.head = this.head.next;
+            this._size--;
+            return value;
+        }
+        return _default;
+    }
+    top() {
+        return this.head.value;
+    }
+    isEmpty() {
+        return this.head === undefined;
+    }
+    clear() {
+        this.head = undefined;
+        this._size = 0;
+    }
+    get size() {
+        return this._size;
+    }
+}
+exports.Stack = Stack;

node_modules/sweet-collections/dist/stack/index.d.ts

@@ -0,0 +1 @@
+export * from './Stack';

node_modules/sweet-collections/dist/stack/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Stack"), exports);

node_modules/sweet-collections/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "sweet-collections",
+  "version": "1.1.0",
+  "description": "Different Javascript collections written in Typescript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "url": "https://github.com/bacali95/sweet-collections.git",
+    "type": "git"
+  },
+  "author": {
+    "name": "Nasreddine Bac Ali",
+    "email": "nasreddine.bacali95@gmail.com",
+    "url": "https://nasreddinebacali.info"
+  },
+  "keywords": [
+    "collections",
+    "algorithms",
+    "lrumap",
+    "lfumap",
+    "sortedmap",
+    "lruset",
+    "lfuset",
+    "sortedset",
+    "sortedarray",
+    "heap"
+  ],
+  "scripts": {
+    "prepublishOnly": "yarn build",
+    "build": "rm -rf dist && tsc",
+    "benchmark": "node benchmark",
+    "lint": "eslint .",
+    "prettier": "prettier --list-different '**/{*,.*}.ts'",
+    "test": "jest --coverage --no-cache && make-coverage-badge"
+  },
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^26.0.15",
+    "@typescript-eslint/eslint-plugin": "^4.6.1",
+    "@typescript-eslint/parser": "^4.6.1",
+    "chalk": "^4.1.0",
+    "collections": "^5.1.12",
+    "eslint": "^7.12.1",
+    "eslint-config-prettier": "^6.15.0",
+    "eslint-config-standard": "^16.0.1",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-jest": "^24.1.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^4.2.1",
+    "jest": "^26.6.1",
+    "make-coverage-badge": "^1.2.0",
+    "prettier": "^2.1.2",
+    "ts-jest": "^26.4.3",
+    "ts-node": "^9.0.0",
+    "typescript": "^4.0.5"
+  }
+}