first commit

node_modules/js-sdsl/dist/cjs/container/ContainerBase/index.d.ts

@@ -0,0 +1,206 @@
+/**
+ * @description The iterator type including `NORMAL` and `REVERSE`.
+ */
+export declare const enum IteratorType {
+    NORMAL = 0,
+    REVERSE = 1
+}
+export declare abstract class ContainerIterator<T> {
+    /**
+     * @description The container pointed to by the iterator.
+     */
+    abstract readonly container: Container<T>;
+    /**
+     * @description Iterator's type.
+     * @example
+     * console.log(container.end().iteratorType === IteratorType.NORMAL);  // true
+     */
+    readonly iteratorType: IteratorType;
+    /**
+     * @param iter - The other iterator you want to compare.
+     * @returns Whether this equals to obj.
+     * @example
+     * container.find(1).equals(container.end());
+     */
+    equals(iter: ContainerIterator<T>): boolean;
+    /**
+     * @description Pointers to element.
+     * @returns The value of the pointer's element.
+     * @example
+     * const val = container.begin().pointer;
+     */
+    abstract get pointer(): T;
+    /**
+     * @description Set pointer's value (some containers are unavailable).
+     * @param newValue - The new value you want to set.
+     * @example
+     * (<LinkList<number>>container).begin().pointer = 1;
+     */
+    abstract set pointer(newValue: T);
+    /**
+     * @description Move `this` iterator to pre.
+     * @returns The iterator's self.
+     * @example
+     * const iter = container.find(1);  // container = [0, 1]
+     * const pre = iter.pre();
+     * console.log(pre === iter);  // true
+     * console.log(pre.equals(iter));  // true
+     * console.log(pre.pointer, iter.pointer); // 0, 0
+     */
+    abstract pre(): this;
+    /**
+     * @description Move `this` iterator to next.
+     * @returns The iterator's self.
+     * @example
+     * const iter = container.find(1);  // container = [1, 2]
+     * const next = iter.next();
+     * console.log(next === iter);  // true
+     * console.log(next.equals(iter));  // true
+     * console.log(next.pointer, iter.pointer); // 2, 2
+     */
+    abstract next(): this;
+    /**
+     * @description Get a copy of itself.
+     * @returns The copy of self.
+     * @example
+     * const iter = container.find(1);  // container = [1, 2]
+     * const next = iter.copy().next();
+     * console.log(next === iter);  // false
+     * console.log(next.equals(iter));  // false
+     * console.log(next.pointer, iter.pointer); // 2, 1
+     */
+    abstract copy(): ContainerIterator<T>;
+}
+export declare abstract class Base {
+    /**
+     * @returns The size of the container.
+     * @example
+     * const container = new Vector([1, 2]);
+     * console.log(container.length); // 2
+     */
+    get length(): number;
+    /**
+     * @returns The size of the container.
+     * @example
+     * const container = new Vector([1, 2]);
+     * console.log(container.size()); // 2
+     */
+    size(): number;
+    /**
+     * @returns Whether the container is empty.
+     * @example
+     * container.clear();
+     * console.log(container.empty());  // true
+     */
+    empty(): boolean;
+    /**
+     * @description Clear the container.
+     * @example
+     * container.clear();
+     * console.log(container.empty());  // true
+     */
+    abstract clear(): void;
+}
+export declare abstract class Container<T> extends Base {
+    /**
+     * @returns Iterator pointing to the beginning element.
+     * @example
+     * const begin = container.begin();
+     * const end = container.end();
+     * for (const it = begin; !it.equals(end); it.next()) {
+     *   doSomething(it.pointer);
+     * }
+     */
+    abstract begin(): ContainerIterator<T>;
+    /**
+     * @returns Iterator pointing to the super end like c++.
+     * @example
+     * const begin = container.begin();
+     * const end = container.end();
+     * for (const it = begin; !it.equals(end); it.next()) {
+     *   doSomething(it.pointer);
+     * }
+     */
+    abstract end(): ContainerIterator<T>;
+    /**
+     * @returns Iterator pointing to the end element.
+     * @example
+     * const rBegin = container.rBegin();
+     * const rEnd = container.rEnd();
+     * for (const it = rBegin; !it.equals(rEnd); it.next()) {
+     *   doSomething(it.pointer);
+     * }
+     */
+    abstract rBegin(): ContainerIterator<T>;
+    /**
+     * @returns Iterator pointing to the super begin like c++.
+     * @example
+     * const rBegin = container.rBegin();
+     * const rEnd = container.rEnd();
+     * for (const it = rBegin; !it.equals(rEnd); it.next()) {
+     *   doSomething(it.pointer);
+     * }
+     */
+    abstract rEnd(): ContainerIterator<T>;
+    /**
+     * @returns The first element of the container.
+     */
+    abstract front(): T | undefined;
+    /**
+     * @returns The last element of the container.
+     */
+    abstract back(): T | undefined;
+    /**
+     * @param element - The element you want to find.
+     * @returns An iterator pointing to the element if found, or super end if not found.
+     * @example
+     * container.find(1).equals(container.end());
+     */
+    abstract find(element: T): ContainerIterator<T>;
+    /**
+     * @description Iterate over all elements in the container.
+     * @param callback - Callback function like Array.forEach.
+     * @example
+     * container.forEach((element, index) => console.log(element, index));
+     */
+    abstract forEach(callback: (element: T, index: number, container: Container<T>) => void): void;
+    /**
+     * @description Gets the value of the element at the specified position.
+     * @example
+     * const val = container.getElementByPos(-1); // throw a RangeError
+     */
+    abstract getElementByPos(pos: number): T;
+    /**
+     * @description Removes the element at the specified position.
+     * @param pos - The element's position you want to remove.
+     * @returns The container length after erasing.
+     * @example
+     * container.eraseElementByPos(-1); // throw a RangeError
+     */
+    abstract eraseElementByPos(pos: number): number;
+    /**
+     * @description Removes element by iterator and move `iter` to next.
+     * @param iter - The iterator you want to erase.
+     * @returns The next iterator.
+     * @example
+     * container.eraseElementByIterator(container.begin());
+     * container.eraseElementByIterator(container.end()); // throw a RangeError
+     */
+    abstract eraseElementByIterator(iter: ContainerIterator<T>): ContainerIterator<T>;
+    /**
+     * @description Using for `for...of` syntax like Array.
+     * @example
+     * for (const element of container) {
+     *   console.log(element);
+     * }
+     */
+    abstract [Symbol.iterator](): Generator<T, void>;
+}
+/**
+ * @description The initial data type passed in when initializing the container.
+ */
+export declare type initContainer<T> = {
+    size?: number | (() => number);
+    length?: number;
+    forEach: (callback: (el: T) => void) => void;
+};

node_modules/js-sdsl/dist/cjs/container/ContainerBase/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.ContainerIterator = exports.Container = exports.Base = void 0;
+
+class ContainerIterator {
+    constructor(t = 0) {
+        this.iteratorType = t;
+    }
+    equals(t) {
+        return this.o === t.o;
+    }
+}
+
+exports.ContainerIterator = ContainerIterator;
+
+class Base {
+    constructor() {
+        this.i = 0;
+    }
+    get length() {
+        return this.i;
+    }
+    size() {
+        return this.i;
+    }
+    empty() {
+        return this.i === 0;
+    }
+}
+
+exports.Base = Base;
+
+class Container extends Base {}
+
+exports.Container = Container;
+//# sourceMappingURL=index.js.map

node_modules/js-sdsl/dist/cjs/container/HashContainer/Base/index.d.ts

@@ -0,0 +1,29 @@
+import { Container, ContainerIterator } from "../../ContainerBase";
+export declare type HashLinkNode<K, V> = {
+    _key: K;
+    _value: V;
+    _pre: HashLinkNode<K, V>;
+    _next: HashLinkNode<K, V>;
+};
+export declare abstract class HashContainerIterator<K, V> extends ContainerIterator<K | [K, V]> {
+    abstract readonly container: HashContainer<K, V>;
+    pre(): this;
+    next(): this;
+}
+export declare abstract class HashContainer<K, V> extends Container<K | [K, V]> {
+    /**
+     * @description Unique symbol used to tag object.
+     */
+    readonly HASH_TAG: symbol;
+    clear(): void;
+    /**
+     * @description Remove the element of the specified key.
+     * @param key - The key you want to remove.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @returns Whether erase successfully.
+     */
+    eraseElementByKey(key: K, isObject?: boolean): boolean;
+    eraseElementByIterator(iter: HashContainerIterator<K, V>): HashContainerIterator<K, V>;
+    eraseElementByPos(pos: number): number;
+}

node_modules/js-sdsl/dist/cjs/container/HashContainer/Base/index.js

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.HashContainerIterator = exports.HashContainer = void 0;
+
+var _ContainerBase = require("../../ContainerBase");
+
+var _checkObject = _interopRequireDefault(require("../../../utils/checkObject"));
+
+var _throwError = require("../../../utils/throwError");
+
+function _interopRequireDefault(t) {
+    return t && t.t ? t : {
+        default: t
+    };
+}
+
+class HashContainerIterator extends _ContainerBase.ContainerIterator {
+    constructor(t, e, i) {
+        super(i);
+        this.o = t;
+        this.h = e;
+        if (this.iteratorType === 0) {
+            this.pre = function() {
+                if (this.o.L === this.h) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.L;
+                return this;
+            };
+            this.next = function() {
+                if (this.o === this.h) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.B;
+                return this;
+            };
+        } else {
+            this.pre = function() {
+                if (this.o.B === this.h) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.B;
+                return this;
+            };
+            this.next = function() {
+                if (this.o === this.h) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.L;
+                return this;
+            };
+        }
+    }
+}
+
+exports.HashContainerIterator = HashContainerIterator;
+
+class HashContainer extends _ContainerBase.Container {
+    constructor() {
+        super();
+        this.H = [];
+        this.g = {};
+        this.HASH_TAG = Symbol("@@HASH_TAG");
+        Object.setPrototypeOf(this.g, null);
+        this.h = {};
+        this.h.L = this.h.B = this.p = this._ = this.h;
+    }
+    V(t) {
+        const {L: e, B: i} = t;
+        e.B = i;
+        i.L = e;
+        if (t === this.p) {
+            this.p = i;
+        }
+        if (t === this._) {
+            this._ = e;
+        }
+        this.i -= 1;
+    }
+    M(t, e, i) {
+        if (i === undefined) i = (0, _checkObject.default)(t);
+        let s;
+        if (i) {
+            const i = t[this.HASH_TAG];
+            if (i !== undefined) {
+                this.H[i].l = e;
+                return this.i;
+            }
+            Object.defineProperty(t, this.HASH_TAG, {
+                value: this.H.length,
+                configurable: true
+            });
+            s = {
+                u: t,
+                l: e,
+                L: this._,
+                B: this.h
+            };
+            this.H.push(s);
+        } else {
+            const i = this.g[t];
+            if (i) {
+                i.l = e;
+                return this.i;
+            }
+            s = {
+                u: t,
+                l: e,
+                L: this._,
+                B: this.h
+            };
+            this.g[t] = s;
+        }
+        if (this.i === 0) {
+            this.p = s;
+            this.h.B = s;
+        } else {
+            this._.B = s;
+        }
+        this._ = s;
+        this.h.L = s;
+        return ++this.i;
+    }
+    I(t, e) {
+        if (e === undefined) e = (0, _checkObject.default)(t);
+        if (e) {
+            const e = t[this.HASH_TAG];
+            if (e === undefined) return this.h;
+            return this.H[e];
+        } else {
+            return this.g[t] || this.h;
+        }
+    }
+    clear() {
+        const t = this.HASH_TAG;
+        this.H.forEach((function(e) {
+            delete e.u[t];
+        }));
+        this.H = [];
+        this.g = {};
+        Object.setPrototypeOf(this.g, null);
+        this.i = 0;
+        this.p = this._ = this.h.L = this.h.B = this.h;
+    }
+    eraseElementByKey(t, e) {
+        let i;
+        if (e === undefined) e = (0, _checkObject.default)(t);
+        if (e) {
+            const e = t[this.HASH_TAG];
+            if (e === undefined) return false;
+            delete t[this.HASH_TAG];
+            i = this.H[e];
+            delete this.H[e];
+        } else {
+            i = this.g[t];
+            if (i === undefined) return false;
+            delete this.g[t];
+        }
+        this.V(i);
+        return true;
+    }
+    eraseElementByIterator(t) {
+        const e = t.o;
+        if (e === this.h) {
+            (0, _throwError.throwIteratorAccessError)();
+        }
+        this.V(e);
+        return t.next();
+    }
+    eraseElementByPos(t) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        let e = this.p;
+        while (t--) {
+            e = e.B;
+        }
+        this.V(e);
+        return this.i;
+    }
+}
+
+exports.HashContainer = HashContainer;
+//# sourceMappingURL=index.js.map

node_modules/js-sdsl/dist/cjs/container/HashContainer/HashMap.d.ts

@@ -0,0 +1,49 @@
+import { initContainer, IteratorType } from "../ContainerBase";
+import { HashContainer, HashContainerIterator, HashLinkNode } from "./Base";
+declare class HashMapIterator<K, V> extends HashContainerIterator<K, V> {
+    readonly container: HashMap<K, V>;
+    constructor(node: HashLinkNode<K, V>, header: HashLinkNode<K, V>, container: HashMap<K, V>, iteratorType?: IteratorType);
+    get pointer(): [K, V];
+    copy(): HashMapIterator<K, V>;
+    equals(iter: HashMapIterator<K, V>): boolean;
+}
+export type { HashMapIterator };
+declare class HashMap<K, V> extends HashContainer<K, V> {
+    constructor(container?: initContainer<[K, V]>);
+    begin(): HashMapIterator<K, V>;
+    end(): HashMapIterator<K, V>;
+    rBegin(): HashMapIterator<K, V>;
+    rEnd(): HashMapIterator<K, V>;
+    front(): [K, V] | undefined;
+    back(): [K, V] | undefined;
+    /**
+     * @description Insert a key-value pair or set value by the given key.
+     * @param key - The key want to insert.
+     * @param value - The value want to set.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @returns The size of container after setting.
+     */
+    setElement(key: K, value: V, isObject?: boolean): number;
+    /**
+     * @description Get the value of the element of the specified key.
+     * @param key - The key want to search.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @example
+     * const val = container.getElementByKey(1);
+     */
+    getElementByKey(key: K, isObject?: boolean): V | undefined;
+    getElementByPos(pos: number): [K, V];
+    /**
+     * @description Check key if exist in container.
+     * @param key - The element you want to search.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @returns An iterator pointing to the element if found, or super end if not found.
+     */
+    find(key: K, isObject?: boolean): HashMapIterator<K, V>;
+    forEach(callback: (element: [K, V], index: number, hashMap: HashMap<K, V>) => void): void;
+    [Symbol.iterator](): Generator<[K, V], void, unknown>;
+}
+export default HashMap;

node_modules/js-sdsl/dist/cjs/container/HashContainer/HashMap.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _Base = require("./Base");
+
+var _checkObject = _interopRequireDefault(require("../../utils/checkObject"));
+
+var _throwError = require("../../utils/throwError");
+
+function _interopRequireDefault(t) {
+    return t && t.t ? t : {
+        default: t
+    };
+}
+
+class HashMapIterator extends _Base.HashContainerIterator {
+    constructor(t, e, r, s) {
+        super(t, e, s);
+        this.container = r;
+    }
+    get pointer() {
+        if (this.o === this.h) {
+            (0, _throwError.throwIteratorAccessError)();
+        }
+        const t = this;
+        return new Proxy([], {
+            get(e, r) {
+                if (r === "0") return t.o.u; else if (r === "1") return t.o.l;
+            },
+            set(e, r, s) {
+                if (r !== "1") {
+                    throw new TypeError("props must be 1");
+                }
+                t.o.l = s;
+                return true;
+            }
+        });
+    }
+    copy() {
+        return new HashMapIterator(this.o, this.h, this.container, this.iteratorType);
+    }
+}
+
+class HashMap extends _Base.HashContainer {
+    constructor(t = []) {
+        super();
+        const e = this;
+        t.forEach((function(t) {
+            e.setElement(t[0], t[1]);
+        }));
+    }
+    begin() {
+        return new HashMapIterator(this.p, this.h, this);
+    }
+    end() {
+        return new HashMapIterator(this.h, this.h, this);
+    }
+    rBegin() {
+        return new HashMapIterator(this._, this.h, this, 1);
+    }
+    rEnd() {
+        return new HashMapIterator(this.h, this.h, this, 1);
+    }
+    front() {
+        if (this.i === 0) return;
+        return [ this.p.u, this.p.l ];
+    }
+    back() {
+        if (this.i === 0) return;
+        return [ this._.u, this._.l ];
+    }
+    setElement(t, e, r) {
+        return this.M(t, e, r);
+    }
+    getElementByKey(t, e) {
+        if (e === undefined) e = (0, _checkObject.default)(t);
+        if (e) {
+            const e = t[this.HASH_TAG];
+            return e !== undefined ? this.H[e].l : undefined;
+        }
+        const r = this.g[t];
+        return r ? r.l : undefined;
+    }
+    getElementByPos(t) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        let e = this.p;
+        while (t--) {
+            e = e.B;
+        }
+        return [ e.u, e.l ];
+    }
+    find(t, e) {
+        const r = this.I(t, e);
+        return new HashMapIterator(r, this.h, this);
+    }
+    forEach(t) {
+        let e = 0;
+        let r = this.p;
+        while (r !== this.h) {
+            t([ r.u, r.l ], e++, this);
+            r = r.B;
+        }
+    }
+    [Symbol.iterator]() {
+        return function*() {
+            let t = this.p;
+            while (t !== this.h) {
+                yield [ t.u, t.l ];
+                t = t.B;
+            }
+        }.bind(this)();
+    }
+}
+
+var _default = HashMap;
+
+exports.default = _default;
+//# sourceMappingURL=HashMap.js.map

node_modules/js-sdsl/dist/cjs/container/HashContainer/HashSet.d.ts

@@ -0,0 +1,39 @@
+import { initContainer, IteratorType } from "../ContainerBase";
+import { HashContainer, HashContainerIterator, HashLinkNode } from "./Base";
+declare class HashSetIterator<K> extends HashContainerIterator<K, undefined> {
+    readonly container: HashSet<K>;
+    constructor(node: HashLinkNode<K, undefined>, header: HashLinkNode<K, undefined>, container: HashSet<K>, iteratorType?: IteratorType);
+    get pointer(): K;
+    copy(): HashSetIterator<K>;
+    equals(iter: HashSetIterator<K>): boolean;
+}
+export type { HashSetIterator };
+declare class HashSet<K> extends HashContainer<K, undefined> {
+    constructor(container?: initContainer<K>);
+    begin(): HashSetIterator<K>;
+    end(): HashSetIterator<K>;
+    rBegin(): HashSetIterator<K>;
+    rEnd(): HashSetIterator<K>;
+    front(): K | undefined;
+    back(): K | undefined;
+    /**
+     * @description Insert element to set.
+     * @param key - The key want to insert.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @returns The size of container after inserting.
+     */
+    insert(key: K, isObject?: boolean): number;
+    getElementByPos(pos: number): K;
+    /**
+     * @description Check key if exist in container.
+     * @param key - The element you want to search.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @returns An iterator pointing to the element if found, or super end if not found.
+     */
+    find(key: K, isObject?: boolean): HashSetIterator<K>;
+    forEach(callback: (element: K, index: number, container: HashSet<K>) => void): void;
+    [Symbol.iterator](): Generator<K, void, unknown>;
+}
+export default HashSet;

node_modules/js-sdsl/dist/cjs/container/HashContainer/HashSet.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _Base = require("./Base");
+
+var _throwError = require("../../utils/throwError");
+
+class HashSetIterator extends _Base.HashContainerIterator {
+    constructor(t, e, r, s) {
+        super(t, e, s);
+        this.container = r;
+    }
+    get pointer() {
+        if (this.o === this.h) {
+            (0, _throwError.throwIteratorAccessError)();
+        }
+        return this.o.u;
+    }
+    copy() {
+        return new HashSetIterator(this.o, this.h, this.container, this.iteratorType);
+    }
+}
+
+class HashSet extends _Base.HashContainer {
+    constructor(t = []) {
+        super();
+        const e = this;
+        t.forEach((function(t) {
+            e.insert(t);
+        }));
+    }
+    begin() {
+        return new HashSetIterator(this.p, this.h, this);
+    }
+    end() {
+        return new HashSetIterator(this.h, this.h, this);
+    }
+    rBegin() {
+        return new HashSetIterator(this._, this.h, this, 1);
+    }
+    rEnd() {
+        return new HashSetIterator(this.h, this.h, this, 1);
+    }
+    front() {
+        return this.p.u;
+    }
+    back() {
+        return this._.u;
+    }
+    insert(t, e) {
+        return this.M(t, undefined, e);
+    }
+    getElementByPos(t) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        let e = this.p;
+        while (t--) {
+            e = e.B;
+        }
+        return e.u;
+    }
+    find(t, e) {
+        const r = this.I(t, e);
+        return new HashSetIterator(r, this.h, this);
+    }
+    forEach(t) {
+        let e = 0;
+        let r = this.p;
+        while (r !== this.h) {
+            t(r.u, e++, this);
+            r = r.B;
+        }
+    }
+    [Symbol.iterator]() {
+        return function*() {
+            let t = this.p;
+            while (t !== this.h) {
+                yield t.u;
+                t = t.B;
+            }
+        }.bind(this)();
+    }
+}
+
+var _default = HashSet;
+
+exports.default = _default;
+//# sourceMappingURL=HashSet.js.map

node_modules/js-sdsl/dist/cjs/container/OtherContainer/PriorityQueue.d.ts

@@ -0,0 +1,79 @@
+import { Base, initContainer } from "../ContainerBase";
+declare class PriorityQueue<T> extends Base {
+    /**
+     * @description PriorityQueue's constructor.
+     * @param container - Initialize container, must have a forEach function.
+     * @param cmp - Compare function.
+     * @param copy - When the container is an array, you can choose to directly operate on the original object of
+     *               the array or perform a shallow copy. The default is shallow copy.
+     * @example
+     * new PriorityQueue();
+     * new PriorityQueue([1, 2, 3]);
+     * new PriorityQueue([1, 2, 3], (x, y) => x - y);
+     * new PriorityQueue([1, 2, 3], (x, y) => x - y, false);
+     */
+    constructor(container?: initContainer<T>, cmp?: (x: T, y: T) => number, copy?: boolean);
+    clear(): void;
+    /**
+     * @description Push element into a container in order.
+     * @param item - The element you want to push.
+     * @returns The size of heap after pushing.
+     * @example
+     * queue.push(1);
+     */
+    push(item: T): void;
+    /**
+     * @description Removes the top element.
+     * @returns The element you popped.
+     * @example
+     * queue.pop();
+     */
+    pop(): T | undefined;
+    /**
+     * @description Accesses the top element.
+     * @example
+     * const top = queue.top();
+     */
+    top(): T | undefined;
+    /**
+     * @description Check if element is in heap.
+     * @param item - The item want to find.
+     * @returns Whether element is in heap.
+     * @example
+     * const que = new PriorityQueue([], (x, y) => x.id - y.id);
+     * const obj = { id: 1 };
+     * que.push(obj);
+     * console.log(que.find(obj));  // true
+     */
+    find(item: T): boolean;
+    /**
+     * @description Remove specified item from heap.
+     * @param item - The item want to remove.
+     * @returns Whether remove success.
+     * @example
+     * const que = new PriorityQueue([], (x, y) => x.id - y.id);
+     * const obj = { id: 1 };
+     * que.push(obj);
+     * que.remove(obj);
+     */
+    remove(item: T): boolean;
+    /**
+     * @description Update item and it's pos in the heap.
+     * @param item - The item want to update.
+     * @returns Whether update success.
+     * @example
+     * const que = new PriorityQueue([], (x, y) => x.id - y.id);
+     * const obj = { id: 1 };
+     * que.push(obj);
+     * obj.id = 2;
+     * que.updateItem(obj);
+     */
+    updateItem(item: T): boolean;
+    /**
+     * @returns Return a copy array of heap.
+     * @example
+     * const arr = queue.toArray();
+     */
+    toArray(): T[];
+}
+export default PriorityQueue;

node_modules/js-sdsl/dist/cjs/container/OtherContainer/PriorityQueue.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _ContainerBase = require("../ContainerBase");
+
+class PriorityQueue extends _ContainerBase.Base {
+    constructor(t = [], s = function(t, s) {
+        if (t > s) return -1;
+        if (t < s) return 1;
+        return 0;
+    }, i = true) {
+        super();
+        this.v = s;
+        if (Array.isArray(t)) {
+            this.C = i ? [ ...t ] : t;
+        } else {
+            this.C = [];
+            const s = this;
+            t.forEach((function(t) {
+                s.C.push(t);
+            }));
+        }
+        this.i = this.C.length;
+        const e = this.i >> 1;
+        for (let t = this.i - 1 >> 1; t >= 0; --t) {
+            this.k(t, e);
+        }
+    }
+    m(t) {
+        const s = this.C[t];
+        while (t > 0) {
+            const i = t - 1 >> 1;
+            const e = this.C[i];
+            if (this.v(e, s) <= 0) break;
+            this.C[t] = e;
+            t = i;
+        }
+        this.C[t] = s;
+    }
+    k(t, s) {
+        const i = this.C[t];
+        while (t < s) {
+            let s = t << 1 | 1;
+            const e = s + 1;
+            let h = this.C[s];
+            if (e < this.i && this.v(h, this.C[e]) > 0) {
+                s = e;
+                h = this.C[e];
+            }
+            if (this.v(h, i) >= 0) break;
+            this.C[t] = h;
+            t = s;
+        }
+        this.C[t] = i;
+    }
+    clear() {
+        this.i = 0;
+        this.C.length = 0;
+    }
+    push(t) {
+        this.C.push(t);
+        this.m(this.i);
+        this.i += 1;
+    }
+    pop() {
+        if (this.i === 0) return;
+        const t = this.C[0];
+        const s = this.C.pop();
+        this.i -= 1;
+        if (this.i) {
+            this.C[0] = s;
+            this.k(0, this.i >> 1);
+        }
+        return t;
+    }
+    top() {
+        return this.C[0];
+    }
+    find(t) {
+        return this.C.indexOf(t) >= 0;
+    }
+    remove(t) {
+        const s = this.C.indexOf(t);
+        if (s < 0) return false;
+        if (s === 0) {
+            this.pop();
+        } else if (s === this.i - 1) {
+            this.C.pop();
+            this.i -= 1;
+        } else {
+            this.C.splice(s, 1, this.C.pop());
+            this.i -= 1;
+            this.m(s);
+            this.k(s, this.i >> 1);
+        }
+        return true;
+    }
+    updateItem(t) {
+        const s = this.C.indexOf(t);
+        if (s < 0) return false;
+        this.m(s);
+        this.k(s, this.i >> 1);
+        return true;
+    }
+    toArray() {
+        return [ ...this.C ];
+    }
+}
+
+var _default = PriorityQueue;
+
+exports.default = _default;
+//# sourceMappingURL=PriorityQueue.js.map

node_modules/js-sdsl/dist/cjs/container/OtherContainer/Queue.d.ts

@@ -0,0 +1,22 @@
+import { Base, initContainer } from "../ContainerBase";
+declare class Queue<T> extends Base {
+    constructor(container?: initContainer<T>);
+    clear(): void;
+    /**
+     * @description Inserts element to queue's end.
+     * @param element - The element you want to push to the front.
+     * @returns The container length after pushing.
+     */
+    push(element: T): number;
+    /**
+     * @description Removes the first element.
+     * @returns The element you popped.
+     */
+    pop(): T | undefined;
+    /**
+     * @description Access the first element.
+     * @returns The first element.
+     */
+    front(): T | undefined;
+}
+export default Queue;

node_modules/js-sdsl/dist/cjs/container/OtherContainer/Queue.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _ContainerBase = require("../ContainerBase");
+
+class Queue extends _ContainerBase.Base {
+    constructor(t = []) {
+        super();
+        this.j = 0;
+        this.q = [];
+        const s = this;
+        t.forEach((function(t) {
+            s.push(t);
+        }));
+    }
+    clear() {
+        this.q = [];
+        this.i = this.j = 0;
+    }
+    push(t) {
+        const s = this.q.length;
+        if (this.j / s > .5 && this.j + this.i >= s && s > 4096) {
+            const s = this.i;
+            for (let t = 0; t < s; ++t) {
+                this.q[t] = this.q[this.j + t];
+            }
+            this.j = 0;
+            this.q[this.i] = t;
+        } else this.q[this.j + this.i] = t;
+        return ++this.i;
+    }
+    pop() {
+        if (this.i === 0) return;
+        const t = this.q[this.j++];
+        this.i -= 1;
+        return t;
+    }
+    front() {
+        if (this.i === 0) return;
+        return this.q[this.j];
+    }
+}
+
+var _default = Queue;
+
+exports.default = _default;
+//# sourceMappingURL=Queue.js.map

