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