Init

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);