node_modules/js-sdsl/dist/cjs/container/OtherContainer/Queue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["container/OtherContainer/Queue.js","../../src/container/OtherContainer/Queue.ts"],"names":["Object","defineProperty","exports","value","default","_ContainerBase","require","Queue","Base","constructor","container","super","this","_first","_queue","self","forEach","el","push","clear","_length","element","capacity","length","i","pop","front","_default"],"mappings":"AAAA;;AAEAA,OAAOC,eAAeC,SAAS,KAAc;IAC3CC,OAAO;;;AAETD,QAAQE,eAAe;;ACLvB,IAAAC,iBAAAC,QAAA;;AAOA,MAAMC,cAAiBC,eAAAA;IASrBC,YAAYC,IAA8B;QACxCC;QANMC,KAAAC,IAAS;QAITD,KAAAE,IAAc;QAGpB,MAAMC,IAAOH;QACbF,EAAUM,SAAQ,SAAUC;YAC1BF,EAAKG,KAAKD;ADLR;AACJ;ICOFE;QACEP,KAAKE,IAAS;QACdF,KAAKQ,IAAUR,KAAKC,IAAS;ADL7B;ICYFK,KAAKG;QACH,MAAMC,IAAWV,KAAKE,EAAOS;QAC7B,IACGX,KAAKC,IAASS,IAAS,MACvBV,KAAKC,IAASD,KAAKQ,KAAYE,KAChCA,IAAQ,MACR;YACA,MAAMC,IAASX,KAAKQ;YACpB,KAAK,IAAII,IAAI,GAAGA,IAAID,KAAUC,GAAG;gBAC/BZ,KAAKE,EAAOU,KAAKZ,KAAKE,EAAOF,KAAKC,IAASW;ADPvC;YCSNZ,KAAKC,IAAS;YACdD,KAAKE,EAAOF,KAAKQ,KAAWC;ADP1B,eCQGT,KAAKE,EAAOF,KAAKC,IAASD,KAAKQ,KAAWC;QACjD,SAAST,KAAKQ;ADLd;ICWFK;QACE,IAAIb,KAAKQ,MAAY,GAAG;QACxB,MAAMH,IAAKL,KAAKE,EAAOF,KAAKC;QAC5BD,KAAKQ,KAAW;QAChB,OAAOH;ADJP;ICUFS;QACE,IAAId,KAAKQ,MAAY,GAAG;QACxB,OAAOR,KAAKE,EAAOF,KAAKC;ADHxB;;;ACKH,IAAAc,WAEcpB;;AAAKL,QAAAE,UAAAuB","file":"Queue.js","sourcesContent":["import { Base } from \"../ContainerBase\";\nclass Queue extends Base {\n    constructor(container = []) {\n        super();\n        /**\n         * @internal\n         */\n        this._first = 0;\n        /**\n         * @internal\n         */\n        this._queue = [];\n        const self = this;\n        container.forEach(function (el) {\n            self.push(el);\n        });\n    }\n    clear() {\n        this._queue = [];\n        this._length = this._first = 0;\n    }\n    /**\n     * @description Inserts element to queue's end.\n     * @param element - The element you want to push to the front.\n     * @returns The container length after pushing.\n     */\n    push(element) {\n        const capacity = this._queue.length;\n        if ((this._first / capacity) > 0.5 /* QUEUE_CONSTANT.ALLOCATE_SIGMA */ &&\n            (this._first + this._length) >= capacity &&\n            capacity > 4096 /* QUEUE_CONSTANT.MIN_ALLOCATE_SIZE */) {\n            const length = this._length;\n            for (let i = 0; i < length; ++i) {\n                this._queue[i] = this._queue[this._first + i];\n            }\n            this._first = 0;\n            this._queue[this._length] = element;\n        }\n        else\n            this._queue[this._first + this._length] = element;\n        return ++this._length;\n    }\n    /**\n     * @description Removes the first element.\n     * @returns The element you popped.\n     */\n    pop() {\n        if (this._length === 0)\n            return;\n        const el = this._queue[this._first++];\n        this._length -= 1;\n        return el;\n    }\n    /**\n     * @description Access the first element.\n     * @returns The first element.\n     */\n    front() {\n        if (this._length === 0)\n            return;\n        return this._queue[this._first];\n    }\n}\nexport default Queue;\n","import { Base, initContainer } from '@/container/ContainerBase';\n\nconst enum QUEUE_CONSTANT {\n  ALLOCATE_SIGMA = 0.5,\n  MIN_ALLOCATE_SIZE = (1 << 12)\n}\n\nclass Queue<T> extends Base {\n  /**\n   * @internal\n   */\n  private _first = 0;\n  /**\n   * @internal\n   */\n  private _queue: T[] = [];\n  constructor(container: initContainer<T> = []) {\n    super();\n    const self = this;\n    container.forEach(function (el) {\n      self.push(el);\n    });\n  }\n  clear() {\n    this._queue = [];\n    this._length = this._first = 0;\n  }\n  /**\n   * @description Inserts element to queue's end.\n   * @param element - The element you want to push to the front.\n   * @returns The container length after pushing.\n   */\n  push(element: T) {\n    const capacity = this._queue.length;\n    if (\n      (this._first / capacity) > QUEUE_CONSTANT.ALLOCATE_SIGMA &&\n      (this._first + this._length) >= capacity &&\n      capacity > QUEUE_CONSTANT.MIN_ALLOCATE_SIZE\n    ) {\n      const length = this._length;\n      for (let i = 0; i < length; ++i) {\n        this._queue[i] = this._queue[this._first + i];\n      }\n      this._first = 0;\n      this._queue[this._length] = element;\n    } else this._queue[this._first + this._length] = element;\n    return ++this._length;\n  }\n  /**\n   * @description Removes the first element.\n   * @returns The element you popped.\n   */\n  pop() {\n    if (this._length === 0) return;\n    const el = this._queue[this._first++];\n    this._length -= 1;\n    return el;\n  }\n  /**\n   * @description Access the first element.\n   * @returns The first element.\n   */\n  front(): T | undefined {\n    if (this._length === 0) return;\n    return this._queue[this._first];\n  }\n}\n\nexport default Queue;\n"]}

node_modules/js-sdsl/dist/cjs/container/OtherContainer/Stack.d.ts

@@ -0,0 +1,22 @@
+import { Base, initContainer } from "../ContainerBase";
+declare class Stack<T> extends Base {
+    constructor(container?: initContainer<T>);
+    clear(): void;
+    /**
+     * @description Insert element to stack's end.
+     * @description The element you want to push to the back.
+     * @returns The container length after erasing.
+     */
+    push(element: T): number;
+    /**
+     * @description Removes the end element.
+     * @returns The element you popped.
+     */
+    pop(): T | undefined;
+    /**
+     * @description Accesses the end element.
+     * @returns The last element.
+     */
+    top(): T | undefined;
+}
+export default Stack;

node_modules/js-sdsl/dist/cjs/container/OtherContainer/Stack.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _ContainerBase = require("../ContainerBase");
+
+class Stack extends _ContainerBase.Base {
+    constructor(t = []) {
+        super();
+        this.S = [];
+        const s = this;
+        t.forEach((function(t) {
+            s.push(t);
+        }));
+    }
+    clear() {
+        this.i = 0;
+        this.S = [];
+    }
+    push(t) {
+        this.S.push(t);
+        this.i += 1;
+        return this.i;
+    }
+    pop() {
+        if (this.i === 0) return;
+        this.i -= 1;
+        return this.S.pop();
+    }
+    top() {
+        return this.S[this.i - 1];
+    }
+}
+
+var _default = Stack;
+
+exports.default = _default;
+//# sourceMappingURL=Stack.js.map

node_modules/js-sdsl/dist/cjs/container/OtherContainer/Stack.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["container/OtherContainer/Stack.js","../../src/container/OtherContainer/Stack.ts"],"names":["Object","defineProperty","exports","value","default","_ContainerBase","require","Stack","Base","constructor","container","super","this","_stack","self","forEach","el","push","clear","_length","element","pop","top","_default"],"mappings":"AAAA;;AAEAA,OAAOC,eAAeC,SAAS,KAAc;IAC3CC,OAAO;;;AAETD,QAAQE,eAAe;;ACLvB,IAAAC,iBAAAC,QAAA;;AAEA,MAAMC,cAAiBC,eAAAA;IAKrBC,YAAYC,IAA8B;QACxCC;QAFMC,KAAAC,IAAc;QAGpB,MAAMC,IAAOF;QACbF,EAAUK,SAAQ,SAAUC;YAC1BF,EAAKG,KAAKD;ADAR;AACJ;ICEFE;QACEN,KAAKO,IAAU;QACfP,KAAKC,IAAS;ADAd;ICOFI,KAAKG;QACHR,KAAKC,EAAOI,KAAKG;QACjBR,KAAKO,KAAW;QAChB,OAAOP,KAAKO;ADAZ;ICMFE;QACE,IAAIT,KAAKO,MAAY,GAAG;QACxBP,KAAKO,KAAW;QAChB,OAAOP,KAAKC,EAAOQ;ADCnB;ICKFC;QACE,OAAOV,KAAKC,EAAOD,KAAKO,IAAU;ADClC;;;ACCH,IAAAI,WAEchB;;AAAKL,QAAAE,UAAAmB","file":"Stack.js","sourcesContent":["import { Base } from \"../ContainerBase\";\nclass Stack extends Base {\n    constructor(container = []) {\n        super();\n        /**\n         * @internal\n         */\n        this._stack = [];\n        const self = this;\n        container.forEach(function (el) {\n            self.push(el);\n        });\n    }\n    clear() {\n        this._length = 0;\n        this._stack = [];\n    }\n    /**\n     * @description Insert element to stack's end.\n     * @description The element you want to push to the back.\n     * @returns The container length after erasing.\n     */\n    push(element) {\n        this._stack.push(element);\n        this._length += 1;\n        return this._length;\n    }\n    /**\n     * @description Removes the end element.\n     * @returns The element you popped.\n     */\n    pop() {\n        if (this._length === 0)\n            return;\n        this._length -= 1;\n        return this._stack.pop();\n    }\n    /**\n     * @description Accesses the end element.\n     * @returns The last element.\n     */\n    top() {\n        return this._stack[this._length - 1];\n    }\n}\nexport default Stack;\n","import { Base, initContainer } from '@/container/ContainerBase';\n\nclass Stack<T> extends Base {\n  /**\n   * @internal\n   */\n  private _stack: T[] = [];\n  constructor(container: initContainer<T> = []) {\n    super();\n    const self = this;\n    container.forEach(function (el) {\n      self.push(el);\n    });\n  }\n  clear() {\n    this._length = 0;\n    this._stack = [];\n  }\n  /**\n   * @description Insert element to stack's end.\n   * @description The element you want to push to the back.\n   * @returns The container length after erasing.\n   */\n  push(element: T) {\n    this._stack.push(element);\n    this._length += 1;\n    return this._length;\n  }\n  /**\n   * @description Removes the end element.\n   * @returns The element you popped.\n   */\n  pop() {\n    if (this._length === 0) return;\n    this._length -= 1;\n    return this._stack.pop();\n  }\n  /**\n   * @description Accesses the end element.\n   * @returns The last element.\n   */\n  top(): T | undefined {\n    return this._stack[this._length - 1];\n  }\n}\n\nexport default Stack;\n"]}

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/Base/RandomIterator.d.ts

@@ -0,0 +1,9 @@
+import { ContainerIterator } from "../../ContainerBase";
+import SequentialContainer from "./index";
+export declare abstract class RandomIterator<T> extends ContainerIterator<T> {
+    abstract readonly container: SequentialContainer<T>;
+    get pointer(): T;
+    set pointer(newValue: T);
+    pre(): this;
+    next(): this;
+}

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/Base/RandomIterator.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.RandomIterator = void 0;
+
+var _ContainerBase = require("../../ContainerBase");
+
+var _throwError = require("../../../utils/throwError");
+
+class RandomIterator extends _ContainerBase.ContainerIterator {
+    constructor(t, r) {
+        super(r);
+        this.o = t;
+        if (this.iteratorType === 0) {
+            this.pre = function() {
+                if (this.o === 0) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o -= 1;
+                return this;
+            };
+            this.next = function() {
+                if (this.o === this.container.size()) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o += 1;
+                return this;
+            };
+        } else {
+            this.pre = function() {
+                if (this.o === this.container.size() - 1) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o += 1;
+                return this;
+            };
+            this.next = function() {
+                if (this.o === -1) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o -= 1;
+                return this;
+            };
+        }
+    }
+    get pointer() {
+        return this.container.getElementByPos(this.o);
+    }
+    set pointer(t) {
+        this.container.setElementByPos(this.o, t);
+    }
+}
+
+exports.RandomIterator = RandomIterator;
+//# sourceMappingURL=RandomIterator.js.map

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/Base/RandomIterator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["container/SequentialContainer/Base/RandomIterator.js","../../src/container/SequentialContainer/Base/RandomIterator.ts"],"names":["Object","defineProperty","exports","value","RandomIterator","_ContainerBase","require","_throwError","ContainerIterator","constructor","index","iteratorType","super","this","_node","pre","throwIteratorAccessError","next","container","size","pointer","getElementByPos","newValue","setElementByPos"],"mappings":"AAAA;;AAEAA,OAAOC,eAAeC,SAAS,KAAc;IAC3CC,OAAO;;;AAETD,QAAQE,sBAAsB;;ACL9B,IAAAC,iBAAAC,QAAA;;AAEA,IAAAC,cAAAD,QAAA;;AAEM,MAAgBF,uBAA0BI,eAAAA;IAS9CC,YACEC,GACAC;QAEAC,MAAMD;QACNE,KAAKC,IAAQJ;QACb,IAAIG,KAAKF,iBAAY,GAA0B;YAC7CE,KAAKE,MAAM;gBACT,IAAIF,KAAKC,MAAU,GAAG;qBACpB,GAAAE,YAAAA;ADTM;gBCWRH,KAAKC,KAAS;gBACd,OAAOD;ADTH;YCWNA,KAAKI,OAAO;gBACV,IAAIJ,KAAKC,MAAUD,KAAKK,UAAUC,QAAQ;qBACxC,GAAAH,YAAAA;ADTM;gBCWRH,KAAKC,KAAS;gBACd,OAAOD;ADTH;AACJ,eCUG;YACLA,KAAKE,MAAM;gBACT,IAAIF,KAAKC,MAAUD,KAAKK,UAAUC,SAAS,GAAG;qBAC5C,GAAAH,YAAAA;ADRM;gBCURH,KAAKC,KAAS;gBACd,OAAOD;ADRH;YCUNA,KAAKI,OAAO;gBACV,IAAIJ,KAAKC,OAAW,GAAG;qBACrB,GAAAE,YAAAA;ADRM;gBCURH,KAAKC,KAAS;gBACd,OAAOD;ADRH;AACJ;AACJ;ICUEO;QACF,OAAOP,KAAKK,UAAUG,gBAAgBR,KAAKC;ADR3C;ICUEM,YAAQE;QACVT,KAAKK,UAAUK,gBAAgBV,KAAKC,GAAOQ;ADR3C;;;ACcHpB,QAAAE,iBAAAA","file":"RandomIterator.js","sourcesContent":["import { ContainerIterator } from \"../../ContainerBase\";\nimport { throwIteratorAccessError } from \"../../../utils/throwError\";\nexport class RandomIterator extends ContainerIterator {\n    /**\n     * @internal\n     */\n    constructor(index, iteratorType) {\n        super(iteratorType);\n        this._node = index;\n        if (this.iteratorType === 0 /* IteratorType.NORMAL */) {\n            this.pre = function () {\n                if (this._node === 0) {\n                    throwIteratorAccessError();\n                }\n                this._node -= 1;\n                return this;\n            };\n            this.next = function () {\n                if (this._node === this.container.size()) {\n                    throwIteratorAccessError();\n                }\n                this._node += 1;\n                return this;\n            };\n        }\n        else {\n            this.pre = function () {\n                if (this._node === this.container.size() - 1) {\n                    throwIteratorAccessError();\n                }\n                this._node += 1;\n                return this;\n            };\n            this.next = function () {\n                if (this._node === -1) {\n                    throwIteratorAccessError();\n                }\n                this._node -= 1;\n                return this;\n            };\n        }\n    }\n    get pointer() {\n        return this.container.getElementByPos(this._node);\n    }\n    set pointer(newValue) {\n        this.container.setElementByPos(this._node, newValue);\n    }\n}\n","import { ContainerIterator, IteratorType } from '@/container/ContainerBase';\nimport SequentialContainer from '@/container/SequentialContainer/Base/index';\nimport { throwIteratorAccessError } from '@/utils/throwError';\n\nexport abstract class RandomIterator<T> extends ContainerIterator<T> {\n  abstract readonly container: SequentialContainer<T>;\n  /**\n   * @internal\n   */\n  _node: number;\n  /**\n   * @internal\n   */\n  protected constructor(\n    index: number,\n    iteratorType?: IteratorType\n  ) {\n    super(iteratorType);\n    this._node = index;\n    if (this.iteratorType === IteratorType.NORMAL) {\n      this.pre = function () {\n        if (this._node === 0) {\n          throwIteratorAccessError();\n        }\n        this._node -= 1;\n        return this;\n      };\n      this.next = function () {\n        if (this._node === this.container.size()) {\n          throwIteratorAccessError();\n        }\n        this._node += 1;\n        return this;\n      };\n    } else {\n      this.pre = function () {\n        if (this._node === this.container.size() - 1) {\n          throwIteratorAccessError();\n        }\n        this._node += 1;\n        return this;\n      };\n      this.next = function () {\n        if (this._node === -1) {\n          throwIteratorAccessError();\n        }\n        this._node -= 1;\n        return this;\n      };\n    }\n  }\n  get pointer() {\n    return this.container.getElementByPos(this._node);\n  }\n  set pointer(newValue: T) {\n    this.container.setElementByPos(this._node, newValue);\n  }\n  // @ts-ignore\n  pre(): this;\n  // @ts-ignore\n  next(): this;\n}\n"]}

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/Base/index.d.ts

@@ -0,0 +1,67 @@
+import { Container } from "../../ContainerBase";
+declare abstract class SequentialContainer<T> extends Container<T> {
+    /**
+     * @description Push the element to the back.
+     * @param element - The element you want to push.
+     * @returns The size of container after pushing.
+     */
+    abstract pushBack(element: T): number;
+    /**
+     * @description Removes the last element.
+     * @returns The element you popped.
+     */
+    abstract popBack(): T | undefined;
+    /**
+     * @description Sets element by position.
+     * @param pos - The position you want to change.
+     * @param element - The element's value you want to update.
+     * @example
+     * container.setElementByPos(-1, 1); // throw a RangeError
+     */
+    abstract setElementByPos(pos: number, element: T): void;
+    /**
+     * @description Removes the elements of the specified value.
+     * @param value - The value you want to remove.
+     * @returns The size of container after erasing.
+     * @example
+     * container.eraseElementByValue(-1);
+     */
+    abstract eraseElementByValue(value: T): number;
+    /**
+     * @description Insert several elements after the specified position.
+     * @param pos - The position you want to insert.
+     * @param element - The element you want to insert.
+     * @param num - The number of elements you want to insert (default 1).
+     * @returns The size of container after inserting.
+     * @example
+     * const container = new Vector([1, 2, 3]);
+     * container.insert(1, 4);  // [1, 4, 2, 3]
+     * container.insert(1, 5, 3); // [1, 5, 5, 5, 4, 2, 3]
+     */
+    abstract insert(pos: number, element: T, num?: number): number;
+    /**
+     * @description Reverses the container.
+     * @example
+     * const container = new Vector([1, 2, 3]);
+     * container.reverse(); // [3, 2, 1]
+     */
+    abstract reverse(): void;
+    /**
+     * @description Removes the duplication of elements in the container.
+     * @returns The size of container after inserting.
+     * @example
+     * const container = new Vector([1, 1, 3, 2, 2, 5, 5, 2]);
+     * container.unique(); // [1, 3, 2, 5, 2]
+     */
+    abstract unique(): number;
+    /**
+     * @description Sort the container.
+     * @param cmp - Comparison function to sort.
+     * @example
+     * const container = new Vector([3, 1, 10]);
+     * container.sort();  // [1, 10, 3]
+     * container.sort((x, y) => x - y); // [1, 3, 10]
+     */
+    abstract sort(cmp?: (x: T, y: T) => number): void;
+}
+export default SequentialContainer;

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/Base/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _ContainerBase = require("../../ContainerBase");
+
+class SequentialContainer extends _ContainerBase.Container {}
+
+var _default = SequentialContainer;
+
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/Base/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["container/SequentialContainer/Base/index.js","../../src/container/SequentialContainer/Base/index.ts"],"names":["Object","defineProperty","exports","value","default","_ContainerBase","require","SequentialContainer","Container","_default"],"mappings":"AAAA;;AAEAA,OAAOC,eAAeC,SAAS,KAAc;IAC3CC,OAAO;;;AAETD,QAAQE,eAAe;;ACLvB,IAAAC,iBAAAC,QAAA;;AAEA,MAAeC,4BAA+BC,eAAAA;;AAgE7C,IAAAC,WAEcF;;AAAmBL,QAAAE,UAAAK","file":"index.js","sourcesContent":[null,"import { Container } from '@/container/ContainerBase';\n\nabstract class SequentialContainer<T> extends Container<T> {\n  /**\n   * @description Push the element to the back.\n   * @param element - The element you want to push.\n   * @returns The size of container after pushing.\n   */\n  abstract pushBack(element: T): number;\n  /**\n   * @description Removes the last element.\n   * @returns The element you popped.\n   */\n  abstract popBack(): T | undefined;\n  /**\n   * @description Sets element by position.\n   * @param pos - The position you want to change.\n   * @param element - The element's value you want to update.\n   * @example\n   * container.setElementByPos(-1, 1); // throw a RangeError\n   */\n  abstract setElementByPos(pos: number, element: T): void;\n  /**\n   * @description Removes the elements of the specified value.\n   * @param value - The value you want to remove.\n   * @returns The size of container after erasing.\n   * @example\n   * container.eraseElementByValue(-1);\n   */\n  abstract eraseElementByValue(value: T): number;\n  /**\n   * @description Insert several elements after the specified position.\n   * @param pos - The position you want to insert.\n   * @param element - The element you want to insert.\n   * @param num - The number of elements you want to insert (default 1).\n   * @returns The size of container after inserting.\n   * @example\n   * const container = new Vector([1, 2, 3]);\n   * container.insert(1, 4);  // [1, 4, 2, 3]\n   * container.insert(1, 5, 3); // [1, 5, 5, 5, 4, 2, 3]\n   */\n  abstract insert(pos: number, element: T, num?: number): number;\n  /**\n   * @description Reverses the container.\n   * @example\n   * const container = new Vector([1, 2, 3]);\n   * container.reverse(); // [3, 2, 1]\n   */\n  abstract reverse(): void;\n  /**\n   * @description Removes the duplication of elements in the container.\n   * @returns The size of container after inserting.\n   * @example\n   * const container = new Vector([1, 1, 3, 2, 2, 5, 5, 2]);\n   * container.unique(); // [1, 3, 2, 5, 2]\n   */\n  abstract unique(): number;\n  /**\n   * @description Sort the container.\n   * @param cmp - Comparison function to sort.\n   * @example\n   * const container = new Vector([3, 1, 10]);\n   * container.sort();  // [1, 10, 3]\n   * container.sort((x, y) => x - y); // [1, 3, 10]\n   */\n  abstract sort(cmp?: (x: T, y: T) => number): void;\n}\n\nexport default SequentialContainer;\n"]}

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/Deque.d.ts

@@ -0,0 +1,58 @@
+import SequentialContainer from './Base';
+import { IteratorType, initContainer } from "../ContainerBase";
+import { RandomIterator } from "./Base/RandomIterator";
+declare class DequeIterator<T> extends RandomIterator<T> {
+    readonly container: Deque<T>;
+    constructor(node: number, container: Deque<T>, iteratorType?: IteratorType);
+    copy(): DequeIterator<T>;
+    equals(iter: DequeIterator<T>): boolean;
+}
+export type { DequeIterator };
+declare class Deque<T> extends SequentialContainer<T> {
+    constructor(container?: initContainer<T>, _bucketSize?: number);
+    clear(): void;
+    begin(): DequeIterator<T>;
+    end(): DequeIterator<T>;
+    rBegin(): DequeIterator<T>;
+    rEnd(): DequeIterator<T>;
+    front(): T | undefined;
+    back(): T | undefined;
+    pushBack(element: T): number;
+    popBack(): T | undefined;
+    /**
+     * @description Push the element to the front.
+     * @param element - The element you want to push.
+     * @returns The size of queue after pushing.
+     */
+    pushFront(element: T): number;
+    /**
+     * @description Remove the _first element.
+     * @returns The element you popped.
+     */
+    popFront(): T | undefined;
+    getElementByPos(pos: number): T;
+    setElementByPos(pos: number, element: T): void;
+    insert(pos: number, element: T, num?: number): number;
+    /**
+     * @description Remove all elements after the specified position (excluding the specified position).
+     * @param pos - The previous position of the first removed element.
+     * @returns The size of the container after cutting.
+     * @example
+     * deque.cut(1); // Then deque's size will be 2. deque -> [0, 1]
+     */
+    cut(pos: number): number;
+    eraseElementByPos(pos: number): number;
+    eraseElementByValue(value: T): number;
+    eraseElementByIterator(iter: DequeIterator<T>): DequeIterator<T>;
+    find(element: T): DequeIterator<T>;
+    reverse(): void;
+    unique(): number;
+    sort(cmp?: (x: T, y: T) => number): void;
+    /**
+     * @description Remove as much useless space as possible.
+     */
+    shrinkToFit(): void;
+    forEach(callback: (element: T, index: number, deque: Deque<T>) => void): void;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+}
+export default Deque;

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/Deque.js

@@ -0,0 +1,338 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _Base = _interopRequireDefault(require("./Base"));
+
+var _RandomIterator = require("./Base/RandomIterator");
+
+function _interopRequireDefault(t) {
+    return t && t.t ? t : {
+        default: t
+    };
+}
+
+class DequeIterator extends _RandomIterator.RandomIterator {
+    constructor(t, i, s) {
+        super(t, s);
+        this.container = i;
+    }
+    copy() {
+        return new DequeIterator(this.o, this.container, this.iteratorType);
+    }
+}
+
+class Deque extends _Base.default {
+    constructor(t = [], i = 1 << 12) {
+        super();
+        this.j = 0;
+        this.D = 0;
+        this.R = 0;
+        this.N = 0;
+        this.P = 0;
+        this.A = [];
+        const s = (() => {
+            if (typeof t.length === "number") return t.length;
+            if (typeof t.size === "number") return t.size;
+            if (typeof t.size === "function") return t.size();
+            throw new TypeError("Cannot get the length or size of the container");
+        })();
+        this.F = i;
+        this.P = Math.max(Math.ceil(s / this.F), 1);
+        for (let t = 0; t < this.P; ++t) {
+            this.A.push(new Array(this.F));
+        }
+        const h = Math.ceil(s / this.F);
+        this.j = this.R = (this.P >> 1) - (h >> 1);
+        this.D = this.N = this.F - s % this.F >> 1;
+        const e = this;
+        t.forEach((function(t) {
+            e.pushBack(t);
+        }));
+    }
+    T() {
+        const t = [];
+        const i = Math.max(this.P >> 1, 1);
+        for (let s = 0; s < i; ++s) {
+            t[s] = new Array(this.F);
+        }
+        for (let i = this.j; i < this.P; ++i) {
+            t[t.length] = this.A[i];
+        }
+        for (let i = 0; i < this.R; ++i) {
+            t[t.length] = this.A[i];
+        }
+        t[t.length] = [ ...this.A[this.R] ];
+        this.j = i;
+        this.R = t.length - 1;
+        for (let s = 0; s < i; ++s) {
+            t[t.length] = new Array(this.F);
+        }
+        this.A = t;
+        this.P = t.length;
+    }
+    O(t) {
+        const i = this.D + t + 1;
+        const s = i % this.F;
+        let h = s - 1;
+        let e = this.j + (i - s) / this.F;
+        if (s === 0) e -= 1;
+        e %= this.P;
+        if (h < 0) h += this.F;
+        return {
+            curNodeBucketIndex: e,
+            curNodePointerIndex: h
+        };
+    }
+    clear() {
+        this.A = [ new Array(this.F) ];
+        this.P = 1;
+        this.j = this.R = this.i = 0;
+        this.D = this.N = this.F >> 1;
+    }
+    begin() {
+        return new DequeIterator(0, this);
+    }
+    end() {
+        return new DequeIterator(this.i, this);
+    }
+    rBegin() {
+        return new DequeIterator(this.i - 1, this, 1);
+    }
+    rEnd() {
+        return new DequeIterator(-1, this, 1);
+    }
+    front() {
+        if (this.i === 0) return;
+        return this.A[this.j][this.D];
+    }
+    back() {
+        if (this.i === 0) return;
+        return this.A[this.R][this.N];
+    }
+    pushBack(t) {
+        if (this.i) {
+            if (this.N < this.F - 1) {
+                this.N += 1;
+            } else if (this.R < this.P - 1) {
+                this.R += 1;
+                this.N = 0;
+            } else {
+                this.R = 0;
+                this.N = 0;
+            }
+            if (this.R === this.j && this.N === this.D) this.T();
+        }
+        this.i += 1;
+        this.A[this.R][this.N] = t;
+        return this.i;
+    }
+    popBack() {
+        if (this.i === 0) return;
+        const t = this.A[this.R][this.N];
+        if (this.i !== 1) {
+            if (this.N > 0) {
+                this.N -= 1;
+            } else if (this.R > 0) {
+                this.R -= 1;
+                this.N = this.F - 1;
+            } else {
+                this.R = this.P - 1;
+                this.N = this.F - 1;
+            }
+        }
+        this.i -= 1;
+        return t;
+    }
+    pushFront(t) {
+        if (this.i) {
+            if (this.D > 0) {
+                this.D -= 1;
+            } else if (this.j > 0) {
+                this.j -= 1;
+                this.D = this.F - 1;
+            } else {
+                this.j = this.P - 1;
+                this.D = this.F - 1;
+            }
+            if (this.j === this.R && this.D === this.N) this.T();
+        }
+        this.i += 1;
+        this.A[this.j][this.D] = t;
+        return this.i;
+    }
+    popFront() {
+        if (this.i === 0) return;
+        const t = this.A[this.j][this.D];
+        if (this.i !== 1) {
+            if (this.D < this.F - 1) {
+                this.D += 1;
+            } else if (this.j < this.P - 1) {
+                this.j += 1;
+                this.D = 0;
+            } else {
+                this.j = 0;
+                this.D = 0;
+            }
+        }
+        this.i -= 1;
+        return t;
+    }
+    getElementByPos(t) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        const {curNodeBucketIndex: i, curNodePointerIndex: s} = this.O(t);
+        return this.A[i][s];
+    }
+    setElementByPos(t, i) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        const {curNodeBucketIndex: s, curNodePointerIndex: h} = this.O(t);
+        this.A[s][h] = i;
+    }
+    insert(t, i, s = 1) {
+        if (t < 0 || t > this.i) {
+            throw new RangeError;
+        }
+        if (t === 0) {
+            while (s--) this.pushFront(i);
+        } else if (t === this.i) {
+            while (s--) this.pushBack(i);
+        } else {
+            const h = [];
+            for (let i = t; i < this.i; ++i) {
+                h.push(this.getElementByPos(i));
+            }
+            this.cut(t - 1);
+            for (let t = 0; t < s; ++t) this.pushBack(i);
+            for (let t = 0; t < h.length; ++t) this.pushBack(h[t]);
+        }
+        return this.i;
+    }
+    cut(t) {
+        if (t < 0) {
+            this.clear();
+            return 0;
+        }
+        const {curNodeBucketIndex: i, curNodePointerIndex: s} = this.O(t);
+        this.R = i;
+        this.N = s;
+        this.i = t + 1;
+        return this.i;
+    }
+    eraseElementByPos(t) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        if (t === 0) this.popFront(); else if (t === this.i - 1) this.popBack(); else {
+            const i = [];
+            for (let s = t + 1; s < this.i; ++s) {
+                i.push(this.getElementByPos(s));
+            }
+            this.cut(t);
+            this.popBack();
+            const s = this;
+            i.forEach((function(t) {
+                s.pushBack(t);
+            }));
+        }
+        return this.i;
+    }
+    eraseElementByValue(t) {
+        if (this.i === 0) return 0;
+        const i = [];
+        for (let s = 0; s < this.i; ++s) {
+            const h = this.getElementByPos(s);
+            if (h !== t) i.push(h);
+        }
+        const s = i.length;
+        for (let t = 0; t < s; ++t) this.setElementByPos(t, i[t]);
+        return this.cut(s - 1);
+    }
+    eraseElementByIterator(t) {
+        const i = t.o;
+        this.eraseElementByPos(i);
+        t = t.next();
+        return t;
+    }
+    find(t) {
+        for (let i = 0; i < this.i; ++i) {
+            if (this.getElementByPos(i) === t) {
+                return new DequeIterator(i, this);
+            }
+        }
+        return this.end();
+    }
+    reverse() {
+        let t = 0;
+        let i = this.i - 1;
+        while (t < i) {
+            const s = this.getElementByPos(t);
+            this.setElementByPos(t, this.getElementByPos(i));
+            this.setElementByPos(i, s);
+            t += 1;
+            i -= 1;
+        }
+    }
+    unique() {
+        if (this.i <= 1) {
+            return this.i;
+        }
+        let t = 1;
+        let i = this.getElementByPos(0);
+        for (let s = 1; s < this.i; ++s) {
+            const h = this.getElementByPos(s);
+            if (h !== i) {
+                i = h;
+                this.setElementByPos(t++, h);
+            }
+        }
+        while (this.i > t) this.popBack();
+        return this.i;
+    }
+    sort(t) {
+        const i = [];
+        for (let t = 0; t < this.i; ++t) {
+            i.push(this.getElementByPos(t));
+        }
+        i.sort(t);
+        for (let t = 0; t < this.i; ++t) this.setElementByPos(t, i[t]);
+    }
+    shrinkToFit() {
+        if (this.i === 0) return;
+        const t = [];
+        this.forEach((function(i) {
+            t.push(i);
+        }));
+        this.P = Math.max(Math.ceil(this.i / this.F), 1);
+        this.i = this.j = this.R = this.D = this.N = 0;
+        this.A = [];
+        for (let t = 0; t < this.P; ++t) {
+            this.A.push(new Array(this.F));
+        }
+        for (let i = 0; i < t.length; ++i) this.pushBack(t[i]);
+    }
+    forEach(t) {
+        for (let i = 0; i < this.i; ++i) {
+            t(this.getElementByPos(i), i, this);
+        }
+    }
+    [Symbol.iterator]() {
+        return function*() {
+            for (let t = 0; t < this.i; ++t) {
+                yield this.getElementByPos(t);
+            }
+        }.bind(this)();
+    }
+}
+
+var _default = Deque;
+
+exports.default = _default;
+//# sourceMappingURL=Deque.js.map

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/LinkList.d.ts

@@ -0,0 +1,58 @@
+import SequentialContainer from './Base';
+import { ContainerIterator, initContainer } from "../ContainerBase";
+declare class LinkListIterator<T> extends ContainerIterator<T> {
+    readonly container: LinkList<T>;
+    get pointer(): T;
+    set pointer(newValue: T);
+    copy(): LinkListIterator<T>;
+    equals(iter: LinkListIterator<T>): boolean;
+    pre(): this;
+    next(): this;
+}
+export type { LinkListIterator };
+declare class LinkList<T> extends SequentialContainer<T> {
+    constructor(container?: initContainer<T>);
+    clear(): void;
+    begin(): LinkListIterator<T>;
+    end(): LinkListIterator<T>;
+    rBegin(): LinkListIterator<T>;
+    rEnd(): LinkListIterator<T>;
+    front(): T | undefined;
+    back(): T | undefined;
+    getElementByPos(pos: number): T;
+    eraseElementByPos(pos: number): number;
+    eraseElementByValue(_value: T): number;
+    eraseElementByIterator(iter: LinkListIterator<T>): LinkListIterator<T>;
+    pushBack(element: T): number;
+    popBack(): T | undefined;
+    /**
+     * @description Push an element to the front.
+     * @param element - The element you want to push.
+     * @returns The size of queue after pushing.
+     */
+    pushFront(element: T): number;
+    /**
+     * @description Removes the first element.
+     * @returns The element you popped.
+     */
+    popFront(): T | undefined;
+    setElementByPos(pos: number, element: T): void;
+    insert(pos: number, element: T, num?: number): number;
+    find(element: T): LinkListIterator<T>;
+    reverse(): void;
+    unique(): number;
+    sort(cmp?: (x: T, y: T) => number): void;
+    /**
+     * @description Merges two sorted lists.
+     * @param list - The other list you want to merge (must be sorted).
+     * @returns The size of list after merging.
+     * @example
+     * const linkA = new LinkList([1, 3, 5]);
+     * const linkB = new LinkList([2, 4, 6]);
+     * linkA.merge(linkB);  // [1, 2, 3, 4, 5];
+     */
+    merge(list: LinkList<T>): number;
+    forEach(callback: (element: T, index: number, list: LinkList<T>) => void): void;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+}
+export default LinkList;

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/LinkList.js

@@ -0,0 +1,330 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _Base = _interopRequireDefault(require("./Base"));
+
+var _ContainerBase = require("../ContainerBase");
+
+var _throwError = require("../../utils/throwError");
+
+function _interopRequireDefault(t) {
+    return t && t.t ? t : {
+        default: t
+    };
+}
+
+class LinkListIterator extends _ContainerBase.ContainerIterator {
+    constructor(t, i, s, r) {
+        super(r);
+        this.o = t;
+        this.h = i;
+        this.container = s;
+        if (this.iteratorType === 0) {
+            this.pre = function() {
+                if (this.o.L === this.h) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.L;
+                return this;
+            };
+            this.next = function() {
+                if (this.o === this.h) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.B;
+                return this;
+            };
+        } else {
+            this.pre = function() {
+                if (this.o.B === this.h) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.B;
+                return this;
+            };
+            this.next = function() {
+                if (this.o === this.h) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.L;
+                return this;
+            };
+        }
+    }
+    get pointer() {
+        if (this.o === this.h) {
+            (0, _throwError.throwIteratorAccessError)();
+        }
+        return this.o.l;
+    }
+    set pointer(t) {
+        if (this.o === this.h) {
+            (0, _throwError.throwIteratorAccessError)();
+        }
+        this.o.l = t;
+    }
+    copy() {
+        return new LinkListIterator(this.o, this.h, this.container, this.iteratorType);
+    }
+}
+
+class LinkList extends _Base.default {
+    constructor(t = []) {
+        super();
+        this.h = {};
+        this.p = this._ = this.h.L = this.h.B = this.h;
+        const i = this;
+        t.forEach((function(t) {
+            i.pushBack(t);
+        }));
+    }
+    V(t) {
+        const {L: i, B: s} = t;
+        i.B = s;
+        s.L = i;
+        if (t === this.p) {
+            this.p = s;
+        }
+        if (t === this._) {
+            this._ = i;
+        }
+        this.i -= 1;
+    }
+    G(t, i) {
+        const s = i.B;
+        const r = {
+            l: t,
+            L: i,
+            B: s
+        };
+        i.B = r;
+        s.L = r;
+        if (i === this.h) {
+            this.p = r;
+        }
+        if (s === this.h) {
+            this._ = r;
+        }
+        this.i += 1;
+    }
+    clear() {
+        this.i = 0;
+        this.p = this._ = this.h.L = this.h.B = this.h;
+    }
+    begin() {
+        return new LinkListIterator(this.p, this.h, this);
+    }
+    end() {
+        return new LinkListIterator(this.h, this.h, this);
+    }
+    rBegin() {
+        return new LinkListIterator(this._, this.h, this, 1);
+    }
+    rEnd() {
+        return new LinkListIterator(this.h, this.h, this, 1);
+    }
+    front() {
+        return this.p.l;
+    }
+    back() {
+        return this._.l;
+    }
+    getElementByPos(t) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        let i = this.p;
+        while (t--) {
+            i = i.B;
+        }
+        return i.l;
+    }
+    eraseElementByPos(t) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        let i = this.p;
+        while (t--) {
+            i = i.B;
+        }
+        this.V(i);
+        return this.i;
+    }
+    eraseElementByValue(t) {
+        let i = this.p;
+        while (i !== this.h) {
+            if (i.l === t) {
+                this.V(i);
+            }
+            i = i.B;
+        }
+        return this.i;
+    }
+    eraseElementByIterator(t) {
+        const i = t.o;
+        if (i === this.h) {
+            (0, _throwError.throwIteratorAccessError)();
+        }
+        t = t.next();
+        this.V(i);
+        return t;
+    }
+    pushBack(t) {
+        this.G(t, this._);
+        return this.i;
+    }
+    popBack() {
+        if (this.i === 0) return;
+        const t = this._.l;
+        this.V(this._);
+        return t;
+    }
+    pushFront(t) {
+        this.G(t, this.h);
+        return this.i;
+    }
+    popFront() {
+        if (this.i === 0) return;
+        const t = this.p.l;
+        this.V(this.p);
+        return t;
+    }
+    setElementByPos(t, i) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        let s = this.p;
+        while (t--) {
+            s = s.B;
+        }
+        s.l = i;
+    }
+    insert(t, i, s = 1) {
+        if (t < 0 || t > this.i) {
+            throw new RangeError;
+        }
+        if (s <= 0) return this.i;
+        if (t === 0) {
+            while (s--) this.pushFront(i);
+        } else if (t === this.i) {
+            while (s--) this.pushBack(i);
+        } else {
+            let r = this.p;
+            for (let i = 1; i < t; ++i) {
+                r = r.B;
+            }
+            const e = r.B;
+            this.i += s;
+            while (s--) {
+                r.B = {
+                    l: i,
+                    L: r
+                };
+                r.B.L = r;
+                r = r.B;
+            }
+            r.B = e;
+            e.L = r;
+        }
+        return this.i;
+    }
+    find(t) {
+        let i = this.p;
+        while (i !== this.h) {
+            if (i.l === t) {
+                return new LinkListIterator(i, this.h, this);
+            }
+            i = i.B;
+        }
+        return this.end();
+    }
+    reverse() {
+        if (this.i <= 1) return;
+        let t = this.p;
+        let i = this._;
+        let s = 0;
+        while (s << 1 < this.i) {
+            const r = t.l;
+            t.l = i.l;
+            i.l = r;
+            t = t.B;
+            i = i.L;
+            s += 1;
+        }
+    }
+    unique() {
+        if (this.i <= 1) {
+            return this.i;
+        }
+        let t = this.p;
+        while (t !== this.h) {
+            let i = t;
+            while (i.B !== this.h && i.l === i.B.l) {
+                i = i.B;
+                this.i -= 1;
+            }
+            t.B = i.B;
+            t.B.L = t;
+            t = t.B;
+        }
+        return this.i;
+    }
+    sort(t) {
+        if (this.i <= 1) return;
+        const i = [];
+        this.forEach((function(t) {
+            i.push(t);
+        }));
+        i.sort(t);
+        let s = this.p;
+        i.forEach((function(t) {
+            s.l = t;
+            s = s.B;
+        }));
+    }
+    merge(t) {
+        const i = this;
+        if (this.i === 0) {
+            t.forEach((function(t) {
+                i.pushBack(t);
+            }));
+        } else {
+            let s = this.p;
+            t.forEach((function(t) {
+                while (s !== i.h && s.l <= t) {
+                    s = s.B;
+                }
+                i.G(t, s.L);
+            }));
+        }
+        return this.i;
+    }
+    forEach(t) {
+        let i = this.p;
+        let s = 0;
+        while (i !== this.h) {
+            t(i.l, s++, this);
+            i = i.B;
+        }
+    }
+    [Symbol.iterator]() {
+        return function*() {
+            if (this.i === 0) return;
+            let t = this.p;
+            while (t !== this.h) {
+                yield t.l;
+                t = t.B;
+            }
+        }.bind(this)();
+    }
+}
+
+var _default = LinkList;
+
+exports.default = _default;
+//# sourceMappingURL=LinkList.js.map

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/Vector.d.ts

@@ -0,0 +1,40 @@
+import SequentialContainer from './Base';
+import { initContainer, IteratorType } from "../ContainerBase";
+import { RandomIterator } from "./Base/RandomIterator";
+declare class VectorIterator<T> extends RandomIterator<T> {
+    container: Vector<T>;
+    constructor(node: number, container: Vector<T>, iteratorType?: IteratorType);
+    copy(): VectorIterator<T>;
+    equals(iter: VectorIterator<T>): boolean;
+}
+export type { VectorIterator };
+declare class Vector<T> extends SequentialContainer<T> {
+    /**
+     * @param container - Initialize container, must have a forEach function.
+     * @param copy - When the container is an array, you can choose to directly operate on the original object of
+     *               the array or perform a shallow copy. The default is shallow copy.
+     */
+    constructor(container?: initContainer<T>, copy?: boolean);
+    clear(): void;
+    begin(): VectorIterator<T>;
+    end(): VectorIterator<T>;
+    rBegin(): VectorIterator<T>;
+    rEnd(): VectorIterator<T>;
+    front(): T | undefined;
+    back(): T | undefined;
+    getElementByPos(pos: number): T;
+    eraseElementByPos(pos: number): number;
+    eraseElementByValue(value: T): number;
+    eraseElementByIterator(iter: VectorIterator<T>): VectorIterator<T>;
+    pushBack(element: T): number;
+    popBack(): T | undefined;
+    setElementByPos(pos: number, element: T): void;
+    insert(pos: number, element: T, num?: number): number;
+    find(element: T): VectorIterator<T>;
+    reverse(): void;
+    unique(): number;
+    sort(cmp?: (x: T, y: T) => number): void;
+    forEach(callback: (element: T, index: number, vector: Vector<T>) => void): void;
+    [Symbol.iterator](): Generator<T, void, undefined>;
+}
+export default Vector;

node_modules/js-sdsl/dist/cjs/container/SequentialContainer/Vector.js

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _Base = _interopRequireDefault(require("./Base"));
+
+var _RandomIterator = require("./Base/RandomIterator");
+
+function _interopRequireDefault(t) {
+    return t && t.t ? t : {
+        default: t
+    };
+}
+
+class VectorIterator extends _RandomIterator.RandomIterator {
+    constructor(t, r, e) {
+        super(t, e);
+        this.container = r;
+    }
+    copy() {
+        return new VectorIterator(this.o, this.container, this.iteratorType);
+    }
+}
+
+class Vector extends _Base.default {
+    constructor(t = [], r = true) {
+        super();
+        if (Array.isArray(t)) {
+            this.J = r ? [ ...t ] : t;
+            this.i = t.length;
+        } else {
+            this.J = [];
+            const r = this;
+            t.forEach((function(t) {
+                r.pushBack(t);
+            }));
+        }
+    }
+    clear() {
+        this.i = 0;
+        this.J.length = 0;
+    }
+    begin() {
+        return new VectorIterator(0, this);
+    }
+    end() {
+        return new VectorIterator(this.i, this);
+    }
+    rBegin() {
+        return new VectorIterator(this.i - 1, this, 1);
+    }
+    rEnd() {
+        return new VectorIterator(-1, this, 1);
+    }
+    front() {
+        return this.J[0];
+    }
+    back() {
+        return this.J[this.i - 1];
+    }
+    getElementByPos(t) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        return this.J[t];
+    }
+    eraseElementByPos(t) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        this.J.splice(t, 1);
+        this.i -= 1;
+        return this.i;
+    }
+    eraseElementByValue(t) {
+        let r = 0;
+        for (let e = 0; e < this.i; ++e) {
+            if (this.J[e] !== t) {
+                this.J[r++] = this.J[e];
+            }
+        }
+        this.i = this.J.length = r;
+        return this.i;
+    }
+    eraseElementByIterator(t) {
+        const r = t.o;
+        t = t.next();
+        this.eraseElementByPos(r);
+        return t;
+    }
+    pushBack(t) {
+        this.J.push(t);
+        this.i += 1;
+        return this.i;
+    }
+    popBack() {
+        if (this.i === 0) return;
+        this.i -= 1;
+        return this.J.pop();
+    }
+    setElementByPos(t, r) {
+        if (t < 0 || t > this.i - 1) {
+            throw new RangeError;
+        }
+        this.J[t] = r;
+    }
+    insert(t, r, e = 1) {
+        if (t < 0 || t > this.i) {
+            throw new RangeError;
+        }
+        this.J.splice(t, 0, ...new Array(e).fill(r));
+        this.i += e;
+        return this.i;
+    }
+    find(t) {
+        for (let r = 0; r < this.i; ++r) {
+            if (this.J[r] === t) {
+                return new VectorIterator(r, this);
+            }
+        }
+        return this.end();
+    }
+    reverse() {
+        this.J.reverse();
+    }
+    unique() {
+        let t = 1;
+        for (let r = 1; r < this.i; ++r) {
+            if (this.J[r] !== this.J[r - 1]) {
+                this.J[t++] = this.J[r];
+            }
+        }
+        this.i = this.J.length = t;
+        return this.i;
+    }
+    sort(t) {
+        this.J.sort(t);
+    }
+    forEach(t) {
+        for (let r = 0; r < this.i; ++r) {
+            t(this.J[r], r, this);
+        }
+    }
+    [Symbol.iterator]() {
+        return function*() {
+            yield* this.J;
+        }.bind(this)();
+    }
+}
+
+var _default = Vector;
+
+exports.default = _default;
+//# sourceMappingURL=Vector.js.map

node_modules/js-sdsl/dist/cjs/container/TreeContainer/Base/TreeIterator.d.ts

@@ -0,0 +1,18 @@
+import { ContainerIterator } from "../../ContainerBase";
+import TreeContainer from "./index";
+declare abstract class TreeIterator<K, V> extends ContainerIterator<K | [K, V]> {
+    abstract readonly container: TreeContainer<K, V>;
+    /**
+     * @description Get the sequential index of the iterator in the tree container.<br/>
+     *              <strong>Note:</strong>
+     *              This function only takes effect when the specified tree container `enableIndex = true`.
+     * @returns The index subscript of the node in the tree.
+     * @example
+     * const st = new OrderedSet([1, 2, 3], true);
+     * console.log(st.begin().next().index);  // 1
+     */
+    get index(): number;
+    pre(): this;
+    next(): this;
+}
+export default TreeIterator;

node_modules/js-sdsl/dist/cjs/container/TreeContainer/Base/TreeIterator.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _ContainerBase = require("../../ContainerBase");
+
+var _throwError = require("../../../utils/throwError");
+
+class TreeIterator extends _ContainerBase.ContainerIterator {
+    constructor(t, r, i) {
+        super(i);
+        this.o = t;
+        this.h = r;
+        if (this.iteratorType === 0) {
+            this.pre = function() {
+                if (this.o === this.h.U) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.L();
+                return this;
+            };
+            this.next = function() {
+                if (this.o === this.h) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.B();
+                return this;
+            };
+        } else {
+            this.pre = function() {
+                if (this.o === this.h.W) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.B();
+                return this;
+            };
+            this.next = function() {
+                if (this.o === this.h) {
+                    (0, _throwError.throwIteratorAccessError)();
+                }
+                this.o = this.o.L();
+                return this;
+            };
+        }
+    }
+    get index() {
+        let t = this.o;
+        const r = this.h.tt;
+        if (t === this.h) {
+            if (r) {
+                return r.rt - 1;
+            }
+            return 0;
+        }
+        let i = 0;
+        if (t.U) {
+            i += t.U.rt;
+        }
+        while (t !== r) {
+            const r = t.tt;
+            if (t === r.W) {
+                i += 1;
+                if (r.U) {
+                    i += r.U.rt;
+                }
+            }
+            t = r;
+        }
+        return i;
+    }
+}
+
+var _default = TreeIterator;
+
+exports.default = _default;
+//# sourceMappingURL=TreeIterator.js.map

node_modules/js-sdsl/dist/cjs/container/TreeContainer/Base/TreeNode.d.ts

@@ -0,0 +1,47 @@
+export declare const enum TreeNodeColor {
+    RED = 1,
+    BLACK = 0
+}
+export declare class TreeNode<K, V> {
+    _color: TreeNodeColor;
+    _key: K | undefined;
+    _value: V | undefined;
+    _left: TreeNode<K, V> | undefined;
+    _right: TreeNode<K, V> | undefined;
+    _parent: TreeNode<K, V> | undefined;
+    constructor(key?: K, value?: V);
+    /**
+     * @description Get the pre node.
+     * @returns TreeNode about the pre node.
+     */
+    _pre(): TreeNode<K, V>;
+    /**
+     * @description Get the next node.
+     * @returns TreeNode about the next node.
+     */
+    _next(): TreeNode<K, V>;
+    /**
+     * @description Rotate left.
+     * @returns TreeNode about moved to original position after rotation.
+     */
+    _rotateLeft(): TreeNode<K, V>;
+    /**
+     * @description Rotate right.
+     * @returns TreeNode about moved to original position after rotation.
+     */
+    _rotateRight(): TreeNode<K, V>;
+}
+export declare class TreeNodeEnableIndex<K, V> extends TreeNode<K, V> {
+    _subTreeSize: number;
+    /**
+     * @description Rotate left and do recount.
+     * @returns TreeNode about moved to original position after rotation.
+     */
+    _rotateLeft(): TreeNodeEnableIndex<K, V>;
+    /**
+     * @description Rotate right and do recount.
+     * @returns TreeNode about moved to original position after rotation.
+     */
+    _rotateRight(): TreeNodeEnableIndex<K, V>;
+    _recount(): void;
+}

node_modules/js-sdsl/dist/cjs/container/TreeContainer/Base/TreeNode.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.TreeNodeEnableIndex = exports.TreeNode = void 0;
+
+class TreeNode {
+    constructor(e, t) {
+        this.ee = 1;
+        this.u = undefined;
+        this.l = undefined;
+        this.U = undefined;
+        this.W = undefined;
+        this.tt = undefined;
+        this.u = e;
+        this.l = t;
+    }
+    L() {
+        let e = this;
+        if (e.ee === 1 && e.tt.tt === e) {
+            e = e.W;
+        } else if (e.U) {
+            e = e.U;
+            while (e.W) {
+                e = e.W;
+            }
+        } else {
+            let t = e.tt;
+            while (t.U === e) {
+                e = t;
+                t = e.tt;
+            }
+            e = t;
+        }
+        return e;
+    }
+    B() {
+        let e = this;
+        if (e.W) {
+            e = e.W;
+            while (e.U) {
+                e = e.U;
+            }
+            return e;
+        } else {
+            let t = e.tt;
+            while (t.W === e) {
+                e = t;
+                t = e.tt;
+            }
+            if (e.W !== t) {
+                return t;
+            } else return e;
+        }
+    }
+    te() {
+        const e = this.tt;
+        const t = this.W;
+        const s = t.U;
+        if (e.tt === this) e.tt = t; else if (e.U === this) e.U = t; else e.W = t;
+        t.tt = e;
+        t.U = this;
+        this.tt = t;
+        this.W = s;
+        if (s) s.tt = this;
+        return t;
+    }
+    se() {
+        const e = this.tt;
+        const t = this.U;
+        const s = t.W;
+        if (e.tt === this) e.tt = t; else if (e.U === this) e.U = t; else e.W = t;
+        t.tt = e;
+        t.W = this;
+        this.tt = t;
+        this.U = s;
+        if (s) s.tt = this;
+        return t;
+    }
+}
+
+exports.TreeNode = TreeNode;
+
+class TreeNodeEnableIndex extends TreeNode {
+    constructor() {
+        super(...arguments);
+        this.rt = 1;
+    }
+    te() {
+        const e = super.te();
+        this.ie();
+        e.ie();
+        return e;
+    }
+    se() {
+        const e = super.se();
+        this.ie();
+        e.ie();
+        return e;
+    }
+    ie() {
+        this.rt = 1;
+        if (this.U) {
+            this.rt += this.U.rt;
+        }
+        if (this.W) {
+            this.rt += this.W.rt;
+        }
+    }
+}
+
+exports.TreeNodeEnableIndex = TreeNodeEnableIndex;
+//# sourceMappingURL=TreeNode.js.map

node_modules/js-sdsl/dist/cjs/container/TreeContainer/Base/index.d.ts

@@ -0,0 +1,58 @@
+import type TreeIterator from './TreeIterator';
+import { Container } from "../../ContainerBase";
+declare abstract class TreeContainer<K, V> extends Container<K | [K, V]> {
+    clear(): void;
+    /**
+     * @description Update node's key by iterator.
+     * @param iter - The iterator you want to change.
+     * @param key - The key you want to update.
+     * @returns Whether the modification is successful.
+     * @example
+     * const st = new orderedSet([1, 2, 5]);
+     * const iter = st.find(2);
+     * st.updateKeyByIterator(iter, 3); // then st will become [1, 3, 5]
+     */
+    updateKeyByIterator(iter: TreeIterator<K, V>, key: K): boolean;
+    eraseElementByPos(pos: number): number;
+    /**
+     * @description Remove the element of the specified key.
+     * @param key - The key you want to remove.
+     * @returns Whether erase successfully.
+     */
+    eraseElementByKey(key: K): boolean;
+    eraseElementByIterator(iter: TreeIterator<K, V>): TreeIterator<K, V>;
+    forEach(callback: (element: K | [K, V], index: number, tree: TreeContainer<K, V>) => void): void;
+    getElementByPos(pos: number): K | [K, V];
+    /**
+     * @description Get the height of the tree.
+     * @returns Number about the height of the RB-tree.
+     */
+    getHeight(): number;
+    /**
+     * @param key - The given key you want to compare.
+     * @returns An iterator to the first element less than the given key.
+     */
+    abstract reverseUpperBound(key: K): TreeIterator<K, V>;
+    /**
+     * @description Union the other tree to self.
+     * @param other - The other tree container you want to merge.
+     * @returns The size of the tree after union.
+     */
+    abstract union(other: TreeContainer<K, V>): number;
+    /**
+     * @param key - The given key you want to compare.
+     * @returns An iterator to the first element not greater than the given key.
+     */
+    abstract reverseLowerBound(key: K): TreeIterator<K, V>;
+    /**
+     * @param key - The given key you want to compare.
+     * @returns An iterator to the first element not less than the given key.
+     */
+    abstract lowerBound(key: K): TreeIterator<K, V>;
+    /**
+     * @param key - The given key you want to compare.
+     * @returns An iterator to the first element greater than the given key.
+     */
+    abstract upperBound(key: K): TreeIterator<K, V>;
+}
+export default TreeContainer;

node_modules/js-sdsl/dist/cjs/container/TreeContainer/Base/index.js

@@ -0,0 +1,514 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _TreeNode = require("./TreeNode");
+
+var _ContainerBase = require("../../ContainerBase");
+
+var _throwError = require("../../../utils/throwError");
+
+class TreeContainer extends _ContainerBase.Container {
+    constructor(e = function(e, t) {
+        if (e < t) return -1;
+        if (e > t) return 1;
+        return 0;
+    }, t = false) {
+        super();
+        this.Y = undefined;
+        this.v = e;
+        if (t) {
+            this.re = _TreeNode.TreeNodeEnableIndex;
+            this.M = function(e, t, i) {
+                const s = this.ne(e, t, i);
+                if (s) {
+                    let e = s.tt;
+                    while (e !== this.h) {
+                        e.rt += 1;
+                        e = e.tt;
+                    }
+                    const t = this.he(s);
+                    if (t) {
+                        const {parentNode: e, grandParent: i, curNode: s} = t;
+                        e.ie();
+                        i.ie();
+                        s.ie();
+                    }
+                }
+                return this.i;
+            };
+            this.V = function(e) {
+                let t = this.fe(e);
+                while (t !== this.h) {
+                    t.rt -= 1;
+                    t = t.tt;
+                }
+            };
+        } else {
+            this.re = _TreeNode.TreeNode;
+            this.M = function(e, t, i) {
+                const s = this.ne(e, t, i);
+                if (s) this.he(s);
+                return this.i;
+            };
+            this.V = this.fe;
+        }
+        this.h = new this.re;
+    }
+    X(e, t) {
+        let i = this.h;
+        while (e) {
+            const s = this.v(e.u, t);
+            if (s < 0) {
+                e = e.W;
+            } else if (s > 0) {
+                i = e;
+                e = e.U;
+            } else return e;
+        }
+        return i;
+    }
+    Z(e, t) {
+        let i = this.h;
+        while (e) {
+            const s = this.v(e.u, t);
+            if (s <= 0) {
+                e = e.W;
+            } else {
+                i = e;
+                e = e.U;
+            }
+        }
+        return i;
+    }
+    $(e, t) {
+        let i = this.h;
+        while (e) {
+            const s = this.v(e.u, t);
+            if (s < 0) {
+                i = e;
+                e = e.W;
+            } else if (s > 0) {
+                e = e.U;
+            } else return e;
+        }
+        return i;
+    }
+    rr(e, t) {
+        let i = this.h;
+        while (e) {
+            const s = this.v(e.u, t);
+            if (s < 0) {
+                i = e;
+                e = e.W;
+            } else {
+                e = e.U;
+            }
+        }
+        return i;
+    }
+    ue(e) {
+        while (true) {
+            const t = e.tt;
+            if (t === this.h) return;
+            if (e.ee === 1) {
+                e.ee = 0;
+                return;
+            }
+            if (e === t.U) {
+                const i = t.W;
+                if (i.ee === 1) {
+                    i.ee = 0;
+                    t.ee = 1;
+                    if (t === this.Y) {
+                        this.Y = t.te();
+                    } else t.te();
+                } else {
+                    if (i.W && i.W.ee === 1) {
+                        i.ee = t.ee;
+                        t.ee = 0;
+                        i.W.ee = 0;
+                        if (t === this.Y) {
+                            this.Y = t.te();
+                        } else t.te();
+                        return;
+                    } else if (i.U && i.U.ee === 1) {
+                        i.ee = 1;
+                        i.U.ee = 0;
+                        i.se();
+                    } else {
+                        i.ee = 1;
+                        e = t;
+                    }
+                }
+            } else {
+                const i = t.U;
+                if (i.ee === 1) {
+                    i.ee = 0;
+                    t.ee = 1;
+                    if (t === this.Y) {
+                        this.Y = t.se();
+                    } else t.se();
+                } else {
+                    if (i.U && i.U.ee === 1) {
+                        i.ee = t.ee;
+                        t.ee = 0;
+                        i.U.ee = 0;
+                        if (t === this.Y) {
+                            this.Y = t.se();
+                        } else t.se();
+                        return;
+                    } else if (i.W && i.W.ee === 1) {
+                        i.ee = 1;
+                        i.W.ee = 0;
+                        i.te();
+                    } else {
+                        i.ee = 1;
+                        e = t;
+                    }
+                }
+            }
+        }
+    }
+    fe(e) {
+        if (this.i === 1) {
+            this.clear();
+            return this.h;
+        }
+        let t = e;
+        while (t.U || t.W) {
+            if (t.W) {
+                t = t.W;
+                while (t.U) t = t.U;
+            } else {
+                t = t.U;
+            }
+            [e.u, t.u] = [ t.u, e.u ];
+            [e.l, t.l] = [ t.l, e.l ];
+            e = t;
+        }
+        if (this.h.U === t) {
+            this.h.U = t.tt;
+        } else if (this.h.W === t) {
+            this.h.W = t.tt;
+        }
+        this.ue(t);
+        const i = t.tt;
+        if (t === i.U) {
+            i.U = undefined;
+        } else i.W = undefined;
+        this.i -= 1;
+        this.Y.ee = 0;
+        return i;
+    }
+    oe(e, t) {
+        if (e === undefined) return false;
+        const i = this.oe(e.U, t);
+        if (i) return true;
+        if (t(e)) return true;
+        return this.oe(e.W, t);
+    }
+    he(e) {
+        while (true) {
+            const t = e.tt;
+            if (t.ee === 0) return;
+            const i = t.tt;
+            if (t === i.U) {
+                const s = i.W;
+                if (s && s.ee === 1) {
+                    s.ee = t.ee = 0;
+                    if (i === this.Y) return;
+                    i.ee = 1;
+                    e = i;
+                    continue;
+                } else if (e === t.W) {
+                    e.ee = 0;
+                    if (e.U) e.U.tt = t;
+                    if (e.W) e.W.tt = i;
+                    t.W = e.U;
+                    i.U = e.W;
+                    e.U = t;
+                    e.W = i;
+                    if (i === this.Y) {
+                        this.Y = e;
+                        this.h.tt = e;
+                    } else {
+                        const t = i.tt;
+                        if (t.U === i) {
+                            t.U = e;
+                        } else t.W = e;
+                    }
+                    e.tt = i.tt;
+                    t.tt = e;
+                    i.tt = e;
+                    i.ee = 1;
+                    return {
+                        parentNode: t,
+                        grandParent: i,
+                        curNode: e
+                    };
+                } else {
+                    t.ee = 0;
+                    if (i === this.Y) {
+                        this.Y = i.se();
+                    } else i.se();
+                    i.ee = 1;
+                }
+            } else {
+                const s = i.U;
+                if (s && s.ee === 1) {
+                    s.ee = t.ee = 0;
+                    if (i === this.Y) return;
+                    i.ee = 1;
+                    e = i;
+                    continue;
+                } else if (e === t.U) {
+                    e.ee = 0;
+                    if (e.U) e.U.tt = i;
+                    if (e.W) e.W.tt = t;
+                    i.W = e.U;
+                    t.U = e.W;
+                    e.U = i;
+                    e.W = t;
+                    if (i === this.Y) {
+                        this.Y = e;
+                        this.h.tt = e;
+                    } else {
+                        const t = i.tt;
+                        if (t.U === i) {
+                            t.U = e;
+                        } else t.W = e;
+                    }
+                    e.tt = i.tt;
+                    t.tt = e;
+                    i.tt = e;
+                    i.ee = 1;
+                    return {
+                        parentNode: t,
+                        grandParent: i,
+                        curNode: e
+                    };
+                } else {
+                    t.ee = 0;
+                    if (i === this.Y) {
+                        this.Y = i.te();
+                    } else i.te();
+                    i.ee = 1;
+                }
+            }
+            return;
+        }
+    }
+    ne(e, t, i) {
+        if (this.Y === undefined) {
+            this.i += 1;
+            this.Y = new this.re(e, t);
+            this.Y.ee = 0;
+            this.Y.tt = this.h;
+            this.h.tt = this.Y;
+            this.h.U = this.Y;
+            this.h.W = this.Y;
+            return;
+        }
+        let s;
+        const r = this.h.U;
+        const n = this.v(r.u, e);
+        if (n === 0) {
+            r.l = t;
+            return;
+        } else if (n > 0) {
+            r.U = new this.re(e, t);
+            r.U.tt = r;
+            s = r.U;
+            this.h.U = s;
+        } else {
+            const r = this.h.W;
+            const n = this.v(r.u, e);
+            if (n === 0) {
+                r.l = t;
+                return;
+            } else if (n < 0) {
+                r.W = new this.re(e, t);
+                r.W.tt = r;
+                s = r.W;
+                this.h.W = s;
+            } else {
+                if (i !== undefined) {
+                    const r = i.o;
+                    if (r !== this.h) {
+                        const i = this.v(r.u, e);
+                        if (i === 0) {
+                            r.l = t;
+                            return;
+                        } else if (i > 0) {
+                            const i = r.L();
+                            const n = this.v(i.u, e);
+                            if (n === 0) {
+                                i.l = t;
+                                return;
+                            } else if (n < 0) {
+                                s = new this.re(e, t);
+                                if (i.W === undefined) {
+                                    i.W = s;
+                                    s.tt = i;
+                                } else {
+                                    r.U = s;
+                                    s.tt = r;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (s === undefined) {
+                    s = this.Y;
+                    while (true) {
+                        const i = this.v(s.u, e);
+                        if (i > 0) {
+                            if (s.U === undefined) {
+                                s.U = new this.re(e, t);
+                                s.U.tt = s;
+                                s = s.U;
+                                break;
+                            }
+                            s = s.U;
+                        } else if (i < 0) {
+                            if (s.W === undefined) {
+                                s.W = new this.re(e, t);
+                                s.W.tt = s;
+                                s = s.W;
+                                break;
+                            }
+                            s = s.W;
+                        } else {
+                            s.l = t;
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        this.i += 1;
+        return s;
+    }
+    I(e, t) {
+        while (e) {
+            const i = this.v(e.u, t);
+            if (i < 0) {
+                e = e.W;
+            } else if (i > 0) {
+                e = e.U;
+            } else return e;
+        }
+        return e || this.h;
+    }
+    clear() {
+        this.i = 0;
+        this.Y = undefined;
+        this.h.tt = undefined;
+        this.h.U = this.h.W = undefined;
+    }
+    updateKeyByIterator(e, t) {
+        const i = e.o;
+        if (i === this.h) {
+            (0, _throwError.throwIteratorAccessError)();
+        }
+        if (this.i === 1) {
+            i.u = t;
+            return true;
+        }
+        if (i === this.h.U) {
+            if (this.v(i.B().u, t) > 0) {
+                i.u = t;
+                return true;
+            }
+            return false;
+        }
+        if (i === this.h.W) {
+            if (this.v(i.L().u, t) < 0) {
+                i.u = t;
+                return true;
+            }
+            return false;
+        }
+        const s = i.L().u;
+        if (this.v(s, t) >= 0) return false;
+        const r = i.B().u;
+        if (this.v(r, t) <= 0) return false;
+        i.u = t;
+        return true;
+    }
+    eraseElementByPos(e) {
+        if (e < 0 || e > this.i - 1) {
+            throw new RangeError;
+        }
+        let t = 0;
+        const i = this;
+        this.oe(this.Y, (function(s) {
+            if (e === t) {
+                i.V(s);
+                return true;
+            }
+            t += 1;
+            return false;
+        }));
+        return this.i;
+    }
+    eraseElementByKey(e) {
+        if (this.i === 0) return false;
+        const t = this.I(this.Y, e);
+        if (t === this.h) return false;
+        this.V(t);
+        return true;
+    }
+    eraseElementByIterator(e) {
+        const t = e.o;
+        if (t === this.h) {
+            (0, _throwError.throwIteratorAccessError)();
+        }
+        const i = t.W === undefined;
+        const s = e.iteratorType === 0;
+        if (s) {
+            if (i) e.next();
+        } else {
+            if (!i || t.U === undefined) e.next();
+        }
+        this.V(t);
+        return e;
+    }
+    forEach(e) {
+        let t = 0;
+        for (const i of this) e(i, t++, this);
+    }
+    getElementByPos(e) {
+        if (e < 0 || e > this.i - 1) {
+            throw new RangeError;
+        }
+        let t;
+        let i = 0;
+        for (const s of this) {
+            if (i === e) {
+                t = s;
+                break;
+            }
+            i += 1;
+        }
+        return t;
+    }
+    getHeight() {
+        if (this.i === 0) return 0;
+        const traversal = function(e) {
+            if (!e) return 0;
+            return Math.max(traversal(e.U), traversal(e.W)) + 1;
+        };
+        return traversal(this.Y);
+    }
+}
+
+var _default = TreeContainer;
+
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/js-sdsl/dist/cjs/container/TreeContainer/OrderedMap.d.ts

@@ -0,0 +1,62 @@
+import TreeContainer from './Base';
+import TreeIterator from './Base/TreeIterator';
+import { TreeNode } from './Base/TreeNode';
+import { initContainer, IteratorType } from "../ContainerBase";
+declare class OrderedMapIterator<K, V> extends TreeIterator<K, V> {
+    container: OrderedMap<K, V>;
+    constructor(node: TreeNode<K, V>, header: TreeNode<K, V>, container: OrderedMap<K, V>, iteratorType?: IteratorType);
+    get pointer(): [K, V];
+    copy(): OrderedMapIterator<K, V>;
+    equals(iter: OrderedMapIterator<K, V>): boolean;
+}
+export type { OrderedMapIterator };
+declare class OrderedMap<K, V> extends TreeContainer<K, V> {
+    /**
+     * @param container - The initialization container.
+     * @param cmp - The compare function.
+     * @param enableIndex - Whether to enable iterator indexing function.
+     * @example
+     * new OrderedMap();
+     * new OrderedMap([[0, 1], [2, 1]]);
+     * new OrderedMap([[0, 1], [2, 1]], (x, y) => x - y);
+     * new OrderedMap([[0, 1], [2, 1]], (x, y) => x - y, true);
+     */
+    constructor(container?: initContainer<[K, V]>, cmp?: (x: K, y: K) => number, enableIndex?: boolean);
+    begin(): OrderedMapIterator<K, V>;
+    end(): OrderedMapIterator<K, V>;
+    rBegin(): OrderedMapIterator<K, V>;
+    rEnd(): OrderedMapIterator<K, V>;
+    front(): [K, V] | undefined;
+    back(): [K, V] | undefined;
+    lowerBound(key: K): OrderedMapIterator<K, V>;
+    upperBound(key: K): OrderedMapIterator<K, V>;
+    reverseLowerBound(key: K): OrderedMapIterator<K, V>;
+    reverseUpperBound(key: K): OrderedMapIterator<K, V>;
+    /**
+     * @description Insert a key-value pair or set value by the given key.
+     * @param key - The key want to insert.
+     * @param value - The value want to set.
+     * @param hint - You can give an iterator hint to improve insertion efficiency.
+     * @return The size of container after setting.
+     * @example
+     * const mp = new OrderedMap([[2, 0], [4, 0], [5, 0]]);
+     * const iter = mp.begin();
+     * mp.setElement(1, 0);
+     * mp.setElement(3, 0, iter);  // give a hint will be faster.
+     */
+    setElement(key: K, value: V, hint?: OrderedMapIterator<K, V>): number;
+    find(key: K): OrderedMapIterator<K, V>;
+    /**
+     * @description Get the value of the element of the specified key.
+     * @param key - The specified key you want to get.
+     * @example
+     * const val = container.getElementByKey(1);
+     */
+    getElementByKey(key: K): V | undefined;
+    union(other: OrderedMap<K, V>): number;
+    [Symbol.iterator](): Generator<[K, V], void, unknown>;
+    eraseElementByIterator(iter: OrderedMapIterator<K, V>): OrderedMapIterator<K, V>;
+    forEach(callback: (element: [K, V], index: number, map: OrderedMap<K, V>) => void): void;
+    getElementByPos(pos: number): [K, V];
+}
+export default OrderedMap;

node_modules/js-sdsl/dist/cjs/container/TreeContainer/OrderedMap.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _Base = _interopRequireDefault(require("./Base"));
+
+var _TreeIterator = _interopRequireDefault(require("./Base/TreeIterator"));
+
+var _throwError = require("../../utils/throwError");
+
+function _interopRequireDefault(r) {
+    return r && r.t ? r : {
+        default: r
+    };
+}
+
+class OrderedMapIterator extends _TreeIterator.default {
+    constructor(r, t, e, s) {
+        super(r, t, s);
+        this.container = e;
+    }
+    get pointer() {
+        if (this.o === this.h) {
+            (0, _throwError.throwIteratorAccessError)();
+        }
+        const r = this;
+        return new Proxy([], {
+            get(t, e) {
+                if (e === "0") return r.o.u; else if (e === "1") return r.o.l;
+            },
+            set(t, e, s) {
+                if (e !== "1") {
+                    throw new TypeError("props must be 1");
+                }
+                r.o.l = s;
+                return true;
+            }
+        });
+    }
+    copy() {
+        return new OrderedMapIterator(this.o, this.h, this.container, this.iteratorType);
+    }
+}
+
+class OrderedMap extends _Base.default {
+    constructor(r = [], t, e) {
+        super(t, e);
+        const s = this;
+        r.forEach((function(r) {
+            s.setElement(r[0], r[1]);
+        }));
+    }
+    * K(r) {
+        if (r === undefined) return;
+        yield* this.K(r.U);
+        yield [ r.u, r.l ];
+        yield* this.K(r.W);
+    }
+    begin() {
+        return new OrderedMapIterator(this.h.U || this.h, this.h, this);
+    }
+    end() {
+        return new OrderedMapIterator(this.h, this.h, this);
+    }
+    rBegin() {
+        return new OrderedMapIterator(this.h.W || this.h, this.h, this, 1);
+    }
+    rEnd() {
+        return new OrderedMapIterator(this.h, this.h, this, 1);
+    }
+    front() {
+        if (this.i === 0) return;
+        const r = this.h.U;
+        return [ r.u, r.l ];
+    }
+    back() {
+        if (this.i === 0) return;
+        const r = this.h.W;
+        return [ r.u, r.l ];
+    }
+    lowerBound(r) {
+        const t = this.X(this.Y, r);
+        return new OrderedMapIterator(t, this.h, this);
+    }
+    upperBound(r) {
+        const t = this.Z(this.Y, r);
+        return new OrderedMapIterator(t, this.h, this);
+    }
+    reverseLowerBound(r) {
+        const t = this.$(this.Y, r);
+        return new OrderedMapIterator(t, this.h, this);
+    }
+    reverseUpperBound(r) {
+        const t = this.rr(this.Y, r);
+        return new OrderedMapIterator(t, this.h, this);
+    }
+    setElement(r, t, e) {
+        return this.M(r, t, e);
+    }
+    find(r) {
+        const t = this.I(this.Y, r);
+        return new OrderedMapIterator(t, this.h, this);
+    }
+    getElementByKey(r) {
+        const t = this.I(this.Y, r);
+        return t.l;
+    }
+    union(r) {
+        const t = this;
+        r.forEach((function(r) {
+            t.setElement(r[0], r[1]);
+        }));
+        return this.i;
+    }
+    [Symbol.iterator]() {
+        return this.K(this.Y);
+    }
+}
+
+var _default = OrderedMap;
+
+exports.default = _default;
+//# sourceMappingURL=OrderedMap.js.map

node_modules/js-sdsl/dist/cjs/container/TreeContainer/OrderedSet.d.ts

@@ -0,0 +1,54 @@
+import TreeContainer from './Base';
+import TreeIterator from './Base/TreeIterator';
+import { TreeNode } from './Base/TreeNode';
+import { initContainer, IteratorType } from "../ContainerBase";
+declare class OrderedSetIterator<K> extends TreeIterator<K, undefined> {
+    container: OrderedSet<K>;
+    constructor(node: TreeNode<K, undefined>, header: TreeNode<K, undefined>, container: OrderedSet<K>, iteratorType?: IteratorType);
+    get pointer(): NonNullable<K>;
+    copy(): OrderedSetIterator<K>;
+    equals(iter: OrderedSetIterator<K>): boolean;
+}
+export type { OrderedSetIterator };
+declare class OrderedSet<K> extends TreeContainer<K, undefined> {
+    /**
+     * @param container - The initialization container.
+     * @param cmp - The compare function.
+     * @param enableIndex - Whether to enable iterator indexing function.
+     * @example
+     * new OrderedSet();
+     * new OrderedSet([0, 1, 2]);
+     * new OrderedSet([0, 1, 2], (x, y) => x - y);
+     * new OrderedSet([0, 1, 2], (x, y) => x - y, true);
+     */
+    constructor(container?: initContainer<K>, cmp?: (x: K, y: K) => number, enableIndex?: boolean);
+    begin(): OrderedSetIterator<K>;
+    end(): OrderedSetIterator<K>;
+    rBegin(): OrderedSetIterator<K>;
+    rEnd(): OrderedSetIterator<K>;
+    front(): K | undefined;
+    back(): K | undefined;
+    /**
+     * @description Insert element to set.
+     * @param key - The key want to insert.
+     * @param hint - You can give an iterator hint to improve insertion efficiency.
+     * @return The size of container after setting.
+     * @example
+     * const st = new OrderedSet([2, 4, 5]);
+     * const iter = st.begin();
+     * st.insert(1);
+     * st.insert(3, iter);  // give a hint will be faster.
+     */
+    insert(key: K, hint?: OrderedSetIterator<K>): number;
+    find(element: K): OrderedSetIterator<K>;
+    lowerBound(key: K): OrderedSetIterator<K>;
+    upperBound(key: K): OrderedSetIterator<K>;
+    reverseLowerBound(key: K): OrderedSetIterator<K>;
+    reverseUpperBound(key: K): OrderedSetIterator<K>;
+    union(other: OrderedSet<K>): number;
+    [Symbol.iterator](): Generator<K, void, unknown>;
+    eraseElementByIterator(iter: OrderedSetIterator<K>): OrderedSetIterator<K>;
+    forEach(callback: (element: K, index: number, tree: OrderedSet<K>) => void): void;
+    getElementByPos(pos: number): K;
+}
+export default OrderedSet;

node_modules/js-sdsl/dist/cjs/container/TreeContainer/OrderedSet.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = void 0;
+
+var _Base = _interopRequireDefault(require("./Base"));
+
+var _TreeIterator = _interopRequireDefault(require("./Base/TreeIterator"));
+
+var _throwError = require("../../utils/throwError");
+
+function _interopRequireDefault(e) {
+    return e && e.t ? e : {
+        default: e
+    };
+}
+
+class OrderedSetIterator extends _TreeIterator.default {
+    constructor(e, t, r, i) {
+        super(e, t, i);
+        this.container = r;
+    }
+    get pointer() {
+        if (this.o === this.h) {
+            (0, _throwError.throwIteratorAccessError)();
+        }
+        return this.o.u;
+    }
+    copy() {
+        return new OrderedSetIterator(this.o, this.h, this.container, this.iteratorType);
+    }
+}
+
+class OrderedSet extends _Base.default {
+    constructor(e = [], t, r) {
+        super(t, r);
+        const i = this;
+        e.forEach((function(e) {
+            i.insert(e);
+        }));
+    }
+    * K(e) {
+        if (e === undefined) return;
+        yield* this.K(e.U);
+        yield e.u;
+        yield* this.K(e.W);
+    }
+    begin() {
+        return new OrderedSetIterator(this.h.U || this.h, this.h, this);
+    }
+    end() {
+        return new OrderedSetIterator(this.h, this.h, this);
+    }
+    rBegin() {
+        return new OrderedSetIterator(this.h.W || this.h, this.h, this, 1);
+    }
+    rEnd() {
+        return new OrderedSetIterator(this.h, this.h, this, 1);
+    }
+    front() {
+        return this.h.U ? this.h.U.u : undefined;
+    }
+    back() {
+        return this.h.W ? this.h.W.u : undefined;
+    }
+    insert(e, t) {
+        return this.M(e, undefined, t);
+    }
+    find(e) {
+        const t = this.I(this.Y, e);
+        return new OrderedSetIterator(t, this.h, this);
+    }
+    lowerBound(e) {
+        const t = this.X(this.Y, e);
+        return new OrderedSetIterator(t, this.h, this);
+    }
+    upperBound(e) {
+        const t = this.Z(this.Y, e);
+        return new OrderedSetIterator(t, this.h, this);
+    }
+    reverseLowerBound(e) {
+        const t = this.$(this.Y, e);
+        return new OrderedSetIterator(t, this.h, this);
+    }
+    reverseUpperBound(e) {
+        const t = this.rr(this.Y, e);
+        return new OrderedSetIterator(t, this.h, this);
+    }
+    union(e) {
+        const t = this;
+        e.forEach((function(e) {
+            t.insert(e);
+        }));
+        return this.i;
+    }
+    [Symbol.iterator]() {
+        return this.K(this.Y);
+    }
+}
+
+var _default = OrderedSet;
+
+exports.default = _default;
+//# sourceMappingURL=OrderedSet.js.map

node_modules/js-sdsl/dist/cjs/index.d.ts

@@ -0,0 +1,21 @@
+export { default as Stack } from "./container/OtherContainer/Stack";
+export { default as Queue } from "./container/OtherContainer/Queue";
+export { default as PriorityQueue } from "./container/OtherContainer/PriorityQueue";
+export { default as Vector } from "./container/SequentialContainer/Vector";
+export { default as LinkList } from "./container/SequentialContainer/LinkList";
+export { default as Deque } from "./container/SequentialContainer/Deque";
+export { default as OrderedSet } from "./container/TreeContainer/OrderedSet";
+export { default as OrderedMap } from "./container/TreeContainer/OrderedMap";
+export { default as HashSet } from "./container/HashContainer/HashSet";
+export { default as HashMap } from "./container/HashContainer/HashMap";
+export type { VectorIterator } from "./container/SequentialContainer/Vector";
+export type { LinkListIterator } from "./container/SequentialContainer/LinkList";
+export type { DequeIterator } from "./container/SequentialContainer/Deque";
+export type { OrderedSetIterator } from "./container/TreeContainer/OrderedSet";
+export type { OrderedMapIterator } from "./container/TreeContainer/OrderedMap";
+export type { HashSetIterator } from "./container/HashContainer/HashSet";
+export type { HashMapIterator } from "./container/HashContainer/HashMap";
+export type { IteratorType, Container, ContainerIterator } from "./container/ContainerBase";
+export type { default as SequentialContainer } from "./container/SequentialContainer/Base";
+export type { default as TreeContainer } from "./container/TreeContainer/Base";
+export type { HashContainer } from "./container/HashContainer/Base";

node_modules/js-sdsl/dist/cjs/index.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+Object.defineProperty(exports, "Deque", {
+    enumerable: true,
+    get: function() {
+        return _Deque.default;
+    }
+});
+
+Object.defineProperty(exports, "HashMap", {
+    enumerable: true,
+    get: function() {
+        return _HashMap.default;
+    }
+});
+
+Object.defineProperty(exports, "HashSet", {
+    enumerable: true,
+    get: function() {
+        return _HashSet.default;
+    }
+});
+
+Object.defineProperty(exports, "LinkList", {
+    enumerable: true,
+    get: function() {
+        return _LinkList.default;
+    }
+});
+
+Object.defineProperty(exports, "OrderedMap", {
+    enumerable: true,
+    get: function() {
+        return _OrderedMap.default;
+    }
+});
+
+Object.defineProperty(exports, "OrderedSet", {
+    enumerable: true,
+    get: function() {
+        return _OrderedSet.default;
+    }
+});
+
+Object.defineProperty(exports, "PriorityQueue", {
+    enumerable: true,
+    get: function() {
+        return _PriorityQueue.default;
+    }
+});
+
+Object.defineProperty(exports, "Queue", {
+    enumerable: true,
+    get: function() {
+        return _Queue.default;
+    }
+});
+
+Object.defineProperty(exports, "Stack", {
+    enumerable: true,
+    get: function() {
+        return _Stack.default;
+    }
+});
+
+Object.defineProperty(exports, "Vector", {
+    enumerable: true,
+    get: function() {
+        return _Vector.default;
+    }
+});
+
+var _Stack = _interopRequireDefault(require("./container/OtherContainer/Stack"));
+
+var _Queue = _interopRequireDefault(require("./container/OtherContainer/Queue"));
+
+var _PriorityQueue = _interopRequireDefault(require("./container/OtherContainer/PriorityQueue"));
+
+var _Vector = _interopRequireDefault(require("./container/SequentialContainer/Vector"));
+
+var _LinkList = _interopRequireDefault(require("./container/SequentialContainer/LinkList"));
+
+var _Deque = _interopRequireDefault(require("./container/SequentialContainer/Deque"));
+
+var _OrderedSet = _interopRequireDefault(require("./container/TreeContainer/OrderedSet"));
+
+var _OrderedMap = _interopRequireDefault(require("./container/TreeContainer/OrderedMap"));
+
+var _HashSet = _interopRequireDefault(require("./container/HashContainer/HashSet"));
+
+var _HashMap = _interopRequireDefault(require("./container/HashContainer/HashMap"));
+
+function _interopRequireDefault(e) {
+    return e && e.t ? e : {
+        default: e
+    };
+}
+//# sourceMappingURL=index.js.map

node_modules/js-sdsl/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.js","../../src/index.ts"],"names":["Object","defineProperty","exports","value","enumerable","get","_Deque","default","_HashMap","_HashSet","_LinkList","_OrderedMap","_OrderedSet","_PriorityQueue","_Queue","_Stack","_Vector","_interopRequireDefault","require","obj","__esModule"],"mappings":"AAAA;;AAEAA,OAAOC,eAAeC,SAAS,KAAc;IAC3CC,OAAO;;;AAETH,OAAOC,eAAeC,SAAS,SAAS;IACtCE,YAAY;IACZC,KAAK;QACH,OAAOC,OAAOC;AAChB;;;AAEFP,OAAOC,eAAeC,SAAS,WAAW;IACxCE,YAAY;IACZC,KAAK;QACH,OAAOG,SAASD;AAClB;;;AAEFP,OAAOC,eAAeC,SAAS,WAAW;IACxCE,YAAY;IACZC,KAAK;QACH,OAAOI,SAASF;AAClB;;;AAEFP,OAAOC,eAAeC,SAAS,YAAY;IACzCE,YAAY;IACZC,KAAK;QACH,OAAOK,UAAUH;AACnB;;;AAEFP,OAAOC,eAAeC,SAAS,cAAc;IAC3CE,YAAY;IACZC,KAAK;QACH,OAAOM,YAAYJ;AACrB;;;AAEFP,OAAOC,eAAeC,SAAS,cAAc;IAC3CE,YAAY;IACZC,KAAK;QACH,OAAOO,YAAYL;AACrB;;;AAEFP,OAAOC,eAAeC,SAAS,iBAAiB;IAC9CE,YAAY;IACZC,KAAK;QACH,OAAOQ,eAAeN;AACxB;;;AAEFP,OAAOC,eAAeC,SAAS,SAAS;IACtCE,YAAY;IACZC,KAAK;QACH,OAAOS,OAAOP;AAChB;;;AAEFP,OAAOC,eAAeC,SAAS,SAAS;IACtCE,YAAY;IACZC,KAAK;QACH,OAAOU,OAAOR;AAChB;;;AAEFP,OAAOC,eAAeC,SAAS,UAAU;IACvCE,YAAY;IACZC,KAAK;QACH,OAAOW,QAAQT;AACjB;;;AC/DF,IAAAQ,SAAAE,uBAAAC,QAAA;;AACA,IAAAJ,SAAAG,uBAAAC,QAAA;;AACA,IAAAL,iBAAAI,uBAAAC,QAAA;;AACA,IAAAF,UAAAC,uBAAAC,QAAA;;AACA,IAAAR,YAAAO,uBAAAC,QAAA;;AACA,IAAAZ,SAAAW,uBAAAC,QAAA;;AACA,IAAAN,cAAAK,uBAAAC,QAAA;;AACA,IAAAP,cAAAM,uBAAAC,QAAA;;AACA,IAAAT,WAAAQ,uBAAAC,QAAA;;AACA,IAAAV,WAAAS,uBAAAC,QAAA;;AAAuE,SAAAD,uBAAAE;IAAA,OAAAA,KAAAA,EAAAC,IAAAD,IAAA;QAAAZ,SAAAY;;AAAA","file":"index.js","sourcesContent":[null,"export { default as Stack } from '@/container/OtherContainer/Stack';\nexport { default as Queue } from '@/container/OtherContainer/Queue';\nexport { default as PriorityQueue } from '@/container/OtherContainer/PriorityQueue';\nexport { default as Vector } from '@/container/SequentialContainer/Vector';\nexport { default as LinkList } from '@/container/SequentialContainer/LinkList';\nexport { default as Deque } from '@/container/SequentialContainer/Deque';\nexport { default as OrderedSet } from '@/container/TreeContainer/OrderedSet';\nexport { default as OrderedMap } from '@/container/TreeContainer/OrderedMap';\nexport { default as HashSet } from '@/container/HashContainer/HashSet';\nexport { default as HashMap } from '@/container/HashContainer/HashMap';\nexport type { VectorIterator } from '@/container/SequentialContainer/Vector';\nexport type { LinkListIterator } from '@/container/SequentialContainer/LinkList';\nexport type { DequeIterator } from '@/container/SequentialContainer/Deque';\nexport type { OrderedSetIterator } from '@/container/TreeContainer/OrderedSet';\nexport type { OrderedMapIterator } from '@/container/TreeContainer/OrderedMap';\nexport type { HashSetIterator } from '@/container/HashContainer/HashSet';\nexport type { HashMapIterator } from '@/container/HashContainer/HashMap';\nexport type { IteratorType, Container, ContainerIterator } from '@/container/ContainerBase';\nexport type { default as SequentialContainer } from '@/container/SequentialContainer/Base';\nexport type { default as TreeContainer } from '@/container/TreeContainer/Base';\nexport type { HashContainer } from '@/container/HashContainer/Base';\n"]}

node_modules/js-sdsl/dist/cjs/utils/checkObject.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/js-sdsl/dist/cjs/utils/checkObject.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.default = checkObject;
+
+function checkObject(e) {
+    const t = typeof e;
+    return t === "object" && e !== null || t === "function";
+}
+//# sourceMappingURL=checkObject.js.map

node_modules/js-sdsl/dist/cjs/utils/checkObject.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["utils/checkObject.js","../../src/utils/checkObject.ts"],"names":["Object","defineProperty","exports","value","default","checkObject","key","t"],"mappings":"AAAA;;AAEAA,OAAOC,eAAeC,SAAS,KAAc;IAC3CC,OAAO;;;AAETD,QAAQE,UAAUC;;ACCJ,SAAUA,YAAeC;IACrC,MAAMC,WAAWD;IACjB,OAAQC,MAAM,YAAYD,MAAQ,QAASC,MAAM;ADCnD","file":"checkObject.js","sourcesContent":["/**\n * @description Determine whether the type of key is `object`.\n * @param key - The key want to check.\n * @returns Whether the type of key is `object`.\n * @internal\n */\nexport default function checkObject(key) {\n    const t = typeof key;\n    return (t === 'object' && key !== null) || t === 'function';\n}\n","/**\n * @description Determine whether the type of key is `object`.\n * @param key - The key want to check.\n * @returns Whether the type of key is `object`.\n * @internal\n */\nexport default function checkObject<T>(key: T) {\n  const t = typeof key;\n  return (t === 'object' && key !== null) || t === 'function';\n}\n"]}

node_modules/js-sdsl/dist/cjs/utils/throwError.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/js-sdsl/dist/cjs/utils/throwError.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "t", {
+    value: true
+});
+
+exports.throwIteratorAccessError = throwIteratorAccessError;
+
+function throwIteratorAccessError() {
+    throw new RangeError("Iterator access denied!");
+}
+//# sourceMappingURL=throwError.js.map

node_modules/js-sdsl/dist/cjs/utils/throwError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["utils/throwError.js","../../src/utils/throwError.ts"],"names":["Object","defineProperty","exports","value","throwIteratorAccessError","RangeError"],"mappings":"AAAA;;AAEAA,OAAOC,eAAeC,SAAS,KAAc;IAC3CC,OAAO;;;AAETD,QAAQE,2BAA2BA;;ACD7B,SAAUA;IACd,MAAM,IAAIC,WAAW;ADCvB","file":"throwError.js","sourcesContent":["/**\n * @description Throw an iterator access error.\n * @internal\n */\nexport function throwIteratorAccessError() {\n    throw new RangeError('Iterator access denied!');\n}\n","/**\n * @description Throw an iterator access error.\n * @internal\n */\nexport function throwIteratorAccessError() {\n  throw new RangeError('Iterator access denied!');\n}\n"]}

node_modules/js-sdsl/dist/esm/container/ContainerBase/index.d.ts

@@ -0,0 +1,206 @@
+/**
+ * @description The iterator type including `NORMAL` and `REVERSE`.
+ */
+export declare const enum IteratorType {
+    NORMAL = 0,
+    REVERSE = 1
+}
+export declare abstract class ContainerIterator<T> {
+    /**
+     * @description The container pointed to by the iterator.
+     */
+    abstract readonly container: Container<T>;
+    /**
+     * @description Iterator's type.
+     * @example
+     * console.log(container.end().iteratorType === IteratorType.NORMAL);  // true
+     */
+    readonly iteratorType: IteratorType;
+    /**
+     * @param iter - The other iterator you want to compare.
+     * @returns Whether this equals to obj.
+     * @example
+     * container.find(1).equals(container.end());
+     */
+    equals(iter: ContainerIterator<T>): boolean;
+    /**
+     * @description Pointers to element.
+     * @returns The value of the pointer's element.
+     * @example
+     * const val = container.begin().pointer;
+     */
+    abstract get pointer(): T;
+    /**
+     * @description Set pointer's value (some containers are unavailable).
+     * @param newValue - The new value you want to set.
+     * @example
+     * (<LinkList<number>>container).begin().pointer = 1;
+     */
+    abstract set pointer(newValue: T);
+    /**
+     * @description Move `this` iterator to pre.
+     * @returns The iterator's self.
+     * @example
+     * const iter = container.find(1);  // container = [0, 1]
+     * const pre = iter.pre();
+     * console.log(pre === iter);  // true
+     * console.log(pre.equals(iter));  // true
+     * console.log(pre.pointer, iter.pointer); // 0, 0
+     */
+    abstract pre(): this;
+    /**
+     * @description Move `this` iterator to next.
+     * @returns The iterator's self.
+     * @example
+     * const iter = container.find(1);  // container = [1, 2]
+     * const next = iter.next();
+     * console.log(next === iter);  // true
+     * console.log(next.equals(iter));  // true
+     * console.log(next.pointer, iter.pointer); // 2, 2
+     */
+    abstract next(): this;
+    /**
+     * @description Get a copy of itself.
+     * @returns The copy of self.
+     * @example
+     * const iter = container.find(1);  // container = [1, 2]
+     * const next = iter.copy().next();
+     * console.log(next === iter);  // false
+     * console.log(next.equals(iter));  // false
+     * console.log(next.pointer, iter.pointer); // 2, 1
+     */
+    abstract copy(): ContainerIterator<T>;
+}
+export declare abstract class Base {
+    /**
+     * @returns The size of the container.
+     * @example
+     * const container = new Vector([1, 2]);
+     * console.log(container.length); // 2
+     */
+    get length(): number;
+    /**
+     * @returns The size of the container.
+     * @example
+     * const container = new Vector([1, 2]);
+     * console.log(container.size()); // 2
+     */
+    size(): number;
+    /**
+     * @returns Whether the container is empty.
+     * @example
+     * container.clear();
+     * console.log(container.empty());  // true
+     */
+    empty(): boolean;
+    /**
+     * @description Clear the container.
+     * @example
+     * container.clear();
+     * console.log(container.empty());  // true
+     */
+    abstract clear(): void;
+}
+export declare abstract class Container<T> extends Base {
+    /**
+     * @returns Iterator pointing to the beginning element.
+     * @example
+     * const begin = container.begin();
+     * const end = container.end();
+     * for (const it = begin; !it.equals(end); it.next()) {
+     *   doSomething(it.pointer);
+     * }
+     */
+    abstract begin(): ContainerIterator<T>;
+    /**
+     * @returns Iterator pointing to the super end like c++.
+     * @example
+     * const begin = container.begin();
+     * const end = container.end();
+     * for (const it = begin; !it.equals(end); it.next()) {
+     *   doSomething(it.pointer);
+     * }
+     */
+    abstract end(): ContainerIterator<T>;
+    /**
+     * @returns Iterator pointing to the end element.
+     * @example
+     * const rBegin = container.rBegin();
+     * const rEnd = container.rEnd();
+     * for (const it = rBegin; !it.equals(rEnd); it.next()) {
+     *   doSomething(it.pointer);
+     * }
+     */
+    abstract rBegin(): ContainerIterator<T>;
+    /**
+     * @returns Iterator pointing to the super begin like c++.
+     * @example
+     * const rBegin = container.rBegin();
+     * const rEnd = container.rEnd();
+     * for (const it = rBegin; !it.equals(rEnd); it.next()) {
+     *   doSomething(it.pointer);
+     * }
+     */
+    abstract rEnd(): ContainerIterator<T>;
+    /**
+     * @returns The first element of the container.
+     */
+    abstract front(): T | undefined;
+    /**
+     * @returns The last element of the container.
+     */
+    abstract back(): T | undefined;
+    /**
+     * @param element - The element you want to find.
+     * @returns An iterator pointing to the element if found, or super end if not found.
+     * @example
+     * container.find(1).equals(container.end());
+     */
+    abstract find(element: T): ContainerIterator<T>;
+    /**
+     * @description Iterate over all elements in the container.
+     * @param callback - Callback function like Array.forEach.
+     * @example
+     * container.forEach((element, index) => console.log(element, index));
+     */
+    abstract forEach(callback: (element: T, index: number, container: Container<T>) => void): void;
+    /**
+     * @description Gets the value of the element at the specified position.
+     * @example
+     * const val = container.getElementByPos(-1); // throw a RangeError
+     */
+    abstract getElementByPos(pos: number): T;
+    /**
+     * @description Removes the element at the specified position.
+     * @param pos - The element's position you want to remove.
+     * @returns The container length after erasing.
+     * @example
+     * container.eraseElementByPos(-1); // throw a RangeError
+     */
+    abstract eraseElementByPos(pos: number): number;
+    /**
+     * @description Removes element by iterator and move `iter` to next.
+     * @param iter - The iterator you want to erase.
+     * @returns The next iterator.
+     * @example
+     * container.eraseElementByIterator(container.begin());
+     * container.eraseElementByIterator(container.end()); // throw a RangeError
+     */
+    abstract eraseElementByIterator(iter: ContainerIterator<T>): ContainerIterator<T>;
+    /**
+     * @description Using for `for...of` syntax like Array.
+     * @example
+     * for (const element of container) {
+     *   console.log(element);
+     * }
+     */
+    abstract [Symbol.iterator](): Generator<T, void>;
+}
+/**
+ * @description The initial data type passed in when initializing the container.
+ */
+export declare type initContainer<T> = {
+    size?: number | (() => number);
+    length?: number;
+    forEach: (callback: (el: T) => void) => void;
+};

node_modules/js-sdsl/dist/esm/container/ContainerBase/index.js

@@ -0,0 +1,68 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(n, t) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(n, t) {
+            n.__proto__ = t;
+        } || function(n, t) {
+            for (var r in t) if (Object.prototype.hasOwnProperty.call(t, r)) n[r] = t[r];
+        };
+        return extendStatics(n, t);
+    };
+    return function(n, t) {
+        if (typeof t !== "function" && t !== null) throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+        extendStatics(n, t);
+        function __() {
+            this.constructor = n;
+        }
+        n.prototype = t === null ? Object.create(t) : (__.prototype = t.prototype, new __);
+    };
+}();
+
+var ContainerIterator = function() {
+    function ContainerIterator(n) {
+        if (n === void 0) {
+            n = 0;
+        }
+        this.iteratorType = n;
+    }
+    ContainerIterator.prototype.equals = function(n) {
+        return this.o === n.o;
+    };
+    return ContainerIterator;
+}();
+
+export { ContainerIterator };
+
+var Base = function() {
+    function Base() {
+        this.M = 0;
+    }
+    Object.defineProperty(Base.prototype, "length", {
+        get: function() {
+            return this.M;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Base.prototype.size = function() {
+        return this.M;
+    };
+    Base.prototype.empty = function() {
+        return this.M === 0;
+    };
+    return Base;
+}();
+
+export { Base };
+
+var Container = function(n) {
+    __extends(Container, n);
+    function Container() {
+        return n !== null && n.apply(this, arguments) || this;
+    }
+    return Container;
+}(Base);
+
+export { Container };
+//# sourceMappingURL=index.js.map

node_modules/js-sdsl/dist/esm/container/HashContainer/Base/index.d.ts

@@ -0,0 +1,29 @@
+import { Container, ContainerIterator } from "../../ContainerBase";
+export declare type HashLinkNode<K, V> = {
+    _key: K;
+    _value: V;
+    _pre: HashLinkNode<K, V>;
+    _next: HashLinkNode<K, V>;
+};
+export declare abstract class HashContainerIterator<K, V> extends ContainerIterator<K | [K, V]> {
+    abstract readonly container: HashContainer<K, V>;
+    pre(): this;
+    next(): this;
+}
+export declare abstract class HashContainer<K, V> extends Container<K | [K, V]> {
+    /**
+     * @description Unique symbol used to tag object.
+     */
+    readonly HASH_TAG: symbol;
+    clear(): void;
+    /**
+     * @description Remove the element of the specified key.
+     * @param key - The key you want to remove.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @returns Whether erase successfully.
+     */
+    eraseElementByKey(key: K, isObject?: boolean): boolean;
+    eraseElementByIterator(iter: HashContainerIterator<K, V>): HashContainerIterator<K, V>;
+    eraseElementByPos(pos: number): number;
+}

node_modules/js-sdsl/dist/esm/container/HashContainer/Base/index.js

@@ -0,0 +1,201 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(t, i) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(t, i) {
+            t.__proto__ = i;
+        } || function(t, i) {
+            for (var r in i) if (Object.prototype.hasOwnProperty.call(i, r)) t[r] = i[r];
+        };
+        return extendStatics(t, i);
+    };
+    return function(t, i) {
+        if (typeof i !== "function" && i !== null) throw new TypeError("Class extends value " + String(i) + " is not a constructor or null");
+        extendStatics(t, i);
+        function __() {
+            this.constructor = t;
+        }
+        t.prototype = i === null ? Object.create(i) : (__.prototype = i.prototype, new __);
+    };
+}();
+
+import { Container, ContainerIterator } from "../../ContainerBase";
+
+import checkObject from "../../../utils/checkObject";
+
+import { throwIteratorAccessError } from "../../../utils/throwError";
+
+var HashContainerIterator = function(t) {
+    __extends(HashContainerIterator, t);
+    function HashContainerIterator(i, r, e) {
+        var n = t.call(this, e) || this;
+        n.o = i;
+        n.h = r;
+        if (n.iteratorType === 0) {
+            n.pre = function() {
+                if (this.o.L === this.h) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.L;
+                return this;
+            };
+            n.next = function() {
+                if (this.o === this.h) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.m;
+                return this;
+            };
+        } else {
+            n.pre = function() {
+                if (this.o.m === this.h) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.m;
+                return this;
+            };
+            n.next = function() {
+                if (this.o === this.h) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.L;
+                return this;
+            };
+        }
+        return n;
+    }
+    return HashContainerIterator;
+}(ContainerIterator);
+
+export { HashContainerIterator };
+
+var HashContainer = function(t) {
+    __extends(HashContainer, t);
+    function HashContainer() {
+        var i = t.call(this) || this;
+        i._ = [];
+        i.I = {};
+        i.HASH_TAG = Symbol("@@HASH_TAG");
+        Object.setPrototypeOf(i.I, null);
+        i.h = {};
+        i.h.L = i.h.m = i.H = i.l = i.h;
+        return i;
+    }
+    HashContainer.prototype.G = function(t) {
+        var i = t.L, r = t.m;
+        i.m = r;
+        r.L = i;
+        if (t === this.H) {
+            this.H = r;
+        }
+        if (t === this.l) {
+            this.l = i;
+        }
+        this.M -= 1;
+    };
+    HashContainer.prototype.v = function(t, i, r) {
+        if (r === undefined) r = checkObject(t);
+        var e;
+        if (r) {
+            var n = t[this.HASH_TAG];
+            if (n !== undefined) {
+                this._[n].p = i;
+                return this.M;
+            }
+            Object.defineProperty(t, this.HASH_TAG, {
+                value: this._.length,
+                configurable: true
+            });
+            e = {
+                u: t,
+                p: i,
+                L: this.l,
+                m: this.h
+            };
+            this._.push(e);
+        } else {
+            var s = this.I[t];
+            if (s) {
+                s.p = i;
+                return this.M;
+            }
+            e = {
+                u: t,
+                p: i,
+                L: this.l,
+                m: this.h
+            };
+            this.I[t] = e;
+        }
+        if (this.M === 0) {
+            this.H = e;
+            this.h.m = e;
+        } else {
+            this.l.m = e;
+        }
+        this.l = e;
+        this.h.L = e;
+        return ++this.M;
+    };
+    HashContainer.prototype.g = function(t, i) {
+        if (i === undefined) i = checkObject(t);
+        if (i) {
+            var r = t[this.HASH_TAG];
+            if (r === undefined) return this.h;
+            return this._[r];
+        } else {
+            return this.I[t] || this.h;
+        }
+    };
+    HashContainer.prototype.clear = function() {
+        var t = this.HASH_TAG;
+        this._.forEach((function(i) {
+            delete i.u[t];
+        }));
+        this._ = [];
+        this.I = {};
+        Object.setPrototypeOf(this.I, null);
+        this.M = 0;
+        this.H = this.l = this.h.L = this.h.m = this.h;
+    };
+    HashContainer.prototype.eraseElementByKey = function(t, i) {
+        var r;
+        if (i === undefined) i = checkObject(t);
+        if (i) {
+            var e = t[this.HASH_TAG];
+            if (e === undefined) return false;
+            delete t[this.HASH_TAG];
+            r = this._[e];
+            delete this._[e];
+        } else {
+            r = this.I[t];
+            if (r === undefined) return false;
+            delete this.I[t];
+        }
+        this.G(r);
+        return true;
+    };
+    HashContainer.prototype.eraseElementByIterator = function(t) {
+        var i = t.o;
+        if (i === this.h) {
+            throwIteratorAccessError();
+        }
+        this.G(i);
+        return t.next();
+    };
+    HashContainer.prototype.eraseElementByPos = function(t) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        var i = this.H;
+        while (t--) {
+            i = i.m;
+        }
+        this.G(i);
+        return this.M;
+    };
+    return HashContainer;
+}(Container);
+
+export { HashContainer };
+//# sourceMappingURL=index.js.map

node_modules/js-sdsl/dist/esm/container/HashContainer/HashMap.d.ts

@@ -0,0 +1,49 @@
+import { initContainer, IteratorType } from "../ContainerBase";
+import { HashContainer, HashContainerIterator, HashLinkNode } from "./Base";
+declare class HashMapIterator<K, V> extends HashContainerIterator<K, V> {
+    readonly container: HashMap<K, V>;
+    constructor(node: HashLinkNode<K, V>, header: HashLinkNode<K, V>, container: HashMap<K, V>, iteratorType?: IteratorType);
+    get pointer(): [K, V];
+    copy(): HashMapIterator<K, V>;
+    equals(iter: HashMapIterator<K, V>): boolean;
+}
+export type { HashMapIterator };
+declare class HashMap<K, V> extends HashContainer<K, V> {
+    constructor(container?: initContainer<[K, V]>);
+    begin(): HashMapIterator<K, V>;
+    end(): HashMapIterator<K, V>;
+    rBegin(): HashMapIterator<K, V>;
+    rEnd(): HashMapIterator<K, V>;
+    front(): [K, V] | undefined;
+    back(): [K, V] | undefined;
+    /**
+     * @description Insert a key-value pair or set value by the given key.
+     * @param key - The key want to insert.
+     * @param value - The value want to set.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @returns The size of container after setting.
+     */
+    setElement(key: K, value: V, isObject?: boolean): number;
+    /**
+     * @description Get the value of the element of the specified key.
+     * @param key - The key want to search.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @example
+     * const val = container.getElementByKey(1);
+     */
+    getElementByKey(key: K, isObject?: boolean): V | undefined;
+    getElementByPos(pos: number): [K, V];
+    /**
+     * @description Check key if exist in container.
+     * @param key - The element you want to search.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @returns An iterator pointing to the element if found, or super end if not found.
+     */
+    find(key: K, isObject?: boolean): HashMapIterator<K, V>;
+    forEach(callback: (element: [K, V], index: number, hashMap: HashMap<K, V>) => void): void;
+    [Symbol.iterator](): Generator<[K, V], void, unknown>;
+}
+export default HashMap;

node_modules/js-sdsl/dist/esm/container/HashContainer/HashMap.js

@@ -0,0 +1,248 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(t, r) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(t, r) {
+            t.__proto__ = r;
+        } || function(t, r) {
+            for (var n in r) if (Object.prototype.hasOwnProperty.call(r, n)) t[n] = r[n];
+        };
+        return extendStatics(t, r);
+    };
+    return function(t, r) {
+        if (typeof r !== "function" && r !== null) throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+        extendStatics(t, r);
+        function __() {
+            this.constructor = t;
+        }
+        t.prototype = r === null ? Object.create(r) : (__.prototype = r.prototype, new __);
+    };
+}();
+
+var __generator = this && this.i || function(t, r) {
+    var n = {
+        label: 0,
+        sent: function() {
+            if (a[0] & 1) throw a[1];
+            return a[1];
+        },
+        trys: [],
+        ops: []
+    }, e, i, a, s;
+    return s = {
+        next: verb(0),
+        throw: verb(1),
+        return: verb(2)
+    }, typeof Symbol === "function" && (s[Symbol.iterator] = function() {
+        return this;
+    }), s;
+    function verb(t) {
+        return function(r) {
+            return step([ t, r ]);
+        };
+    }
+    function step(s) {
+        if (e) throw new TypeError("Generator is already executing.");
+        while (n) try {
+            if (e = 1, i && (a = s[0] & 2 ? i["return"] : s[0] ? i["throw"] || ((a = i["return"]) && a.call(i), 
+            0) : i.next) && !(a = a.call(i, s[1])).done) return a;
+            if (i = 0, a) s = [ s[0] & 2, a.value ];
+            switch (s[0]) {
+              case 0:
+              case 1:
+                a = s;
+                break;
+
+              case 4:
+                n.label++;
+                return {
+                    value: s[1],
+                    done: false
+                };
+
+              case 5:
+                n.label++;
+                i = s[1];
+                s = [ 0 ];
+                continue;
+
+              case 7:
+                s = n.ops.pop();
+                n.trys.pop();
+                continue;
+
+              default:
+                if (!(a = n.trys, a = a.length > 0 && a[a.length - 1]) && (s[0] === 6 || s[0] === 2)) {
+                    n = 0;
+                    continue;
+                }
+                if (s[0] === 3 && (!a || s[1] > a[0] && s[1] < a[3])) {
+                    n.label = s[1];
+                    break;
+                }
+                if (s[0] === 6 && n.label < a[1]) {
+                    n.label = a[1];
+                    a = s;
+                    break;
+                }
+                if (a && n.label < a[2]) {
+                    n.label = a[2];
+                    n.ops.push(s);
+                    break;
+                }
+                if (a[2]) n.ops.pop();
+                n.trys.pop();
+                continue;
+            }
+            s = r.call(t, n);
+        } catch (t) {
+            s = [ 6, t ];
+            i = 0;
+        } finally {
+            e = a = 0;
+        }
+        if (s[0] & 5) throw s[1];
+        return {
+            value: s[0] ? s[1] : void 0,
+            done: true
+        };
+    }
+};
+
+import { HashContainer, HashContainerIterator } from "./Base";
+
+import checkObject from "../../utils/checkObject";
+
+import { throwIteratorAccessError } from "../../utils/throwError";
+
+var HashMapIterator = function(t) {
+    __extends(HashMapIterator, t);
+    function HashMapIterator(r, n, e, i) {
+        var a = t.call(this, r, n, i) || this;
+        a.container = e;
+        return a;
+    }
+    Object.defineProperty(HashMapIterator.prototype, "pointer", {
+        get: function() {
+            if (this.o === this.h) {
+                throwIteratorAccessError();
+            }
+            var t = this;
+            return new Proxy([], {
+                get: function(r, n) {
+                    if (n === "0") return t.o.u; else if (n === "1") return t.o.p;
+                },
+                set: function(r, n, e) {
+                    if (n !== "1") {
+                        throw new TypeError("props must be 1");
+                    }
+                    t.o.p = e;
+                    return true;
+                }
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HashMapIterator.prototype.copy = function() {
+        return new HashMapIterator(this.o, this.h, this.container, this.iteratorType);
+    };
+    return HashMapIterator;
+}(HashContainerIterator);
+
+var HashMap = function(t) {
+    __extends(HashMap, t);
+    function HashMap(r) {
+        if (r === void 0) {
+            r = [];
+        }
+        var n = t.call(this) || this;
+        var e = n;
+        r.forEach((function(t) {
+            e.setElement(t[0], t[1]);
+        }));
+        return n;
+    }
+    HashMap.prototype.begin = function() {
+        return new HashMapIterator(this.H, this.h, this);
+    };
+    HashMap.prototype.end = function() {
+        return new HashMapIterator(this.h, this.h, this);
+    };
+    HashMap.prototype.rBegin = function() {
+        return new HashMapIterator(this.l, this.h, this, 1);
+    };
+    HashMap.prototype.rEnd = function() {
+        return new HashMapIterator(this.h, this.h, this, 1);
+    };
+    HashMap.prototype.front = function() {
+        if (this.M === 0) return;
+        return [ this.H.u, this.H.p ];
+    };
+    HashMap.prototype.back = function() {
+        if (this.M === 0) return;
+        return [ this.l.u, this.l.p ];
+    };
+    HashMap.prototype.setElement = function(t, r, n) {
+        return this.v(t, r, n);
+    };
+    HashMap.prototype.getElementByKey = function(t, r) {
+        if (r === undefined) r = checkObject(t);
+        if (r) {
+            var n = t[this.HASH_TAG];
+            return n !== undefined ? this._[n].p : undefined;
+        }
+        var e = this.I[t];
+        return e ? e.p : undefined;
+    };
+    HashMap.prototype.getElementByPos = function(t) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        var r = this.H;
+        while (t--) {
+            r = r.m;
+        }
+        return [ r.u, r.p ];
+    };
+    HashMap.prototype.find = function(t, r) {
+        var n = this.g(t, r);
+        return new HashMapIterator(n, this.h, this);
+    };
+    HashMap.prototype.forEach = function(t) {
+        var r = 0;
+        var n = this.H;
+        while (n !== this.h) {
+            t([ n.u, n.p ], r++, this);
+            n = n.m;
+        }
+    };
+    HashMap.prototype[Symbol.iterator] = function() {
+        return function() {
+            var t;
+            return __generator(this, (function(r) {
+                switch (r.label) {
+                  case 0:
+                    t = this.H;
+                    r.label = 1;
+
+                  case 1:
+                    if (!(t !== this.h)) return [ 3, 3 ];
+                    return [ 4, [ t.u, t.p ] ];
+
+                  case 2:
+                    r.sent();
+                    t = t.m;
+                    return [ 3, 1 ];
+
+                  case 3:
+                    return [ 2 ];
+                }
+            }));
+        }.bind(this)();
+    };
+    return HashMap;
+}(HashContainer);
+
+export default HashMap;
+//# sourceMappingURL=HashMap.js.map

node_modules/js-sdsl/dist/esm/container/HashContainer/HashSet.d.ts

@@ -0,0 +1,39 @@
+import { initContainer, IteratorType } from "../ContainerBase";
+import { HashContainer, HashContainerIterator, HashLinkNode } from "./Base";
+declare class HashSetIterator<K> extends HashContainerIterator<K, undefined> {
+    readonly container: HashSet<K>;
+    constructor(node: HashLinkNode<K, undefined>, header: HashLinkNode<K, undefined>, container: HashSet<K>, iteratorType?: IteratorType);
+    get pointer(): K;
+    copy(): HashSetIterator<K>;
+    equals(iter: HashSetIterator<K>): boolean;
+}
+export type { HashSetIterator };
+declare class HashSet<K> extends HashContainer<K, undefined> {
+    constructor(container?: initContainer<K>);
+    begin(): HashSetIterator<K>;
+    end(): HashSetIterator<K>;
+    rBegin(): HashSetIterator<K>;
+    rEnd(): HashSetIterator<K>;
+    front(): K | undefined;
+    back(): K | undefined;
+    /**
+     * @description Insert element to set.
+     * @param key - The key want to insert.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @returns The size of container after inserting.
+     */
+    insert(key: K, isObject?: boolean): number;
+    getElementByPos(pos: number): K;
+    /**
+     * @description Check key if exist in container.
+     * @param key - The element you want to search.
+     * @param isObject - Tell us if the type of inserted key is `object` to improve efficiency.<br/>
+     *                   If a `undefined` value is passed in, the type will be automatically judged.
+     * @returns An iterator pointing to the element if found, or super end if not found.
+     */
+    find(key: K, isObject?: boolean): HashSetIterator<K>;
+    forEach(callback: (element: K, index: number, container: HashSet<K>) => void): void;
+    [Symbol.iterator](): Generator<K, void, unknown>;
+}
+export default HashSet;

node_modules/js-sdsl/dist/esm/container/HashContainer/HashSet.js

@@ -0,0 +1,223 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(t, r) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(t, r) {
+            t.__proto__ = r;
+        } || function(t, r) {
+            for (var e in r) if (Object.prototype.hasOwnProperty.call(r, e)) t[e] = r[e];
+        };
+        return extendStatics(t, r);
+    };
+    return function(t, r) {
+        if (typeof r !== "function" && r !== null) throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+        extendStatics(t, r);
+        function __() {
+            this.constructor = t;
+        }
+        t.prototype = r === null ? Object.create(r) : (__.prototype = r.prototype, new __);
+    };
+}();
+
+var __generator = this && this.i || function(t, r) {
+    var e = {
+        label: 0,
+        sent: function() {
+            if (s[0] & 1) throw s[1];
+            return s[1];
+        },
+        trys: [],
+        ops: []
+    }, n, i, s, a;
+    return a = {
+        next: verb(0),
+        throw: verb(1),
+        return: verb(2)
+    }, typeof Symbol === "function" && (a[Symbol.iterator] = function() {
+        return this;
+    }), a;
+    function verb(t) {
+        return function(r) {
+            return step([ t, r ]);
+        };
+    }
+    function step(a) {
+        if (n) throw new TypeError("Generator is already executing.");
+        while (e) try {
+            if (n = 1, i && (s = a[0] & 2 ? i["return"] : a[0] ? i["throw"] || ((s = i["return"]) && s.call(i), 
+            0) : i.next) && !(s = s.call(i, a[1])).done) return s;
+            if (i = 0, s) a = [ a[0] & 2, s.value ];
+            switch (a[0]) {
+              case 0:
+              case 1:
+                s = a;
+                break;
+
+              case 4:
+                e.label++;
+                return {
+                    value: a[1],
+                    done: false
+                };
+
+              case 5:
+                e.label++;
+                i = a[1];
+                a = [ 0 ];
+                continue;
+
+              case 7:
+                a = e.ops.pop();
+                e.trys.pop();
+                continue;
+
+              default:
+                if (!(s = e.trys, s = s.length > 0 && s[s.length - 1]) && (a[0] === 6 || a[0] === 2)) {
+                    e = 0;
+                    continue;
+                }
+                if (a[0] === 3 && (!s || a[1] > s[0] && a[1] < s[3])) {
+                    e.label = a[1];
+                    break;
+                }
+                if (a[0] === 6 && e.label < s[1]) {
+                    e.label = s[1];
+                    s = a;
+                    break;
+                }
+                if (s && e.label < s[2]) {
+                    e.label = s[2];
+                    e.ops.push(a);
+                    break;
+                }
+                if (s[2]) e.ops.pop();
+                e.trys.pop();
+                continue;
+            }
+            a = r.call(t, e);
+        } catch (t) {
+            a = [ 6, t ];
+            i = 0;
+        } finally {
+            n = s = 0;
+        }
+        if (a[0] & 5) throw a[1];
+        return {
+            value: a[0] ? a[1] : void 0,
+            done: true
+        };
+    }
+};
+
+import { HashContainer, HashContainerIterator } from "./Base";
+
+import { throwIteratorAccessError } from "../../utils/throwError";
+
+var HashSetIterator = function(t) {
+    __extends(HashSetIterator, t);
+    function HashSetIterator(r, e, n, i) {
+        var s = t.call(this, r, e, i) || this;
+        s.container = n;
+        return s;
+    }
+    Object.defineProperty(HashSetIterator.prototype, "pointer", {
+        get: function() {
+            if (this.o === this.h) {
+                throwIteratorAccessError();
+            }
+            return this.o.u;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HashSetIterator.prototype.copy = function() {
+        return new HashSetIterator(this.o, this.h, this.container, this.iteratorType);
+    };
+    return HashSetIterator;
+}(HashContainerIterator);
+
+var HashSet = function(t) {
+    __extends(HashSet, t);
+    function HashSet(r) {
+        if (r === void 0) {
+            r = [];
+        }
+        var e = t.call(this) || this;
+        var n = e;
+        r.forEach((function(t) {
+            n.insert(t);
+        }));
+        return e;
+    }
+    HashSet.prototype.begin = function() {
+        return new HashSetIterator(this.H, this.h, this);
+    };
+    HashSet.prototype.end = function() {
+        return new HashSetIterator(this.h, this.h, this);
+    };
+    HashSet.prototype.rBegin = function() {
+        return new HashSetIterator(this.l, this.h, this, 1);
+    };
+    HashSet.prototype.rEnd = function() {
+        return new HashSetIterator(this.h, this.h, this, 1);
+    };
+    HashSet.prototype.front = function() {
+        return this.H.u;
+    };
+    HashSet.prototype.back = function() {
+        return this.l.u;
+    };
+    HashSet.prototype.insert = function(t, r) {
+        return this.v(t, undefined, r);
+    };
+    HashSet.prototype.getElementByPos = function(t) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        var r = this.H;
+        while (t--) {
+            r = r.m;
+        }
+        return r.u;
+    };
+    HashSet.prototype.find = function(t, r) {
+        var e = this.g(t, r);
+        return new HashSetIterator(e, this.h, this);
+    };
+    HashSet.prototype.forEach = function(t) {
+        var r = 0;
+        var e = this.H;
+        while (e !== this.h) {
+            t(e.u, r++, this);
+            e = e.m;
+        }
+    };
+    HashSet.prototype[Symbol.iterator] = function() {
+        return function() {
+            var t;
+            return __generator(this, (function(r) {
+                switch (r.label) {
+                  case 0:
+                    t = this.H;
+                    r.label = 1;
+
+                  case 1:
+                    if (!(t !== this.h)) return [ 3, 3 ];
+                    return [ 4, t.u ];
+
+                  case 2:
+                    r.sent();
+                    t = t.m;
+                    return [ 3, 1 ];
+
+                  case 3:
+                    return [ 2 ];
+                }
+            }));
+        }.bind(this)();
+    };
+    return HashSet;
+}(HashContainer);
+
+export default HashSet;
+//# sourceMappingURL=HashSet.js.map

node_modules/js-sdsl/dist/esm/container/OtherContainer/PriorityQueue.d.ts

@@ -0,0 +1,79 @@
+import { Base, initContainer } from "../ContainerBase";
+declare class PriorityQueue<T> extends Base {
+    /**
+     * @description PriorityQueue's constructor.
+     * @param container - Initialize container, must have a forEach function.
+     * @param cmp - Compare function.
+     * @param copy - When the container is an array, you can choose to directly operate on the original object of
+     *               the array or perform a shallow copy. The default is shallow copy.
+     * @example
+     * new PriorityQueue();
+     * new PriorityQueue([1, 2, 3]);
+     * new PriorityQueue([1, 2, 3], (x, y) => x - y);
+     * new PriorityQueue([1, 2, 3], (x, y) => x - y, false);
+     */
+    constructor(container?: initContainer<T>, cmp?: (x: T, y: T) => number, copy?: boolean);
+    clear(): void;
+    /**
+     * @description Push element into a container in order.
+     * @param item - The element you want to push.
+     * @returns The size of heap after pushing.
+     * @example
+     * queue.push(1);
+     */
+    push(item: T): void;
+    /**
+     * @description Removes the top element.
+     * @returns The element you popped.
+     * @example
+     * queue.pop();
+     */
+    pop(): T | undefined;
+    /**
+     * @description Accesses the top element.
+     * @example
+     * const top = queue.top();
+     */
+    top(): T | undefined;
+    /**
+     * @description Check if element is in heap.
+     * @param item - The item want to find.
+     * @returns Whether element is in heap.
+     * @example
+     * const que = new PriorityQueue([], (x, y) => x.id - y.id);
+     * const obj = { id: 1 };
+     * que.push(obj);
+     * console.log(que.find(obj));  // true
+     */
+    find(item: T): boolean;
+    /**
+     * @description Remove specified item from heap.
+     * @param item - The item want to remove.
+     * @returns Whether remove success.
+     * @example
+     * const que = new PriorityQueue([], (x, y) => x.id - y.id);
+     * const obj = { id: 1 };
+     * que.push(obj);
+     * que.remove(obj);
+     */
+    remove(item: T): boolean;
+    /**
+     * @description Update item and it's pos in the heap.
+     * @param item - The item want to update.
+     * @returns Whether update success.
+     * @example
+     * const que = new PriorityQueue([], (x, y) => x.id - y.id);
+     * const obj = { id: 1 };
+     * que.push(obj);
+     * obj.id = 2;
+     * que.updateItem(obj);
+     */
+    updateItem(item: T): boolean;
+    /**
+     * @returns Return a copy array of heap.
+     * @example
+     * const arr = queue.toArray();
+     */
+    toArray(): T[];
+}
+export default PriorityQueue;

node_modules/js-sdsl/dist/esm/container/OtherContainer/PriorityQueue.js

@@ -0,0 +1,171 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(i, r) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(i, r) {
+            i.__proto__ = r;
+        } || function(i, r) {
+            for (var t in r) if (Object.prototype.hasOwnProperty.call(r, t)) i[t] = r[t];
+        };
+        return extendStatics(i, r);
+    };
+    return function(i, r) {
+        if (typeof r !== "function" && r !== null) throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+        extendStatics(i, r);
+        function __() {
+            this.constructor = i;
+        }
+        i.prototype = r === null ? Object.create(r) : (__.prototype = r.prototype, new __);
+    };
+}();
+
+var __read = this && this.q || function(i, r) {
+    var t = typeof Symbol === "function" && i[Symbol.iterator];
+    if (!t) return i;
+    var e = t.call(i), n, u = [], s;
+    try {
+        while ((r === void 0 || r-- > 0) && !(n = e.next()).done) u.push(n.value);
+    } catch (i) {
+        s = {
+            error: i
+        };
+    } finally {
+        try {
+            if (n && !n.done && (t = e["return"])) t.call(e);
+        } finally {
+            if (s) throw s.error;
+        }
+    }
+    return u;
+};
+
+var __spreadArray = this && this.D || function(i, r, t) {
+    if (t || arguments.length === 2) for (var e = 0, n = r.length, u; e < n; e++) {
+        if (u || !(e in r)) {
+            if (!u) u = Array.prototype.slice.call(r, 0, e);
+            u[e] = r[e];
+        }
+    }
+    return i.concat(u || Array.prototype.slice.call(r));
+};
+
+import { Base } from "../ContainerBase";
+
+var PriorityQueue = function(i) {
+    __extends(PriorityQueue, i);
+    function PriorityQueue(r, t, e) {
+        if (r === void 0) {
+            r = [];
+        }
+        if (t === void 0) {
+            t = function(i, r) {
+                if (i > r) return -1;
+                if (i < r) return 1;
+                return 0;
+            };
+        }
+        if (e === void 0) {
+            e = true;
+        }
+        var n = i.call(this) || this;
+        n.$ = t;
+        if (Array.isArray(r)) {
+            n.ii = e ? __spreadArray([], __read(r), false) : r;
+        } else {
+            n.ii = [];
+            var u = n;
+            r.forEach((function(i) {
+                u.ii.push(i);
+            }));
+        }
+        n.M = n.ii.length;
+        var s = n.M >> 1;
+        for (var o = n.M - 1 >> 1; o >= 0; --o) {
+            n.ri(o, s);
+        }
+        return n;
+    }
+    PriorityQueue.prototype.ti = function(i) {
+        var r = this.ii[i];
+        while (i > 0) {
+            var t = i - 1 >> 1;
+            var e = this.ii[t];
+            if (this.$(e, r) <= 0) break;
+            this.ii[i] = e;
+            i = t;
+        }
+        this.ii[i] = r;
+    };
+    PriorityQueue.prototype.ri = function(i, r) {
+        var t = this.ii[i];
+        while (i < r) {
+            var e = i << 1 | 1;
+            var n = e + 1;
+            var u = this.ii[e];
+            if (n < this.M && this.$(u, this.ii[n]) > 0) {
+                e = n;
+                u = this.ii[n];
+            }
+            if (this.$(u, t) >= 0) break;
+            this.ii[i] = u;
+            i = e;
+        }
+        this.ii[i] = t;
+    };
+    PriorityQueue.prototype.clear = function() {
+        this.M = 0;
+        this.ii.length = 0;
+    };
+    PriorityQueue.prototype.push = function(i) {
+        this.ii.push(i);
+        this.ti(this.M);
+        this.M += 1;
+    };
+    PriorityQueue.prototype.pop = function() {
+        if (this.M === 0) return;
+        var i = this.ii[0];
+        var r = this.ii.pop();
+        this.M -= 1;
+        if (this.M) {
+            this.ii[0] = r;
+            this.ri(0, this.M >> 1);
+        }
+        return i;
+    };
+    PriorityQueue.prototype.top = function() {
+        return this.ii[0];
+    };
+    PriorityQueue.prototype.find = function(i) {
+        return this.ii.indexOf(i) >= 0;
+    };
+    PriorityQueue.prototype.remove = function(i) {
+        var r = this.ii.indexOf(i);
+        if (r < 0) return false;
+        if (r === 0) {
+            this.pop();
+        } else if (r === this.M - 1) {
+            this.ii.pop();
+            this.M -= 1;
+        } else {
+            this.ii.splice(r, 1, this.ii.pop());
+            this.M -= 1;
+            this.ti(r);
+            this.ri(r, this.M >> 1);
+        }
+        return true;
+    };
+    PriorityQueue.prototype.updateItem = function(i) {
+        var r = this.ii.indexOf(i);
+        if (r < 0) return false;
+        this.ti(r);
+        this.ri(r, this.M >> 1);
+        return true;
+    };
+    PriorityQueue.prototype.toArray = function() {
+        return __spreadArray([], __read(this.ii), false);
+    };
+    return PriorityQueue;
+}(Base);
+
+export default PriorityQueue;
+//# sourceMappingURL=PriorityQueue.js.map

node_modules/js-sdsl/dist/esm/container/OtherContainer/Queue.d.ts

@@ -0,0 +1,22 @@
+import { Base, initContainer } from "../ContainerBase";
+declare class Queue<T> extends Base {
+    constructor(container?: initContainer<T>);
+    clear(): void;
+    /**
+     * @description Inserts element to queue's end.
+     * @param element - The element you want to push to the front.
+     * @returns The container length after pushing.
+     */
+    push(element: T): number;
+    /**
+     * @description Removes the first element.
+     * @returns The element you popped.
+     */
+    pop(): T | undefined;
+    /**
+     * @description Access the first element.
+     * @returns The first element.
+     */
+    front(): T | undefined;
+}
+export default Queue;

node_modules/js-sdsl/dist/esm/container/OtherContainer/Queue.js

@@ -0,0 +1,69 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(t, i) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(t, i) {
+            t.__proto__ = i;
+        } || function(t, i) {
+            for (var n in i) if (Object.prototype.hasOwnProperty.call(i, n)) t[n] = i[n];
+        };
+        return extendStatics(t, i);
+    };
+    return function(t, i) {
+        if (typeof i !== "function" && i !== null) throw new TypeError("Class extends value " + String(i) + " is not a constructor or null");
+        extendStatics(t, i);
+        function __() {
+            this.constructor = t;
+        }
+        t.prototype = i === null ? Object.create(i) : (__.prototype = i.prototype, new __);
+    };
+}();
+
+import { Base } from "../ContainerBase";
+
+var Queue = function(t) {
+    __extends(Queue, t);
+    function Queue(i) {
+        if (i === void 0) {
+            i = [];
+        }
+        var n = t.call(this) || this;
+        n.A = 0;
+        n.tt = [];
+        var e = n;
+        i.forEach((function(t) {
+            e.push(t);
+        }));
+        return n;
+    }
+    Queue.prototype.clear = function() {
+        this.tt = [];
+        this.M = this.A = 0;
+    };
+    Queue.prototype.push = function(t) {
+        var i = this.tt.length;
+        if (this.A / i > .5 && this.A + this.M >= i && i > 4096) {
+            var n = this.M;
+            for (var e = 0; e < n; ++e) {
+                this.tt[e] = this.tt[this.A + e];
+            }
+            this.A = 0;
+            this.tt[this.M] = t;
+        } else this.tt[this.A + this.M] = t;
+        return ++this.M;
+    };
+    Queue.prototype.pop = function() {
+        if (this.M === 0) return;
+        var t = this.tt[this.A++];
+        this.M -= 1;
+        return t;
+    };
+    Queue.prototype.front = function() {
+        if (this.M === 0) return;
+        return this.tt[this.A];
+    };
+    return Queue;
+}(Base);
+
+export default Queue;
+//# sourceMappingURL=Queue.js.map

node_modules/js-sdsl/dist/esm/container/OtherContainer/Stack.d.ts

@@ -0,0 +1,22 @@
+import { Base, initContainer } from "../ContainerBase";
+declare class Stack<T> extends Base {
+    constructor(container?: initContainer<T>);
+    clear(): void;
+    /**
+     * @description Insert element to stack's end.
+     * @description The element you want to push to the back.
+     * @returns The container length after erasing.
+     */
+    push(element: T): number;
+    /**
+     * @description Removes the end element.
+     * @returns The element you popped.
+     */
+    pop(): T | undefined;
+    /**
+     * @description Accesses the end element.
+     * @returns The last element.
+     */
+    top(): T | undefined;
+}
+export default Stack;

node_modules/js-sdsl/dist/esm/container/OtherContainer/Stack.js

@@ -0,0 +1,59 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(t, n) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(t, n) {
+            t.__proto__ = n;
+        } || function(t, n) {
+            for (var i in n) if (Object.prototype.hasOwnProperty.call(n, i)) t[i] = n[i];
+        };
+        return extendStatics(t, n);
+    };
+    return function(t, n) {
+        if (typeof n !== "function" && n !== null) throw new TypeError("Class extends value " + String(n) + " is not a constructor or null");
+        extendStatics(t, n);
+        function __() {
+            this.constructor = t;
+        }
+        t.prototype = n === null ? Object.create(n) : (__.prototype = n.prototype, new __);
+    };
+}();
+
+import { Base } from "../ContainerBase";
+
+var Stack = function(t) {
+    __extends(Stack, t);
+    function Stack(n) {
+        if (n === void 0) {
+            n = [];
+        }
+        var i = t.call(this) || this;
+        i.nt = [];
+        var r = i;
+        n.forEach((function(t) {
+            r.push(t);
+        }));
+        return i;
+    }
+    Stack.prototype.clear = function() {
+        this.M = 0;
+        this.nt = [];
+    };
+    Stack.prototype.push = function(t) {
+        this.nt.push(t);
+        this.M += 1;
+        return this.M;
+    };
+    Stack.prototype.pop = function() {
+        if (this.M === 0) return;
+        this.M -= 1;
+        return this.nt.pop();
+    };
+    Stack.prototype.top = function() {
+        return this.nt[this.M - 1];
+    };
+    return Stack;
+}(Base);
+
+export default Stack;
+//# sourceMappingURL=Stack.js.map

node_modules/js-sdsl/dist/esm/container/OtherContainer/Stack.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["container/OtherContainer/Stack.js","../../src/container/OtherContainer/Stack.ts"],"names":["__extends","this","extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","TypeError","String","__","constructor","create","Base","Stack","_super","container","_this","_stack","self","forEach","el","push","clear","_length","element","pop","top"],"mappings":"AAAA,IAAIA,YAAaC,QAAQA,KAAKD,KAAe;IACzC,IAAIE,gBAAgB,SAAUC,GAAGC;QAC7BF,gBAAgBG,OAAOC,kBAClB;YAAEC,WAAW;qBAAgBC,SAAS,SAAUL,GAAGC;YAAKD,EAAEI,YAAYH;AAAG,aAC1E,SAAUD,GAAGC;YAAK,KAAK,IAAIK,KAAKL,GAAG,IAAIC,OAAOK,UAAUC,eAAeC,KAAKR,GAAGK,IAAIN,EAAEM,KAAKL,EAAEK;AAAI;QACpG,OAAOP,cAAcC,GAAGC;AAC5B;IACA,OAAO,SAAUD,GAAGC;QAChB,WAAWA,MAAM,cAAcA,MAAM,MACjC,MAAM,IAAIS,UAAU,yBAAyBC,OAAOV,KAAK;QAC7DF,cAAcC,GAAGC;QACjB,SAASW;YAAOd,KAAKe,cAAcb;AAAG;QACtCA,EAAEO,YAAYN,MAAM,OAAOC,OAAOY,OAAOb,MAAMW,GAAGL,YAAYN,EAAEM,WAAW,IAAIK;AACnF;AACJ,CAd6C;;SCApCG,YAAqB;;AAE9B,IAAAC,QAAA,SAAAC;IAAuBpB,UAAAmB,OAAAC;IAKrB,SAAAD,MAAYE;QAAA,IAAAA,WAAA,GAAA;YAAAA,IAAA;AAAgC;QAA5C,IAAAC,IACEF,EAAAR,KAAAX,SAAOA;QAFDqB,EAAAC,KAAc;QAGpB,IAAMC,IAAOF;QACbD,EAAUI,SAAQ,SAAUC;YAC1BF,EAAKG,KAAKD;ADiBR;QACA,OAAOJ;AACX;IChBFH,MAAAT,UAAAkB,QAAA;QACE3B,KAAK4B,IAAU;QACf5B,KAAKsB,KAAS;ADkBd;ICXFJ,MAAAT,UAAAiB,OAAA,SAAKG;QACH7B,KAAKsB,GAAOI,KAAKG;QACjB7B,KAAK4B,KAAW;QAChB,OAAO5B,KAAK4B;ADkBZ;ICZFV,MAAAT,UAAAqB,MAAA;QACE,IAAI9B,KAAK4B,MAAY,GAAG;QACxB5B,KAAK4B,KAAW;QAChB,OAAO5B,KAAKsB,GAAOQ;ADmBnB;ICbFZ,MAAAT,UAAAsB,MAAA;QACE,OAAO/B,KAAKsB,GAAOtB,KAAK4B,IAAU;ADmBlC;ICjBJ,OAAAV;AAAA,CA1CA,CAAuBD;;eA4CRC","file":"Stack.js","sourcesContent":["var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { Base } from \"../ContainerBase\";\nvar Stack = /** @class */ (function (_super) {\n    __extends(Stack, _super);\n    function Stack(container) {\n        if (container === void 0) { container = []; }\n        var _this = _super.call(this) || this;\n        /**\n         * @internal\n         */\n        _this._stack = [];\n        var self = _this;\n        container.forEach(function (el) {\n            self.push(el);\n        });\n        return _this;\n    }\n    Stack.prototype.clear = function () {\n        this._length = 0;\n        this._stack = [];\n    };\n    /**\n     * @description Insert element to stack's end.\n     * @description The element you want to push to the back.\n     * @returns The container length after erasing.\n     */\n    Stack.prototype.push = function (element) {\n        this._stack.push(element);\n        this._length += 1;\n        return this._length;\n    };\n    /**\n     * @description Removes the end element.\n     * @returns The element you popped.\n     */\n    Stack.prototype.pop = function () {\n        if (this._length === 0)\n            return;\n        this._length -= 1;\n        return this._stack.pop();\n    };\n    /**\n     * @description Accesses the end element.\n     * @returns The last element.\n     */\n    Stack.prototype.top = function () {\n        return this._stack[this._length - 1];\n    };\n    return Stack;\n}(Base));\nexport default Stack;\n","import { Base, initContainer } from '@/container/ContainerBase';\n\nclass Stack<T> extends Base {\n  /**\n   * @internal\n   */\n  private _stack: T[] = [];\n  constructor(container: initContainer<T> = []) {\n    super();\n    const self = this;\n    container.forEach(function (el) {\n      self.push(el);\n    });\n  }\n  clear() {\n    this._length = 0;\n    this._stack = [];\n  }\n  /**\n   * @description Insert element to stack's end.\n   * @description The element you want to push to the back.\n   * @returns The container length after erasing.\n   */\n  push(element: T) {\n    this._stack.push(element);\n    this._length += 1;\n    return this._length;\n  }\n  /**\n   * @description Removes the end element.\n   * @returns The element you popped.\n   */\n  pop() {\n    if (this._length === 0) return;\n    this._length -= 1;\n    return this._stack.pop();\n  }\n  /**\n   * @description Accesses the end element.\n   * @returns The last element.\n   */\n  top(): T | undefined {\n    return this._stack[this._length - 1];\n  }\n}\n\nexport default Stack;\n"]}

node_modules/js-sdsl/dist/esm/container/SequentialContainer/Base/RandomIterator.d.ts

@@ -0,0 +1,9 @@
+import { ContainerIterator } from "../../ContainerBase";
+import SequentialContainer from "./index";
+export declare abstract class RandomIterator<T> extends ContainerIterator<T> {
+    abstract readonly container: SequentialContainer<T>;
+    get pointer(): T;
+    set pointer(newValue: T);
+    pre(): this;
+    next(): this;
+}

node_modules/js-sdsl/dist/esm/container/SequentialContainer/Base/RandomIterator.js

@@ -0,0 +1,78 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(t, r) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(t, r) {
+            t.__proto__ = r;
+        } || function(t, r) {
+            for (var n in r) if (Object.prototype.hasOwnProperty.call(r, n)) t[n] = r[n];
+        };
+        return extendStatics(t, r);
+    };
+    return function(t, r) {
+        if (typeof r !== "function" && r !== null) throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+        extendStatics(t, r);
+        function __() {
+            this.constructor = t;
+        }
+        t.prototype = r === null ? Object.create(r) : (__.prototype = r.prototype, new __);
+    };
+}();
+
+import { ContainerIterator } from "../../ContainerBase";
+
+import { throwIteratorAccessError } from "../../../utils/throwError";
+
+var RandomIterator = function(t) {
+    __extends(RandomIterator, t);
+    function RandomIterator(r, n) {
+        var o = t.call(this, n) || this;
+        o.o = r;
+        if (o.iteratorType === 0) {
+            o.pre = function() {
+                if (this.o === 0) {
+                    throwIteratorAccessError();
+                }
+                this.o -= 1;
+                return this;
+            };
+            o.next = function() {
+                if (this.o === this.container.size()) {
+                    throwIteratorAccessError();
+                }
+                this.o += 1;
+                return this;
+            };
+        } else {
+            o.pre = function() {
+                if (this.o === this.container.size() - 1) {
+                    throwIteratorAccessError();
+                }
+                this.o += 1;
+                return this;
+            };
+            o.next = function() {
+                if (this.o === -1) {
+                    throwIteratorAccessError();
+                }
+                this.o -= 1;
+                return this;
+            };
+        }
+        return o;
+    }
+    Object.defineProperty(RandomIterator.prototype, "pointer", {
+        get: function() {
+            return this.container.getElementByPos(this.o);
+        },
+        set: function(t) {
+            this.container.setElementByPos(this.o, t);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RandomIterator;
+}(ContainerIterator);
+
+export { RandomIterator };
+//# sourceMappingURL=RandomIterator.js.map

node_modules/js-sdsl/dist/esm/container/SequentialContainer/Base/index.d.ts

@@ -0,0 +1,67 @@
+import { Container } from "../../ContainerBase";
+declare abstract class SequentialContainer<T> extends Container<T> {
+    /**
+     * @description Push the element to the back.
+     * @param element - The element you want to push.
+     * @returns The size of container after pushing.
+     */
+    abstract pushBack(element: T): number;
+    /**
+     * @description Removes the last element.
+     * @returns The element you popped.
+     */
+    abstract popBack(): T | undefined;
+    /**
+     * @description Sets element by position.
+     * @param pos - The position you want to change.
+     * @param element - The element's value you want to update.
+     * @example
+     * container.setElementByPos(-1, 1); // throw a RangeError
+     */
+    abstract setElementByPos(pos: number, element: T): void;
+    /**
+     * @description Removes the elements of the specified value.
+     * @param value - The value you want to remove.
+     * @returns The size of container after erasing.
+     * @example
+     * container.eraseElementByValue(-1);
+     */
+    abstract eraseElementByValue(value: T): number;
+    /**
+     * @description Insert several elements after the specified position.
+     * @param pos - The position you want to insert.
+     * @param element - The element you want to insert.
+     * @param num - The number of elements you want to insert (default 1).
+     * @returns The size of container after inserting.
+     * @example
+     * const container = new Vector([1, 2, 3]);
+     * container.insert(1, 4);  // [1, 4, 2, 3]
+     * container.insert(1, 5, 3); // [1, 5, 5, 5, 4, 2, 3]
+     */
+    abstract insert(pos: number, element: T, num?: number): number;
+    /**
+     * @description Reverses the container.
+     * @example
+     * const container = new Vector([1, 2, 3]);
+     * container.reverse(); // [3, 2, 1]
+     */
+    abstract reverse(): void;
+    /**
+     * @description Removes the duplication of elements in the container.
+     * @returns The size of container after inserting.
+     * @example
+     * const container = new Vector([1, 1, 3, 2, 2, 5, 5, 2]);
+     * container.unique(); // [1, 3, 2, 5, 2]
+     */
+    abstract unique(): number;
+    /**
+     * @description Sort the container.
+     * @param cmp - Comparison function to sort.
+     * @example
+     * const container = new Vector([3, 1, 10]);
+     * container.sort();  // [1, 10, 3]
+     * container.sort((x, y) => x - y); // [1, 3, 10]
+     */
+    abstract sort(cmp?: (x: T, y: T) => number): void;
+}
+export default SequentialContainer;

node_modules/js-sdsl/dist/esm/container/SequentialContainer/Base/index.js

@@ -0,0 +1,33 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(n, t) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(n, t) {
+            n.__proto__ = t;
+        } || function(n, t) {
+            for (var e in t) if (Object.prototype.hasOwnProperty.call(t, e)) n[e] = t[e];
+        };
+        return extendStatics(n, t);
+    };
+    return function(n, t) {
+        if (typeof t !== "function" && t !== null) throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+        extendStatics(n, t);
+        function __() {
+            this.constructor = n;
+        }
+        n.prototype = t === null ? Object.create(t) : (__.prototype = t.prototype, new __);
+    };
+}();
+
+import { Container } from "../../ContainerBase";
+
+var SequentialContainer = function(n) {
+    __extends(SequentialContainer, n);
+    function SequentialContainer() {
+        return n !== null && n.apply(this, arguments) || this;
+    }
+    return SequentialContainer;
+}(Container);
+
+export default SequentialContainer;
+//# sourceMappingURL=index.js.map

node_modules/js-sdsl/dist/esm/container/SequentialContainer/Base/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["container/SequentialContainer/Base/index.js","../../src/container/SequentialContainer/Base/index.ts"],"names":["__extends","this","extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","TypeError","String","__","constructor","create","Container","SequentialContainer","_super","apply","arguments"],"mappings":"AAAA,IAAIA,YAAaC,QAAQA,KAAKD,KAAe;IACzC,IAAIE,gBAAgB,SAAUC,GAAGC;QAC7BF,gBAAgBG,OAAOC,kBAClB;YAAEC,WAAW;qBAAgBC,SAAS,SAAUL,GAAGC;YAAKD,EAAEI,YAAYH;AAAG,aAC1E,SAAUD,GAAGC;YAAK,KAAK,IAAIK,KAAKL,GAAG,IAAIC,OAAOK,UAAUC,eAAeC,KAAKR,GAAGK,IAAIN,EAAEM,KAAKL,EAAEK;AAAI;QACpG,OAAOP,cAAcC,GAAGC;AAC5B;IACA,OAAO,SAAUD,GAAGC;QAChB,WAAWA,MAAM,cAAcA,MAAM,MACjC,MAAM,IAAIS,UAAU,yBAAyBC,OAAOV,KAAK;QAC7DF,cAAcC,GAAGC;QACjB,SAASW;YAAOd,KAAKe,cAAcb;AAAG;QACtCA,EAAEO,YAAYN,MAAM,OAAOC,OAAOY,OAAOb,MAAMW,GAAGL,YAAYN,EAAEM,WAAW,IAAIK;AACnF;AACJ,CAd6C;;SCApCG,iBAAW;;AAEpB,IAAAC,sBAAA,SAAAC;IAA8CpB,UAAAmB,qBAAAC;IAA9C,SAAAD;QDiBQ,OAAOC,MAAW,QAAQA,EAAOC,MAAMpB,MAAMqB,cAAcrB;AC+CnE;IAAA,OAAAkB;AAAA,CAhEA,CAA8CD;;eAkE/BC","file":"index.js","sourcesContent":["var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { Container } from \"../../ContainerBase\";\nvar SequentialContainer = /** @class */ (function (_super) {\n    __extends(SequentialContainer, _super);\n    function SequentialContainer() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return SequentialContainer;\n}(Container));\nexport default SequentialContainer;\n","import { Container } from '@/container/ContainerBase';\n\nabstract class SequentialContainer<T> extends Container<T> {\n  /**\n   * @description Push the element to the back.\n   * @param element - The element you want to push.\n   * @returns The size of container after pushing.\n   */\n  abstract pushBack(element: T): number;\n  /**\n   * @description Removes the last element.\n   * @returns The element you popped.\n   */\n  abstract popBack(): T | undefined;\n  /**\n   * @description Sets element by position.\n   * @param pos - The position you want to change.\n   * @param element - The element's value you want to update.\n   * @example\n   * container.setElementByPos(-1, 1); // throw a RangeError\n   */\n  abstract setElementByPos(pos: number, element: T): void;\n  /**\n   * @description Removes the elements of the specified value.\n   * @param value - The value you want to remove.\n   * @returns The size of container after erasing.\n   * @example\n   * container.eraseElementByValue(-1);\n   */\n  abstract eraseElementByValue(value: T): number;\n  /**\n   * @description Insert several elements after the specified position.\n   * @param pos - The position you want to insert.\n   * @param element - The element you want to insert.\n   * @param num - The number of elements you want to insert (default 1).\n   * @returns The size of container after inserting.\n   * @example\n   * const container = new Vector([1, 2, 3]);\n   * container.insert(1, 4);  // [1, 4, 2, 3]\n   * container.insert(1, 5, 3); // [1, 5, 5, 5, 4, 2, 3]\n   */\n  abstract insert(pos: number, element: T, num?: number): number;\n  /**\n   * @description Reverses the container.\n   * @example\n   * const container = new Vector([1, 2, 3]);\n   * container.reverse(); // [3, 2, 1]\n   */\n  abstract reverse(): void;\n  /**\n   * @description Removes the duplication of elements in the container.\n   * @returns The size of container after inserting.\n   * @example\n   * const container = new Vector([1, 1, 3, 2, 2, 5, 5, 2]);\n   * container.unique(); // [1, 3, 2, 5, 2]\n   */\n  abstract unique(): number;\n  /**\n   * @description Sort the container.\n   * @param cmp - Comparison function to sort.\n   * @example\n   * const container = new Vector([3, 1, 10]);\n   * container.sort();  // [1, 10, 3]\n   * container.sort((x, y) => x - y); // [1, 3, 10]\n   */\n  abstract sort(cmp?: (x: T, y: T) => number): void;\n}\n\nexport default SequentialContainer;\n"]}

node_modules/js-sdsl/dist/esm/container/SequentialContainer/Deque.d.ts

@@ -0,0 +1,58 @@
+import SequentialContainer from './Base';
+import { IteratorType, initContainer } from "../ContainerBase";
+import { RandomIterator } from "./Base/RandomIterator";
+declare class DequeIterator<T> extends RandomIterator<T> {
+    readonly container: Deque<T>;
+    constructor(node: number, container: Deque<T>, iteratorType?: IteratorType);
+    copy(): DequeIterator<T>;
+    equals(iter: DequeIterator<T>): boolean;
+}
+export type { DequeIterator };
+declare class Deque<T> extends SequentialContainer<T> {
+    constructor(container?: initContainer<T>, _bucketSize?: number);
+    clear(): void;
+    begin(): DequeIterator<T>;
+    end(): DequeIterator<T>;
+    rBegin(): DequeIterator<T>;
+    rEnd(): DequeIterator<T>;
+    front(): T | undefined;
+    back(): T | undefined;
+    pushBack(element: T): number;
+    popBack(): T | undefined;
+    /**
+     * @description Push the element to the front.
+     * @param element - The element you want to push.
+     * @returns The size of queue after pushing.
+     */
+    pushFront(element: T): number;
+    /**
+     * @description Remove the _first element.
+     * @returns The element you popped.
+     */
+    popFront(): T | undefined;
+    getElementByPos(pos: number): T;
+    setElementByPos(pos: number, element: T): void;
+    insert(pos: number, element: T, num?: number): number;
+    /**
+     * @description Remove all elements after the specified position (excluding the specified position).
+     * @param pos - The previous position of the first removed element.
+     * @returns The size of the container after cutting.
+     * @example
+     * deque.cut(1); // Then deque's size will be 2. deque -> [0, 1]
+     */
+    cut(pos: number): number;
+    eraseElementByPos(pos: number): number;
+    eraseElementByValue(value: T): number;
+    eraseElementByIterator(iter: DequeIterator<T>): DequeIterator<T>;
+    find(element: T): DequeIterator<T>;
+    reverse(): void;
+    unique(): number;
+    sort(cmp?: (x: T, y: T) => number): void;
+    /**
+     * @description Remove as much useless space as possible.
+     */
+    shrinkToFit(): void;
+    forEach(callback: (element: T, index: number, deque: Deque<T>) => void): void;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+}
+export default Deque;

node_modules/js-sdsl/dist/esm/container/SequentialContainer/Deque.js

@@ -0,0 +1,498 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(t, i) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(t, i) {
+            t.__proto__ = i;
+        } || function(t, i) {
+            for (var r in i) if (Object.prototype.hasOwnProperty.call(i, r)) t[r] = i[r];
+        };
+        return extendStatics(t, i);
+    };
+    return function(t, i) {
+        if (typeof i !== "function" && i !== null) throw new TypeError("Class extends value " + String(i) + " is not a constructor or null");
+        extendStatics(t, i);
+        function __() {
+            this.constructor = t;
+        }
+        t.prototype = i === null ? Object.create(i) : (__.prototype = i.prototype, new __);
+    };
+}();
+
+var __generator = this && this.i || function(t, i) {
+    var r = {
+        label: 0,
+        sent: function() {
+            if (h[0] & 1) throw h[1];
+            return h[1];
+        },
+        trys: [],
+        ops: []
+    }, e, s, h, n;
+    return n = {
+        next: verb(0),
+        throw: verb(1),
+        return: verb(2)
+    }, typeof Symbol === "function" && (n[Symbol.iterator] = function() {
+        return this;
+    }), n;
+    function verb(t) {
+        return function(i) {
+            return step([ t, i ]);
+        };
+    }
+    function step(n) {
+        if (e) throw new TypeError("Generator is already executing.");
+        while (r) try {
+            if (e = 1, s && (h = n[0] & 2 ? s["return"] : n[0] ? s["throw"] || ((h = s["return"]) && h.call(s), 
+            0) : s.next) && !(h = h.call(s, n[1])).done) return h;
+            if (s = 0, h) n = [ n[0] & 2, h.value ];
+            switch (n[0]) {
+              case 0:
+              case 1:
+                h = n;
+                break;
+
+              case 4:
+                r.label++;
+                return {
+                    value: n[1],
+                    done: false
+                };
+
+              case 5:
+                r.label++;
+                s = n[1];
+                n = [ 0 ];
+                continue;
+
+              case 7:
+                n = r.ops.pop();
+                r.trys.pop();
+                continue;
+
+              default:
+                if (!(h = r.trys, h = h.length > 0 && h[h.length - 1]) && (n[0] === 6 || n[0] === 2)) {
+                    r = 0;
+                    continue;
+                }
+                if (n[0] === 3 && (!h || n[1] > h[0] && n[1] < h[3])) {
+                    r.label = n[1];
+                    break;
+                }
+                if (n[0] === 6 && r.label < h[1]) {
+                    r.label = h[1];
+                    h = n;
+                    break;
+                }
+                if (h && r.label < h[2]) {
+                    r.label = h[2];
+                    r.ops.push(n);
+                    break;
+                }
+                if (h[2]) r.ops.pop();
+                r.trys.pop();
+                continue;
+            }
+            n = i.call(t, r);
+        } catch (t) {
+            n = [ 6, t ];
+            s = 0;
+        } finally {
+            e = h = 0;
+        }
+        if (n[0] & 5) throw n[1];
+        return {
+            value: n[0] ? n[1] : void 0,
+            done: true
+        };
+    }
+};
+
+var __read = this && this.q || function(t, i) {
+    var r = typeof Symbol === "function" && t[Symbol.iterator];
+    if (!r) return t;
+    var e = r.call(t), s, h = [], n;
+    try {
+        while ((i === void 0 || i-- > 0) && !(s = e.next()).done) h.push(s.value);
+    } catch (t) {
+        n = {
+            error: t
+        };
+    } finally {
+        try {
+            if (s && !s.done && (r = e["return"])) r.call(e);
+        } finally {
+            if (n) throw n.error;
+        }
+    }
+    return h;
+};
+
+var __spreadArray = this && this.D || function(t, i, r) {
+    if (r || arguments.length === 2) for (var e = 0, s = i.length, h; e < s; e++) {
+        if (h || !(e in i)) {
+            if (!h) h = Array.prototype.slice.call(i, 0, e);
+            h[e] = i[e];
+        }
+    }
+    return t.concat(h || Array.prototype.slice.call(i));
+};
+
+import SequentialContainer from "./Base";
+
+import { RandomIterator } from "./Base/RandomIterator";
+
+var DequeIterator = function(t) {
+    __extends(DequeIterator, t);
+    function DequeIterator(i, r, e) {
+        var s = t.call(this, i, e) || this;
+        s.container = r;
+        return s;
+    }
+    DequeIterator.prototype.copy = function() {
+        return new DequeIterator(this.o, this.container, this.iteratorType);
+    };
+    return DequeIterator;
+}(RandomIterator);
+
+var Deque = function(t) {
+    __extends(Deque, t);
+    function Deque(i, r) {
+        if (i === void 0) {
+            i = [];
+        }
+        if (r === void 0) {
+            r = 1 << 12;
+        }
+        var e = t.call(this) || this;
+        e.A = 0;
+        e.S = 0;
+        e.R = 0;
+        e.k = 0;
+        e.C = 0;
+        e.j = [];
+        var s = function() {
+            if (typeof i.length === "number") return i.length;
+            if (typeof i.size === "number") return i.size;
+            if (typeof i.size === "function") return i.size();
+            throw new TypeError("Cannot get the length or size of the container");
+        }();
+        e.B = r;
+        e.C = Math.max(Math.ceil(s / e.B), 1);
+        for (var h = 0; h < e.C; ++h) {
+            e.j.push(new Array(e.B));
+        }
+        var n = Math.ceil(s / e.B);
+        e.A = e.R = (e.C >> 1) - (n >> 1);
+        e.S = e.k = e.B - s % e.B >> 1;
+        var u = e;
+        i.forEach((function(t) {
+            u.pushBack(t);
+        }));
+        return e;
+    }
+    Deque.prototype.O = function() {
+        var t = [];
+        var i = Math.max(this.C >> 1, 1);
+        for (var r = 0; r < i; ++r) {
+            t[r] = new Array(this.B);
+        }
+        for (var r = this.A; r < this.C; ++r) {
+            t[t.length] = this.j[r];
+        }
+        for (var r = 0; r < this.R; ++r) {
+            t[t.length] = this.j[r];
+        }
+        t[t.length] = __spreadArray([], __read(this.j[this.R]), false);
+        this.A = i;
+        this.R = t.length - 1;
+        for (var r = 0; r < i; ++r) {
+            t[t.length] = new Array(this.B);
+        }
+        this.j = t;
+        this.C = t.length;
+    };
+    Deque.prototype.T = function(t) {
+        var i = this.S + t + 1;
+        var r = i % this.B;
+        var e = r - 1;
+        var s = this.A + (i - r) / this.B;
+        if (r === 0) s -= 1;
+        s %= this.C;
+        if (e < 0) e += this.B;
+        return {
+            curNodeBucketIndex: s,
+            curNodePointerIndex: e
+        };
+    };
+    Deque.prototype.clear = function() {
+        this.j = [ new Array(this.B) ];
+        this.C = 1;
+        this.A = this.R = this.M = 0;
+        this.S = this.k = this.B >> 1;
+    };
+    Deque.prototype.begin = function() {
+        return new DequeIterator(0, this);
+    };
+    Deque.prototype.end = function() {
+        return new DequeIterator(this.M, this);
+    };
+    Deque.prototype.rBegin = function() {
+        return new DequeIterator(this.M - 1, this, 1);
+    };
+    Deque.prototype.rEnd = function() {
+        return new DequeIterator(-1, this, 1);
+    };
+    Deque.prototype.front = function() {
+        if (this.M === 0) return;
+        return this.j[this.A][this.S];
+    };
+    Deque.prototype.back = function() {
+        if (this.M === 0) return;
+        return this.j[this.R][this.k];
+    };
+    Deque.prototype.pushBack = function(t) {
+        if (this.M) {
+            if (this.k < this.B - 1) {
+                this.k += 1;
+            } else if (this.R < this.C - 1) {
+                this.R += 1;
+                this.k = 0;
+            } else {
+                this.R = 0;
+                this.k = 0;
+            }
+            if (this.R === this.A && this.k === this.S) this.O();
+        }
+        this.M += 1;
+        this.j[this.R][this.k] = t;
+        return this.M;
+    };
+    Deque.prototype.popBack = function() {
+        if (this.M === 0) return;
+        var t = this.j[this.R][this.k];
+        if (this.M !== 1) {
+            if (this.k > 0) {
+                this.k -= 1;
+            } else if (this.R > 0) {
+                this.R -= 1;
+                this.k = this.B - 1;
+            } else {
+                this.R = this.C - 1;
+                this.k = this.B - 1;
+            }
+        }
+        this.M -= 1;
+        return t;
+    };
+    Deque.prototype.pushFront = function(t) {
+        if (this.M) {
+            if (this.S > 0) {
+                this.S -= 1;
+            } else if (this.A > 0) {
+                this.A -= 1;
+                this.S = this.B - 1;
+            } else {
+                this.A = this.C - 1;
+                this.S = this.B - 1;
+            }
+            if (this.A === this.R && this.S === this.k) this.O();
+        }
+        this.M += 1;
+        this.j[this.A][this.S] = t;
+        return this.M;
+    };
+    Deque.prototype.popFront = function() {
+        if (this.M === 0) return;
+        var t = this.j[this.A][this.S];
+        if (this.M !== 1) {
+            if (this.S < this.B - 1) {
+                this.S += 1;
+            } else if (this.A < this.C - 1) {
+                this.A += 1;
+                this.S = 0;
+            } else {
+                this.A = 0;
+                this.S = 0;
+            }
+        }
+        this.M -= 1;
+        return t;
+    };
+    Deque.prototype.getElementByPos = function(t) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        var i = this.T(t), r = i.curNodeBucketIndex, e = i.curNodePointerIndex;
+        return this.j[r][e];
+    };
+    Deque.prototype.setElementByPos = function(t, i) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        var r = this.T(t), e = r.curNodeBucketIndex, s = r.curNodePointerIndex;
+        this.j[e][s] = i;
+    };
+    Deque.prototype.insert = function(t, i, r) {
+        if (r === void 0) {
+            r = 1;
+        }
+        if (t < 0 || t > this.M) {
+            throw new RangeError;
+        }
+        if (t === 0) {
+            while (r--) this.pushFront(i);
+        } else if (t === this.M) {
+            while (r--) this.pushBack(i);
+        } else {
+            var e = [];
+            for (var s = t; s < this.M; ++s) {
+                e.push(this.getElementByPos(s));
+            }
+            this.cut(t - 1);
+            for (var s = 0; s < r; ++s) this.pushBack(i);
+            for (var s = 0; s < e.length; ++s) this.pushBack(e[s]);
+        }
+        return this.M;
+    };
+    Deque.prototype.cut = function(t) {
+        if (t < 0) {
+            this.clear();
+            return 0;
+        }
+        var i = this.T(t), r = i.curNodeBucketIndex, e = i.curNodePointerIndex;
+        this.R = r;
+        this.k = e;
+        this.M = t + 1;
+        return this.M;
+    };
+    Deque.prototype.eraseElementByPos = function(t) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        if (t === 0) this.popFront(); else if (t === this.M - 1) this.popBack(); else {
+            var i = [];
+            for (var r = t + 1; r < this.M; ++r) {
+                i.push(this.getElementByPos(r));
+            }
+            this.cut(t);
+            this.popBack();
+            var e = this;
+            i.forEach((function(t) {
+                e.pushBack(t);
+            }));
+        }
+        return this.M;
+    };
+    Deque.prototype.eraseElementByValue = function(t) {
+        if (this.M === 0) return 0;
+        var i = [];
+        for (var r = 0; r < this.M; ++r) {
+            var e = this.getElementByPos(r);
+            if (e !== t) i.push(e);
+        }
+        var s = i.length;
+        for (var r = 0; r < s; ++r) this.setElementByPos(r, i[r]);
+        return this.cut(s - 1);
+    };
+    Deque.prototype.eraseElementByIterator = function(t) {
+        var i = t.o;
+        this.eraseElementByPos(i);
+        t = t.next();
+        return t;
+    };
+    Deque.prototype.find = function(t) {
+        for (var i = 0; i < this.M; ++i) {
+            if (this.getElementByPos(i) === t) {
+                return new DequeIterator(i, this);
+            }
+        }
+        return this.end();
+    };
+    Deque.prototype.reverse = function() {
+        var t = 0;
+        var i = this.M - 1;
+        while (t < i) {
+            var r = this.getElementByPos(t);
+            this.setElementByPos(t, this.getElementByPos(i));
+            this.setElementByPos(i, r);
+            t += 1;
+            i -= 1;
+        }
+    };
+    Deque.prototype.unique = function() {
+        if (this.M <= 1) {
+            return this.M;
+        }
+        var t = 1;
+        var i = this.getElementByPos(0);
+        for (var r = 1; r < this.M; ++r) {
+            var e = this.getElementByPos(r);
+            if (e !== i) {
+                i = e;
+                this.setElementByPos(t++, e);
+            }
+        }
+        while (this.M > t) this.popBack();
+        return this.M;
+    };
+    Deque.prototype.sort = function(t) {
+        var i = [];
+        for (var r = 0; r < this.M; ++r) {
+            i.push(this.getElementByPos(r));
+        }
+        i.sort(t);
+        for (var r = 0; r < this.M; ++r) this.setElementByPos(r, i[r]);
+    };
+    Deque.prototype.shrinkToFit = function() {
+        if (this.M === 0) return;
+        var t = [];
+        this.forEach((function(i) {
+            t.push(i);
+        }));
+        this.C = Math.max(Math.ceil(this.M / this.B), 1);
+        this.M = this.A = this.R = this.S = this.k = 0;
+        this.j = [];
+        for (var i = 0; i < this.C; ++i) {
+            this.j.push(new Array(this.B));
+        }
+        for (var i = 0; i < t.length; ++i) this.pushBack(t[i]);
+    };
+    Deque.prototype.forEach = function(t) {
+        for (var i = 0; i < this.M; ++i) {
+            t(this.getElementByPos(i), i, this);
+        }
+    };
+    Deque.prototype[Symbol.iterator] = function() {
+        return function() {
+            var t;
+            return __generator(this, (function(i) {
+                switch (i.label) {
+                  case 0:
+                    t = 0;
+                    i.label = 1;
+
+                  case 1:
+                    if (!(t < this.M)) return [ 3, 4 ];
+                    return [ 4, this.getElementByPos(t) ];
+
+                  case 2:
+                    i.sent();
+                    i.label = 3;
+
+                  case 3:
+                    ++t;
+                    return [ 3, 1 ];
+
+                  case 4:
+                    return [ 2 ];
+                }
+            }));
+        }.bind(this)();
+    };
+    return Deque;
+}(SequentialContainer);
+
+export default Deque;
+//# sourceMappingURL=Deque.js.map

node_modules/js-sdsl/dist/esm/container/SequentialContainer/LinkList.d.ts

@@ -0,0 +1,58 @@
+import SequentialContainer from './Base';
+import { ContainerIterator, initContainer } from "../ContainerBase";
+declare class LinkListIterator<T> extends ContainerIterator<T> {
+    readonly container: LinkList<T>;
+    get pointer(): T;
+    set pointer(newValue: T);
+    copy(): LinkListIterator<T>;
+    equals(iter: LinkListIterator<T>): boolean;
+    pre(): this;
+    next(): this;
+}
+export type { LinkListIterator };
+declare class LinkList<T> extends SequentialContainer<T> {
+    constructor(container?: initContainer<T>);
+    clear(): void;
+    begin(): LinkListIterator<T>;
+    end(): LinkListIterator<T>;
+    rBegin(): LinkListIterator<T>;
+    rEnd(): LinkListIterator<T>;
+    front(): T | undefined;
+    back(): T | undefined;
+    getElementByPos(pos: number): T;
+    eraseElementByPos(pos: number): number;
+    eraseElementByValue(_value: T): number;
+    eraseElementByIterator(iter: LinkListIterator<T>): LinkListIterator<T>;
+    pushBack(element: T): number;
+    popBack(): T | undefined;
+    /**
+     * @description Push an element to the front.
+     * @param element - The element you want to push.
+     * @returns The size of queue after pushing.
+     */
+    pushFront(element: T): number;
+    /**
+     * @description Removes the first element.
+     * @returns The element you popped.
+     */
+    popFront(): T | undefined;
+    setElementByPos(pos: number, element: T): void;
+    insert(pos: number, element: T, num?: number): number;
+    find(element: T): LinkListIterator<T>;
+    reverse(): void;
+    unique(): number;
+    sort(cmp?: (x: T, y: T) => number): void;
+    /**
+     * @description Merges two sorted lists.
+     * @param list - The other list you want to merge (must be sorted).
+     * @returns The size of list after merging.
+     * @example
+     * const linkA = new LinkList([1, 3, 5]);
+     * const linkB = new LinkList([2, 4, 6]);
+     * linkA.merge(linkB);  // [1, 2, 3, 4, 5];
+     */
+    merge(list: LinkList<T>): number;
+    forEach(callback: (element: T, index: number, list: LinkList<T>) => void): void;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+}
+export default LinkList;

node_modules/js-sdsl/dist/esm/container/SequentialContainer/LinkList.js

@@ -0,0 +1,456 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(t, i) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(t, i) {
+            t.__proto__ = i;
+        } || function(t, i) {
+            for (var r in i) if (Object.prototype.hasOwnProperty.call(i, r)) t[r] = i[r];
+        };
+        return extendStatics(t, i);
+    };
+    return function(t, i) {
+        if (typeof i !== "function" && i !== null) throw new TypeError("Class extends value " + String(i) + " is not a constructor or null");
+        extendStatics(t, i);
+        function __() {
+            this.constructor = t;
+        }
+        t.prototype = i === null ? Object.create(i) : (__.prototype = i.prototype, new __);
+    };
+}();
+
+var __generator = this && this.i || function(t, i) {
+    var r = {
+        label: 0,
+        sent: function() {
+            if (e[0] & 1) throw e[1];
+            return e[1];
+        },
+        trys: [],
+        ops: []
+    }, n, s, e, h;
+    return h = {
+        next: verb(0),
+        throw: verb(1),
+        return: verb(2)
+    }, typeof Symbol === "function" && (h[Symbol.iterator] = function() {
+        return this;
+    }), h;
+    function verb(t) {
+        return function(i) {
+            return step([ t, i ]);
+        };
+    }
+    function step(h) {
+        if (n) throw new TypeError("Generator is already executing.");
+        while (r) try {
+            if (n = 1, s && (e = h[0] & 2 ? s["return"] : h[0] ? s["throw"] || ((e = s["return"]) && e.call(s), 
+            0) : s.next) && !(e = e.call(s, h[1])).done) return e;
+            if (s = 0, e) h = [ h[0] & 2, e.value ];
+            switch (h[0]) {
+              case 0:
+              case 1:
+                e = h;
+                break;
+
+              case 4:
+                r.label++;
+                return {
+                    value: h[1],
+                    done: false
+                };
+
+              case 5:
+                r.label++;
+                s = h[1];
+                h = [ 0 ];
+                continue;
+
+              case 7:
+                h = r.ops.pop();
+                r.trys.pop();
+                continue;
+
+              default:
+                if (!(e = r.trys, e = e.length > 0 && e[e.length - 1]) && (h[0] === 6 || h[0] === 2)) {
+                    r = 0;
+                    continue;
+                }
+                if (h[0] === 3 && (!e || h[1] > e[0] && h[1] < e[3])) {
+                    r.label = h[1];
+                    break;
+                }
+                if (h[0] === 6 && r.label < e[1]) {
+                    r.label = e[1];
+                    e = h;
+                    break;
+                }
+                if (e && r.label < e[2]) {
+                    r.label = e[2];
+                    r.ops.push(h);
+                    break;
+                }
+                if (e[2]) r.ops.pop();
+                r.trys.pop();
+                continue;
+            }
+            h = i.call(t, r);
+        } catch (t) {
+            h = [ 6, t ];
+            s = 0;
+        } finally {
+            n = e = 0;
+        }
+        if (h[0] & 5) throw h[1];
+        return {
+            value: h[0] ? h[1] : void 0,
+            done: true
+        };
+    }
+};
+
+import SequentialContainer from "./Base";
+
+import { ContainerIterator } from "../ContainerBase";
+
+import { throwIteratorAccessError } from "../../utils/throwError";
+
+var LinkListIterator = function(t) {
+    __extends(LinkListIterator, t);
+    function LinkListIterator(i, r, n, s) {
+        var e = t.call(this, s) || this;
+        e.o = i;
+        e.h = r;
+        e.container = n;
+        if (e.iteratorType === 0) {
+            e.pre = function() {
+                if (this.o.L === this.h) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.L;
+                return this;
+            };
+            e.next = function() {
+                if (this.o === this.h) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.m;
+                return this;
+            };
+        } else {
+            e.pre = function() {
+                if (this.o.m === this.h) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.m;
+                return this;
+            };
+            e.next = function() {
+                if (this.o === this.h) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.L;
+                return this;
+            };
+        }
+        return e;
+    }
+    Object.defineProperty(LinkListIterator.prototype, "pointer", {
+        get: function() {
+            if (this.o === this.h) {
+                throwIteratorAccessError();
+            }
+            return this.o.p;
+        },
+        set: function(t) {
+            if (this.o === this.h) {
+                throwIteratorAccessError();
+            }
+            this.o.p = t;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LinkListIterator.prototype.copy = function() {
+        return new LinkListIterator(this.o, this.h, this.container, this.iteratorType);
+    };
+    return LinkListIterator;
+}(ContainerIterator);
+
+var LinkList = function(t) {
+    __extends(LinkList, t);
+    function LinkList(i) {
+        if (i === void 0) {
+            i = [];
+        }
+        var r = t.call(this) || this;
+        r.h = {};
+        r.H = r.l = r.h.L = r.h.m = r.h;
+        var n = r;
+        i.forEach((function(t) {
+            n.pushBack(t);
+        }));
+        return r;
+    }
+    LinkList.prototype.G = function(t) {
+        var i = t.L, r = t.m;
+        i.m = r;
+        r.L = i;
+        if (t === this.H) {
+            this.H = r;
+        }
+        if (t === this.l) {
+            this.l = i;
+        }
+        this.M -= 1;
+    };
+    LinkList.prototype.F = function(t, i) {
+        var r = i.m;
+        var n = {
+            p: t,
+            L: i,
+            m: r
+        };
+        i.m = n;
+        r.L = n;
+        if (i === this.h) {
+            this.H = n;
+        }
+        if (r === this.h) {
+            this.l = n;
+        }
+        this.M += 1;
+    };
+    LinkList.prototype.clear = function() {
+        this.M = 0;
+        this.H = this.l = this.h.L = this.h.m = this.h;
+    };
+    LinkList.prototype.begin = function() {
+        return new LinkListIterator(this.H, this.h, this);
+    };
+    LinkList.prototype.end = function() {
+        return new LinkListIterator(this.h, this.h, this);
+    };
+    LinkList.prototype.rBegin = function() {
+        return new LinkListIterator(this.l, this.h, this, 1);
+    };
+    LinkList.prototype.rEnd = function() {
+        return new LinkListIterator(this.h, this.h, this, 1);
+    };
+    LinkList.prototype.front = function() {
+        return this.H.p;
+    };
+    LinkList.prototype.back = function() {
+        return this.l.p;
+    };
+    LinkList.prototype.getElementByPos = function(t) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        var i = this.H;
+        while (t--) {
+            i = i.m;
+        }
+        return i.p;
+    };
+    LinkList.prototype.eraseElementByPos = function(t) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        var i = this.H;
+        while (t--) {
+            i = i.m;
+        }
+        this.G(i);
+        return this.M;
+    };
+    LinkList.prototype.eraseElementByValue = function(t) {
+        var i = this.H;
+        while (i !== this.h) {
+            if (i.p === t) {
+                this.G(i);
+            }
+            i = i.m;
+        }
+        return this.M;
+    };
+    LinkList.prototype.eraseElementByIterator = function(t) {
+        var i = t.o;
+        if (i === this.h) {
+            throwIteratorAccessError();
+        }
+        t = t.next();
+        this.G(i);
+        return t;
+    };
+    LinkList.prototype.pushBack = function(t) {
+        this.F(t, this.l);
+        return this.M;
+    };
+    LinkList.prototype.popBack = function() {
+        if (this.M === 0) return;
+        var t = this.l.p;
+        this.G(this.l);
+        return t;
+    };
+    LinkList.prototype.pushFront = function(t) {
+        this.F(t, this.h);
+        return this.M;
+    };
+    LinkList.prototype.popFront = function() {
+        if (this.M === 0) return;
+        var t = this.H.p;
+        this.G(this.H);
+        return t;
+    };
+    LinkList.prototype.setElementByPos = function(t, i) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        var r = this.H;
+        while (t--) {
+            r = r.m;
+        }
+        r.p = i;
+    };
+    LinkList.prototype.insert = function(t, i, r) {
+        if (r === void 0) {
+            r = 1;
+        }
+        if (t < 0 || t > this.M) {
+            throw new RangeError;
+        }
+        if (r <= 0) return this.M;
+        if (t === 0) {
+            while (r--) this.pushFront(i);
+        } else if (t === this.M) {
+            while (r--) this.pushBack(i);
+        } else {
+            var n = this.H;
+            for (var s = 1; s < t; ++s) {
+                n = n.m;
+            }
+            var e = n.m;
+            this.M += r;
+            while (r--) {
+                n.m = {
+                    p: i,
+                    L: n
+                };
+                n.m.L = n;
+                n = n.m;
+            }
+            n.m = e;
+            e.L = n;
+        }
+        return this.M;
+    };
+    LinkList.prototype.find = function(t) {
+        var i = this.H;
+        while (i !== this.h) {
+            if (i.p === t) {
+                return new LinkListIterator(i, this.h, this);
+            }
+            i = i.m;
+        }
+        return this.end();
+    };
+    LinkList.prototype.reverse = function() {
+        if (this.M <= 1) return;
+        var t = this.H;
+        var i = this.l;
+        var r = 0;
+        while (r << 1 < this.M) {
+            var n = t.p;
+            t.p = i.p;
+            i.p = n;
+            t = t.m;
+            i = i.L;
+            r += 1;
+        }
+    };
+    LinkList.prototype.unique = function() {
+        if (this.M <= 1) {
+            return this.M;
+        }
+        var t = this.H;
+        while (t !== this.h) {
+            var i = t;
+            while (i.m !== this.h && i.p === i.m.p) {
+                i = i.m;
+                this.M -= 1;
+            }
+            t.m = i.m;
+            t.m.L = t;
+            t = t.m;
+        }
+        return this.M;
+    };
+    LinkList.prototype.sort = function(t) {
+        if (this.M <= 1) return;
+        var i = [];
+        this.forEach((function(t) {
+            i.push(t);
+        }));
+        i.sort(t);
+        var r = this.H;
+        i.forEach((function(t) {
+            r.p = t;
+            r = r.m;
+        }));
+    };
+    LinkList.prototype.merge = function(t) {
+        var i = this;
+        if (this.M === 0) {
+            t.forEach((function(t) {
+                i.pushBack(t);
+            }));
+        } else {
+            var r = this.H;
+            t.forEach((function(t) {
+                while (r !== i.h && r.p <= t) {
+                    r = r.m;
+                }
+                i.F(t, r.L);
+            }));
+        }
+        return this.M;
+    };
+    LinkList.prototype.forEach = function(t) {
+        var i = this.H;
+        var r = 0;
+        while (i !== this.h) {
+            t(i.p, r++, this);
+            i = i.m;
+        }
+    };
+    LinkList.prototype[Symbol.iterator] = function() {
+        return function() {
+            var t;
+            return __generator(this, (function(i) {
+                switch (i.label) {
+                  case 0:
+                    if (this.M === 0) return [ 2 ];
+                    t = this.H;
+                    i.label = 1;
+
+                  case 1:
+                    if (!(t !== this.h)) return [ 3, 3 ];
+                    return [ 4, t.p ];
+
+                  case 2:
+                    i.sent();
+                    t = t.m;
+                    return [ 3, 1 ];
+
+                  case 3:
+                    return [ 2 ];
+                }
+            }));
+        }.bind(this)();
+    };
+    return LinkList;
+}(SequentialContainer);
+
+export default LinkList;
+//# sourceMappingURL=LinkList.js.map

node_modules/js-sdsl/dist/esm/container/SequentialContainer/Vector.d.ts

@@ -0,0 +1,40 @@
+import SequentialContainer from './Base';
+import { initContainer, IteratorType } from "../ContainerBase";
+import { RandomIterator } from "./Base/RandomIterator";
+declare class VectorIterator<T> extends RandomIterator<T> {
+    container: Vector<T>;
+    constructor(node: number, container: Vector<T>, iteratorType?: IteratorType);
+    copy(): VectorIterator<T>;
+    equals(iter: VectorIterator<T>): boolean;
+}
+export type { VectorIterator };
+declare class Vector<T> extends SequentialContainer<T> {
+    /**
+     * @param container - Initialize container, must have a forEach function.
+     * @param copy - When the container is an array, you can choose to directly operate on the original object of
+     *               the array or perform a shallow copy. The default is shallow copy.
+     */
+    constructor(container?: initContainer<T>, copy?: boolean);
+    clear(): void;
+    begin(): VectorIterator<T>;
+    end(): VectorIterator<T>;
+    rBegin(): VectorIterator<T>;
+    rEnd(): VectorIterator<T>;
+    front(): T | undefined;
+    back(): T | undefined;
+    getElementByPos(pos: number): T;
+    eraseElementByPos(pos: number): number;
+    eraseElementByValue(value: T): number;
+    eraseElementByIterator(iter: VectorIterator<T>): VectorIterator<T>;
+    pushBack(element: T): number;
+    popBack(): T | undefined;
+    setElementByPos(pos: number, element: T): void;
+    insert(pos: number, element: T, num?: number): number;
+    find(element: T): VectorIterator<T>;
+    reverse(): void;
+    unique(): number;
+    sort(cmp?: (x: T, y: T) => number): void;
+    forEach(callback: (element: T, index: number, vector: Vector<T>) => void): void;
+    [Symbol.iterator](): Generator<T, void, undefined>;
+}
+export default Vector;

node_modules/js-sdsl/dist/esm/container/SequentialContainer/Vector.js

@@ -0,0 +1,323 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(t, r) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(t, r) {
+            t.__proto__ = r;
+        } || function(t, r) {
+            for (var e in r) if (Object.prototype.hasOwnProperty.call(r, e)) t[e] = r[e];
+        };
+        return extendStatics(t, r);
+    };
+    return function(t, r) {
+        if (typeof r !== "function" && r !== null) throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+        extendStatics(t, r);
+        function __() {
+            this.constructor = t;
+        }
+        t.prototype = r === null ? Object.create(r) : (__.prototype = r.prototype, new __);
+    };
+}();
+
+var __generator = this && this.i || function(t, r) {
+    var e = {
+        label: 0,
+        sent: function() {
+            if (o[0] & 1) throw o[1];
+            return o[1];
+        },
+        trys: [],
+        ops: []
+    }, n, i, o, u;
+    return u = {
+        next: verb(0),
+        throw: verb(1),
+        return: verb(2)
+    }, typeof Symbol === "function" && (u[Symbol.iterator] = function() {
+        return this;
+    }), u;
+    function verb(t) {
+        return function(r) {
+            return step([ t, r ]);
+        };
+    }
+    function step(u) {
+        if (n) throw new TypeError("Generator is already executing.");
+        while (e) try {
+            if (n = 1, i && (o = u[0] & 2 ? i["return"] : u[0] ? i["throw"] || ((o = i["return"]) && o.call(i), 
+            0) : i.next) && !(o = o.call(i, u[1])).done) return o;
+            if (i = 0, o) u = [ u[0] & 2, o.value ];
+            switch (u[0]) {
+              case 0:
+              case 1:
+                o = u;
+                break;
+
+              case 4:
+                e.label++;
+                return {
+                    value: u[1],
+                    done: false
+                };
+
+              case 5:
+                e.label++;
+                i = u[1];
+                u = [ 0 ];
+                continue;
+
+              case 7:
+                u = e.ops.pop();
+                e.trys.pop();
+                continue;
+
+              default:
+                if (!(o = e.trys, o = o.length > 0 && o[o.length - 1]) && (u[0] === 6 || u[0] === 2)) {
+                    e = 0;
+                    continue;
+                }
+                if (u[0] === 3 && (!o || u[1] > o[0] && u[1] < o[3])) {
+                    e.label = u[1];
+                    break;
+                }
+                if (u[0] === 6 && e.label < o[1]) {
+                    e.label = o[1];
+                    o = u;
+                    break;
+                }
+                if (o && e.label < o[2]) {
+                    e.label = o[2];
+                    e.ops.push(u);
+                    break;
+                }
+                if (o[2]) e.ops.pop();
+                e.trys.pop();
+                continue;
+            }
+            u = r.call(t, e);
+        } catch (t) {
+            u = [ 6, t ];
+            i = 0;
+        } finally {
+            n = o = 0;
+        }
+        if (u[0] & 5) throw u[1];
+        return {
+            value: u[0] ? u[1] : void 0,
+            done: true
+        };
+    }
+};
+
+var __read = this && this.q || function(t, r) {
+    var e = typeof Symbol === "function" && t[Symbol.iterator];
+    if (!e) return t;
+    var n = e.call(t), i, o = [], u;
+    try {
+        while ((r === void 0 || r-- > 0) && !(i = n.next()).done) o.push(i.value);
+    } catch (t) {
+        u = {
+            error: t
+        };
+    } finally {
+        try {
+            if (i && !i.done && (e = n["return"])) e.call(n);
+        } finally {
+            if (u) throw u.error;
+        }
+    }
+    return o;
+};
+
+var __spreadArray = this && this.D || function(t, r, e) {
+    if (e || arguments.length === 2) for (var n = 0, i = r.length, o; n < i; n++) {
+        if (o || !(n in r)) {
+            if (!o) o = Array.prototype.slice.call(r, 0, n);
+            o[n] = r[n];
+        }
+    }
+    return t.concat(o || Array.prototype.slice.call(r));
+};
+
+var __values = this && this.V || function(t) {
+    var r = typeof Symbol === "function" && Symbol.iterator, e = r && t[r], n = 0;
+    if (e) return e.call(t);
+    if (t && typeof t.length === "number") return {
+        next: function() {
+            if (t && n >= t.length) t = void 0;
+            return {
+                value: t && t[n++],
+                done: !t
+            };
+        }
+    };
+    throw new TypeError(r ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+
+import SequentialContainer from "./Base";
+
+import { RandomIterator } from "./Base/RandomIterator";
+
+var VectorIterator = function(t) {
+    __extends(VectorIterator, t);
+    function VectorIterator(r, e, n) {
+        var i = t.call(this, r, n) || this;
+        i.container = e;
+        return i;
+    }
+    VectorIterator.prototype.copy = function() {
+        return new VectorIterator(this.o, this.container, this.iteratorType);
+    };
+    return VectorIterator;
+}(RandomIterator);
+
+var Vector = function(t) {
+    __extends(Vector, t);
+    function Vector(r, e) {
+        if (r === void 0) {
+            r = [];
+        }
+        if (e === void 0) {
+            e = true;
+        }
+        var n = t.call(this) || this;
+        if (Array.isArray(r)) {
+            n.J = e ? __spreadArray([], __read(r), false) : r;
+            n.M = r.length;
+        } else {
+            n.J = [];
+            var i = n;
+            r.forEach((function(t) {
+                i.pushBack(t);
+            }));
+        }
+        return n;
+    }
+    Vector.prototype.clear = function() {
+        this.M = 0;
+        this.J.length = 0;
+    };
+    Vector.prototype.begin = function() {
+        return new VectorIterator(0, this);
+    };
+    Vector.prototype.end = function() {
+        return new VectorIterator(this.M, this);
+    };
+    Vector.prototype.rBegin = function() {
+        return new VectorIterator(this.M - 1, this, 1);
+    };
+    Vector.prototype.rEnd = function() {
+        return new VectorIterator(-1, this, 1);
+    };
+    Vector.prototype.front = function() {
+        return this.J[0];
+    };
+    Vector.prototype.back = function() {
+        return this.J[this.M - 1];
+    };
+    Vector.prototype.getElementByPos = function(t) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        return this.J[t];
+    };
+    Vector.prototype.eraseElementByPos = function(t) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        this.J.splice(t, 1);
+        this.M -= 1;
+        return this.M;
+    };
+    Vector.prototype.eraseElementByValue = function(t) {
+        var r = 0;
+        for (var e = 0; e < this.M; ++e) {
+            if (this.J[e] !== t) {
+                this.J[r++] = this.J[e];
+            }
+        }
+        this.M = this.J.length = r;
+        return this.M;
+    };
+    Vector.prototype.eraseElementByIterator = function(t) {
+        var r = t.o;
+        t = t.next();
+        this.eraseElementByPos(r);
+        return t;
+    };
+    Vector.prototype.pushBack = function(t) {
+        this.J.push(t);
+        this.M += 1;
+        return this.M;
+    };
+    Vector.prototype.popBack = function() {
+        if (this.M === 0) return;
+        this.M -= 1;
+        return this.J.pop();
+    };
+    Vector.prototype.setElementByPos = function(t, r) {
+        if (t < 0 || t > this.M - 1) {
+            throw new RangeError;
+        }
+        this.J[t] = r;
+    };
+    Vector.prototype.insert = function(t, r, e) {
+        var n;
+        if (e === void 0) {
+            e = 1;
+        }
+        if (t < 0 || t > this.M) {
+            throw new RangeError;
+        }
+        (n = this.J).splice.apply(n, __spreadArray([ t, 0 ], __read(new Array(e).fill(r)), false));
+        this.M += e;
+        return this.M;
+    };
+    Vector.prototype.find = function(t) {
+        for (var r = 0; r < this.M; ++r) {
+            if (this.J[r] === t) {
+                return new VectorIterator(r, this);
+            }
+        }
+        return this.end();
+    };
+    Vector.prototype.reverse = function() {
+        this.J.reverse();
+    };
+    Vector.prototype.unique = function() {
+        var t = 1;
+        for (var r = 1; r < this.M; ++r) {
+            if (this.J[r] !== this.J[r - 1]) {
+                this.J[t++] = this.J[r];
+            }
+        }
+        this.M = this.J.length = t;
+        return this.M;
+    };
+    Vector.prototype.sort = function(t) {
+        this.J.sort(t);
+    };
+    Vector.prototype.forEach = function(t) {
+        for (var r = 0; r < this.M; ++r) {
+            t(this.J[r], r, this);
+        }
+    };
+    Vector.prototype[Symbol.iterator] = function() {
+        return function() {
+            return __generator(this, (function(t) {
+                switch (t.label) {
+                  case 0:
+                    return [ 5, __values(this.J) ];
+
+                  case 1:
+                    t.sent();
+                    return [ 2 ];
+                }
+            }));
+        }.bind(this)();
+    };
+    return Vector;
+}(SequentialContainer);
+
+export default Vector;
+//# sourceMappingURL=Vector.js.map

node_modules/js-sdsl/dist/esm/container/TreeContainer/Base/TreeIterator.d.ts

@@ -0,0 +1,18 @@
+import { ContainerIterator } from "../../ContainerBase";
+import TreeContainer from "./index";
+declare abstract class TreeIterator<K, V> extends ContainerIterator<K | [K, V]> {
+    abstract readonly container: TreeContainer<K, V>;
+    /**
+     * @description Get the sequential index of the iterator in the tree container.<br/>
+     *              <strong>Note:</strong>
+     *              This function only takes effect when the specified tree container `enableIndex = true`.
+     * @returns The index subscript of the node in the tree.
+     * @example
+     * const st = new OrderedSet([1, 2, 3], true);
+     * console.log(st.begin().next().index);  // 1
+     */
+    get index(): number;
+    pre(): this;
+    next(): this;
+}
+export default TreeIterator;

node_modules/js-sdsl/dist/esm/container/TreeContainer/Base/TreeIterator.js

@@ -0,0 +1,98 @@
+var __extends = this && this.t || function() {
+    var extendStatics = function(r, t) {
+        extendStatics = Object.setPrototypeOf || {
+            __proto__: []
+        } instanceof Array && function(r, t) {
+            r.__proto__ = t;
+        } || function(r, t) {
+            for (var e in t) if (Object.prototype.hasOwnProperty.call(t, e)) r[e] = t[e];
+        };
+        return extendStatics(r, t);
+    };
+    return function(r, t) {
+        if (typeof t !== "function" && t !== null) throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+        extendStatics(r, t);
+        function __() {
+            this.constructor = r;
+        }
+        r.prototype = t === null ? Object.create(t) : (__.prototype = t.prototype, new __);
+    };
+}();
+
+import { ContainerIterator } from "../../ContainerBase";
+
+import { throwIteratorAccessError } from "../../../utils/throwError";
+
+var TreeIterator = function(r) {
+    __extends(TreeIterator, r);
+    function TreeIterator(t, e, i) {
+        var n = r.call(this, i) || this;
+        n.o = t;
+        n.h = e;
+        if (n.iteratorType === 0) {
+            n.pre = function() {
+                if (this.o === this.h.K) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.L();
+                return this;
+            };
+            n.next = function() {
+                if (this.o === this.h) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.m();
+                return this;
+            };
+        } else {
+            n.pre = function() {
+                if (this.o === this.h.N) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.m();
+                return this;
+            };
+            n.next = function() {
+                if (this.o === this.h) {
+                    throwIteratorAccessError();
+                }
+                this.o = this.o.L();
+                return this;
+            };
+        }
+        return n;
+    }
+    Object.defineProperty(TreeIterator.prototype, "index", {
+        get: function() {
+            var r = this.o;
+            var t = this.h.rr;
+            if (r === this.h) {
+                if (t) {
+                    return t.tr - 1;
+                }
+                return 0;
+            }
+            var e = 0;
+            if (r.K) {
+                e += r.K.tr;
+            }
+            while (r !== t) {
+                var i = r.rr;
+                if (r === i.N) {
+                    e += 1;
+                    if (i.K) {
+                        e += i.K.tr;
+                    }
+                }
+                r = i;
+            }
+            return e;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return TreeIterator;
+}(ContainerIterator);
+
+export default TreeIterator;
+//# sourceMappingURL=TreeIterator.js.map

node_modules/js-sdsl/dist/esm/container/TreeContainer/Base/TreeNode.d.ts

@@ -0,0 +1,47 @@
+export declare const enum TreeNodeColor {
+    RED = 1,
+    BLACK = 0
+}
+export declare class TreeNode<K, V> {
+    _color: TreeNodeColor;
+    _key: K | undefined;
+    _value: V | undefined;
+    _left: TreeNode<K, V> | undefined;
+    _right: TreeNode<K, V> | undefined;
+    _parent: TreeNode<K, V> | undefined;
+    constructor(key?: K, value?: V);
+    /**
+     * @description Get the pre node.
+     * @returns TreeNode about the pre node.
+     */
+    _pre(): TreeNode<K, V>;
+    /**
+     * @description Get the next node.
+     * @returns TreeNode about the next node.
+     */
+    _next(): TreeNode<K, V>;
+    /**
+     * @description Rotate left.
+     * @returns TreeNode about moved to original position after rotation.
+     */
+    _rotateLeft(): TreeNode<K, V>;
+    /**
+     * @description Rotate right.
+     * @returns TreeNode about moved to original position after rotation.
+     */
+    _rotateRight(): TreeNode<K, V>;
+}
+export declare class TreeNodeEnableIndex<K, V> extends TreeNode<K, V> {
+    _subTreeSize: number;
+    /**
+     * @description Rotate left and do recount.
+     * @returns TreeNode about moved to original position after rotation.
+     */
+    _rotateLeft(): TreeNodeEnableIndex<K, V>;
+    /**
+     * @description Rotate right and do recount.
+     * @returns TreeNode about moved to original position after rotation.
+     */
+    _rotateRight(): TreeNodeEnableIndex<K, V>;
+    _recount(): void;
+}