@machhub-dev/node-red-nodes 1.0.5

package/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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["container/SequentialContainer/Vector.js","../../src/container/SequentialContainer/Vector.ts"],"names":["Object","defineProperty","exports","value","default","_Base","_interopRequireDefault","require","_RandomIterator","obj","__esModule","VectorIterator","RandomIterator","constructor","node","container","iteratorType","super","this","copy","_node","Vector","SequentialContainer","Array","isArray","_vector","_length","length","self","forEach","el","pushBack","clear","begin","end","rBegin","rEnd","front","back","getElementByPos","pos","RangeError","eraseElementByPos","splice","eraseElementByValue","index","i","eraseElementByIterator","iter","next","element","push","popBack","pop","setElementByPos","insert","num","fill","find","reverse","unique","sort","cmp","callback","Symbol","iterator","bind","_default"],"mappings":"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","file":"Vector.js","sourcesContent":["import SequentialContainer from './Base';\nimport { RandomIterator } from \"./Base/RandomIterator\";\nimport $checkWithinAccessParams from \"../../utils/checkParams.macro\";\nclass VectorIterator extends RandomIterator {\n    constructor(node, container, iteratorType) {\n        super(node, iteratorType);\n        this.container = container;\n    }\n    copy() {\n        return new VectorIterator(this._node, this.container, this.iteratorType);\n    }\n}\nclass Vector extends SequentialContainer {\n    /**\n     * @param container - Initialize container, must have a forEach function.\n     * @param copy - When the container is an array, you can choose to directly operate on the original object of\n     *               the array or perform a shallow copy. The default is shallow copy.\n     */\n    constructor(container = [], copy = true) {\n        super();\n        if (Array.isArray(container)) {\n            this._vector = copy ? [...container] : container;\n            this._length = container.length;\n        }\n        else {\n            this._vector = [];\n            const self = this;\n            container.forEach(function (el) {\n                self.pushBack(el);\n            });\n        }\n    }\n    clear() {\n        this._length = 0;\n        this._vector.length = 0;\n    }\n    begin() {\n        return new VectorIterator(0, this);\n    }\n    end() {\n        return new VectorIterator(this._length, this);\n    }\n    rBegin() {\n        return new VectorIterator(this._length - 1, this, 1 /* IteratorType.REVERSE */);\n    }\n    rEnd() {\n        return new VectorIterator(-1, this, 1 /* IteratorType.REVERSE */);\n    }\n    front() {\n        return this._vector[0];\n    }\n    back() {\n        return this._vector[this._length - 1];\n    }\n    getElementByPos(pos) {\n        if (pos < 0 || pos > this._length - 1) {\n            throw new RangeError();\n        }\n        return this._vector[pos];\n    }\n    eraseElementByPos(pos) {\n        if (pos < 0 || pos > this._length - 1) {\n            throw new RangeError();\n        }\n        this._vector.splice(pos, 1);\n        this._length -= 1;\n        return this._length;\n    }\n    eraseElementByValue(value) {\n        let index = 0;\n        for (let i = 0; i < this._length; ++i) {\n            if (this._vector[i] !== value) {\n                this._vector[index++] = this._vector[i];\n            }\n        }\n        this._length = this._vector.length = index;\n        return this._length;\n    }\n    eraseElementByIterator(iter) {\n        const _node = iter._node;\n        iter = iter.next();\n        this.eraseElementByPos(_node);\n        return iter;\n    }\n    pushBack(element) {\n        this._vector.push(element);\n        this._length += 1;\n        return this._length;\n    }\n    popBack() {\n        if (this._length === 0)\n            return;\n        this._length -= 1;\n        return this._vector.pop();\n    }\n    setElementByPos(pos, element) {\n        if (pos < 0 || pos > this._length - 1) {\n            throw new RangeError();\n        }\n        this._vector[pos] = element;\n    }\n    insert(pos, element, num = 1) {\n        if (pos < 0 || pos > this._length) {\n            throw new RangeError();\n        }\n        this._vector.splice(pos, 0, ...new Array(num).fill(element));\n        this._length += num;\n        return this._length;\n    }\n    find(element) {\n        for (let i = 0; i < this._length; ++i) {\n            if (this._vector[i] === element) {\n                return new VectorIterator(i, this);\n            }\n        }\n        return this.end();\n    }\n    reverse() {\n        this._vector.reverse();\n    }\n    unique() {\n        let index = 1;\n        for (let i = 1; i < this._length; ++i) {\n            if (this._vector[i] !== this._vector[i - 1]) {\n                this._vector[index++] = this._vector[i];\n            }\n        }\n        this._length = this._vector.length = index;\n        return this._length;\n    }\n    sort(cmp) {\n        this._vector.sort(cmp);\n    }\n    forEach(callback) {\n        for (let i = 0; i < this._length; ++i) {\n            callback(this._vector[i], i, this);\n        }\n    }\n    [Symbol.iterator]() {\n        return function* () {\n            yield* this._vector;\n        }.bind(this)();\n    }\n}\nexport default Vector;\n","import SequentialContainer from './Base';\nimport { initContainer, IteratorType } from '@/container/ContainerBase';\nimport { RandomIterator } from '@/container/SequentialContainer/Base/RandomIterator';\nimport $checkWithinAccessParams from '@/utils/checkParams.macro';\n\nclass VectorIterator<T> extends RandomIterator<T> {\n  container: Vector<T>;\n  constructor(node: number, container: Vector<T>, iteratorType?: IteratorType) {\n    super(node, iteratorType);\n    this.container = container;\n  }\n  copy() {\n    return new VectorIterator<T>(this._node, this.container, this.iteratorType);\n  }\n  // @ts-ignore\n  equals(iter: VectorIterator<T>): boolean;\n}\n\nexport type { VectorIterator };\n\nclass Vector<T> extends SequentialContainer<T> {\n  /**\n   * @internal\n   */\n  private readonly _vector: T[];\n  /**\n   * @param container - Initialize container, must have a forEach function.\n   * @param copy - When the container is an array, you can choose to directly operate on the original object of\n   *               the array or perform a shallow copy. The default is shallow copy.\n   */\n  constructor(container: initContainer<T> = [], copy = true) {\n    super();\n    if (Array.isArray(container)) {\n      this._vector = copy ? [...container] : container;\n      this._length = container.length;\n    } else {\n      this._vector = [];\n      const self = this;\n      container.forEach(function (el) {\n        self.pushBack(el);\n      });\n    }\n  }\n  clear() {\n    this._length = 0;\n    this._vector.length = 0;\n  }\n  begin() {\n    return new VectorIterator<T>(0, this);\n  }\n  end() {\n    return new VectorIterator<T>(this._length, this);\n  }\n  rBegin() {\n    return new VectorIterator<T>(this._length - 1, this, IteratorType.REVERSE);\n  }\n  rEnd() {\n    return new VectorIterator<T>(-1, this, IteratorType.REVERSE);\n  }\n  front(): T | undefined {\n    return this._vector[0];\n  }\n  back(): T | undefined {\n    return this._vector[this._length - 1];\n  }\n  getElementByPos(pos: number) {\n    $checkWithinAccessParams!(pos, 0, this._length - 1);\n    return this._vector[pos];\n  }\n  eraseElementByPos(pos: number) {\n    $checkWithinAccessParams!(pos, 0, this._length - 1);\n    this._vector.splice(pos, 1);\n    this._length -= 1;\n    return this._length;\n  }\n  eraseElementByValue(value: T) {\n    let index = 0;\n    for (let i = 0; i < this._length; ++i) {\n      if (this._vector[i] !== value) {\n        this._vector[index++] = this._vector[i];\n      }\n    }\n    this._length = this._vector.length = index;\n    return this._length;\n  }\n  eraseElementByIterator(iter: VectorIterator<T>) {\n    const _node = iter._node;\n    iter = iter.next();\n    this.eraseElementByPos(_node);\n    return iter;\n  }\n  pushBack(element: T) {\n    this._vector.push(element);\n    this._length += 1;\n    return this._length;\n  }\n  popBack() {\n    if (this._length === 0) return;\n    this._length -= 1;\n    return this._vector.pop();\n  }\n  setElementByPos(pos: number, element: T) {\n    $checkWithinAccessParams!(pos, 0, this._length - 1);\n    this._vector[pos] = element;\n  }\n  insert(pos: number, element: T, num = 1) {\n    $checkWithinAccessParams!(pos, 0, this._length);\n    this._vector.splice(pos, 0, ...new Array<T>(num).fill(element));\n    this._length += num;\n    return this._length;\n  }\n  find(element: T) {\n    for (let i = 0; i < this._length; ++i) {\n      if (this._vector[i] === element) {\n        return new VectorIterator<T>(i, this);\n      }\n    }\n    return this.end();\n  }\n  reverse() {\n    this._vector.reverse();\n  }\n  unique() {\n    let index = 1;\n    for (let i = 1; i < this._length; ++i) {\n      if (this._vector[i] !== this._vector[i - 1]) {\n        this._vector[index++] = this._vector[i];\n      }\n    }\n    this._length = this._vector.length = index;\n    return this._length;\n  }\n  sort(cmp?: (x: T, y: T) => number) {\n    this._vector.sort(cmp);\n  }\n  forEach(callback: (element: T, index: number, vector: Vector<T>) => void) {\n    for (let i = 0; i < this._length; ++i) {\n      callback(this._vector[i], i, this);\n    }\n  }\n  [Symbol.iterator]() {\n    return function * (this: Vector<T>) {\n      yield * this._vector;\n    }.bind(this)();\n  }\n}\n\nexport default Vector;\n"]}

package/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;

package/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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["container/TreeContainer/Base/TreeIterator.js","../../src/container/TreeContainer/Base/TreeIterator.ts"],"names":["Object","defineProperty","exports","value","default","_ContainerBase","require","_throwError","TreeIterator","ContainerIterator","constructor","node","header","iteratorType","super","this","_node","_header","pre","_left","throwIteratorAccessError","_pre","next","_next","_right","index","root","_parent","_subTreeSize","_default"],"mappings":"AAAA;;AAEAA,OAAOC,eAAeC,SAAS,KAAc;IAC3CC,OAAO;;;AAETD,QAAQE,eAAe;;ACHvB,IAAAC,iBAAAC,QAAA;;AAEA,IAAAC,cAAAD,QAAA;;AAEA,MAAeE,qBAA2BC,eAAAA;IAaxCC,YACEC,GACAC,GACAC;QAEAC,MAAMD;QACNE,KAAKC,IAAQL;QACbI,KAAKE,IAAUL;QACf,IAAIG,KAAKF,iBAAY,GAA0B;YAC7CE,KAAKG,MAAM;gBACT,IAAIH,KAAKC,MAAUD,KAAKE,EAAQE,GAAO;qBACrC,GAAAC,YAAAA;ADhBM;gBCkBRL,KAAKC,IAAQD,KAAKC,EAAMK;gBACxB,OAAON;ADhBH;YCmBNA,KAAKO,OAAO;gBACV,IAAIP,KAAKC,MAAUD,KAAKE,GAAS;qBAC/B,GAAAG,YAAAA;ADjBM;gBCmBRL,KAAKC,IAAQD,KAAKC,EAAMO;gBACxB,OAAOR;ADjBH;AACJ,eCkBG;YACLA,KAAKG,MAAM;gBACT,IAAIH,KAAKC,MAAUD,KAAKE,EAAQO,GAAQ;qBACtC,GAAAJ,YAAAA;ADhBM;gBCkBRL,KAAKC,IAAQD,KAAKC,EAAMO;gBACxB,OAAOR;ADhBH;YCmBNA,KAAKO,OAAO;gBACV,IAAIP,KAAKC,MAAUD,KAAKE,GAAS;qBAC/B,GAAAG,YAAAA;ADjBM;gBCmBRL,KAAKC,IAAQD,KAAKC,EAAMK;gBACxB,OAAON;ADjBH;AACJ;AACJ;IC4BEU;QACF,IAAIT,IAAQD,KAAKC;QACjB,MAAMU,IAAOX,KAAKE,EAAQU;QAC1B,IAAIX,MAAUD,KAAKE,GAAS;YAC1B,IAAIS,GAAM;gBACR,OAAOA,EAAKE,KAAe;ADjBvB;YCmBN,OAAO;ADjBL;QCmBJ,IAAIH,IAAQ;QACZ,IAAIT,EAAMG,GAAO;YACfM,KAAUT,EAAMG,EAAoCS;ADjBlD;QCmBJ,OAAOZ,MAAUU,GAAM;YACrB,MAAMC,IAAUX,EAAMW;YACtB,IAAIX,MAAUW,EAAQH,GAAQ;gBAC5BC,KAAS;gBACT,IAAIE,EAAQR,GAAO;oBACjBM,KAAUE,EAAQR,EAAoCS;ADjBhD;AACJ;YCmBNZ,IAAQW;ADjBN;QCmBJ,OAAOF;ADjBP;;;ACuBH,IAAAI,WAEcrB;;AAAYN,QAAAE,UAAAyB","file":"TreeIterator.js","sourcesContent":["import { ContainerIterator } from \"../../ContainerBase\";\nimport { throwIteratorAccessError } from \"../../../utils/throwError\";\nclass TreeIterator extends ContainerIterator {\n    /**\n     * @internal\n     */\n    constructor(node, header, iteratorType) {\n        super(iteratorType);\n        this._node = node;\n        this._header = header;\n        if (this.iteratorType === 0 /* IteratorType.NORMAL */) {\n            this.pre = function () {\n                if (this._node === this._header._left) {\n                    throwIteratorAccessError();\n                }\n                this._node = this._node._pre();\n                return this;\n            };\n            this.next = function () {\n                if (this._node === this._header) {\n                    throwIteratorAccessError();\n                }\n                this._node = this._node._next();\n                return this;\n            };\n        }\n        else {\n            this.pre = function () {\n                if (this._node === this._header._right) {\n                    throwIteratorAccessError();\n                }\n                this._node = this._node._next();\n                return this;\n            };\n            this.next = function () {\n                if (this._node === this._header) {\n                    throwIteratorAccessError();\n                }\n                this._node = this._node._pre();\n                return this;\n            };\n        }\n    }\n    /**\n     * @description Get the sequential index of the iterator in the tree container.<br/>\n     *              <strong>Note:</strong>\n     *              This function only takes effect when the specified tree container `enableIndex = true`.\n     * @returns The index subscript of the node in the tree.\n     * @example\n     * const st = new OrderedSet([1, 2, 3], true);\n     * console.log(st.begin().next().index);  // 1\n     */\n    get index() {\n        let _node = this._node;\n        const root = this._header._parent;\n        if (_node === this._header) {\n            if (root) {\n                return root._subTreeSize - 1;\n            }\n            return 0;\n        }\n        let index = 0;\n        if (_node._left) {\n            index += _node._left._subTreeSize;\n        }\n        while (_node !== root) {\n            const _parent = _node._parent;\n            if (_node === _parent._right) {\n                index += 1;\n                if (_parent._left) {\n                    index += _parent._left._subTreeSize;\n                }\n            }\n            _node = _parent;\n        }\n        return index;\n    }\n}\nexport default TreeIterator;\n","import { TreeNode } from './TreeNode';\nimport type { TreeNodeEnableIndex } from './TreeNode';\nimport { ContainerIterator, IteratorType } from '@/container/ContainerBase';\nimport TreeContainer from '@/container/TreeContainer/Base/index';\nimport { throwIteratorAccessError } from '@/utils/throwError';\n\nabstract class TreeIterator<K, V> extends ContainerIterator<K | [K, V]> {\n  abstract readonly container: TreeContainer<K, V>;\n  /**\n   * @internal\n   */\n  _node: TreeNode<K, V>;\n  /**\n   * @internal\n   */\n  protected _header: TreeNode<K, V>;\n  /**\n   * @internal\n   */\n  protected constructor(\n    node: TreeNode<K, V>,\n    header: TreeNode<K, V>,\n    iteratorType?: IteratorType\n  ) {\n    super(iteratorType);\n    this._node = node;\n    this._header = header;\n    if (this.iteratorType === IteratorType.NORMAL) {\n      this.pre = function () {\n        if (this._node === this._header._left) {\n          throwIteratorAccessError();\n        }\n        this._node = this._node._pre();\n        return this;\n      };\n\n      this.next = function () {\n        if (this._node === this._header) {\n          throwIteratorAccessError();\n        }\n        this._node = this._node._next();\n        return this;\n      };\n    } else {\n      this.pre = function () {\n        if (this._node === this._header._right) {\n          throwIteratorAccessError();\n        }\n        this._node = this._node._next();\n        return this;\n      };\n\n      this.next = function () {\n        if (this._node === this._header) {\n          throwIteratorAccessError();\n        }\n        this._node = this._node._pre();\n        return this;\n      };\n    }\n  }\n  /**\n   * @description Get the sequential index of the iterator in the tree container.<br/>\n   *              <strong>Note:</strong>\n   *              This function only takes effect when the specified tree container `enableIndex = true`.\n   * @returns The index subscript of the node in the tree.\n   * @example\n   * const st = new OrderedSet([1, 2, 3], true);\n   * console.log(st.begin().next().index);  // 1\n   */\n  get index() {\n    let _node = this._node as TreeNodeEnableIndex<K, V>;\n    const root = this._header._parent as TreeNodeEnableIndex<K, V>;\n    if (_node === this._header) {\n      if (root) {\n        return root._subTreeSize - 1;\n      }\n      return 0;\n    }\n    let index = 0;\n    if (_node._left) {\n      index += (_node._left as TreeNodeEnableIndex<K, V>)._subTreeSize;\n    }\n    while (_node !== root) {\n      const _parent = _node._parent as TreeNodeEnableIndex<K, V>;\n      if (_node === _parent._right) {\n        index += 1;\n        if (_parent._left) {\n          index += (_parent._left as TreeNodeEnableIndex<K, V>)._subTreeSize;\n        }\n      }\n      _node = _parent;\n    }\n    return index;\n  }\n  // @ts-ignore\n  pre(): this;\n  // @ts-ignore\n  next(): this;\n}\n\nexport default TreeIterator;\n"]}

package/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;
+}

package/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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["container/TreeContainer/Base/TreeNode.js","../../src/container/TreeContainer/Base/TreeNode.ts"],"names":["Object","defineProperty","exports","value","TreeNodeEnableIndex","TreeNode","constructor","key","this","_color","_key","undefined","_value","_left","_right","_parent","_pre","preNode","pre","_next","nextNode","_rotateLeft","PP","V","R","_rotateRight","F","K","super","arguments","_subTreeSize","parent","_recount"],"mappings":"AAAA;;AAEAA,OAAOC,eAAeC,SAAS,KAAc;IAC3CC,OAAO;;;AAETD,QAAQE,sBAAsBF,QAAQG,gBAAgB;;ACAhD,MAAOA;IAOXC,YAAYC,GAASJ;QANrBK,KAAAC,KAAM;QACND,KAAAE,IAAsBC;QACtBH,KAAAI,IAAwBD;QACxBH,KAAAK,IAAoCF;QACpCH,KAAAM,IAAqCH;QACrCH,KAAAO,KAAsCJ;QAEpCH,KAAKE,IAAOH;QACZC,KAAKI,IAAST;ADJd;ICUFa;QACE,IAAIC,IAA0BT;QAC9B,IACES,EAAQR,OAAM,KACdQ,EAAQF,GAASA,OAAYE,GAC7B;YACAA,IAAUA,EAAQH;ADNhB,eCOG,IAAIG,EAAQJ,GAAO;YACxBI,IAAUA,EAAQJ;YAClB,OAAOI,EAAQH,GAAQ;gBACrBG,IAAUA,EAAQH;ADLd;AACJ,eCMG;YACL,IAAII,IAAMD,EAAQF;YAClB,OAAOG,EAAIL,MAAUI,GAAS;gBAC5BA,IAAUC;gBACVA,IAAMD,EAAQF;ADJV;YCMNE,IAAUC;ADJR;QCMJ,OAAOD;ADJP;ICUFE;QACE,IAAIC,IAA2BZ;QAC/B,IAAIY,EAASN,GAAQ;YACnBM,IAAWA,EAASN;YACpB,OAAOM,EAASP,GAAO;gBACrBO,IAAWA,EAASP;ADJhB;YCMN,OAAOO;ADJL,eCKG;YACL,IAAIF,IAAME,EAASL;YACnB,OAAOG,EAAIJ,MAAWM,GAAU;gBAC9BA,IAAWF;gBACXA,IAAME,EAASL;ADHX;YCKN,IAAIK,EAASN,MAAWI,GAAK;gBAC3B,OAAOA;ADHH,mBCIC,OAAOE;ADDZ;AACJ;ICOFC;QACE,MAAMC,IAAKd,KAAKO;QAChB,MAAMQ,IAAIf,KAAKM;QACf,MAAMU,IAAID,EAAEV;QAEZ,IAAIS,EAAGP,OAAYP,MAAMc,EAAGP,KAAUQ,QACjC,IAAID,EAAGT,MAAUL,MAAMc,EAAGT,IAAQU,QAClCD,EAAGR,IAASS;QAEjBA,EAAER,KAAUO;QACZC,EAAEV,IAAQL;QAEVA,KAAKO,KAAUQ;QACff,KAAKM,IAASU;QAEd,IAAIA,GAAGA,EAAET,KAAUP;QAEnB,OAAOe;ADFP;ICQFE;QACE,MAAMH,IAAKd,KAAKO;QAChB,MAAMW,IAAIlB,KAAKK;QACf,MAAMc,IAAID,EAAEZ;QAEZ,IAAIQ,EAAGP,OAAYP,MAAMc,EAAGP,KAAUW,QACjC,IAAIJ,EAAGT,MAAUL,MAAMc,EAAGT,IAAQa,QAClCJ,EAAGR,IAASY;QAEjBA,EAAEX,KAAUO;QACZI,EAAEZ,IAASN;QAEXA,KAAKO,KAAUW;QACflB,KAAKK,IAAQc;QAEb,IAAIA,GAAGA,EAAEZ,KAAUP;QAEnB,OAAOkB;ADHP;;;ACKHxB,QAAAG,WAAAA;;AAEK,MAAOD,4BAAkCC;IAA/CC;QDHQsB,SAASC;QCIfrB,KAAAsB,KAAe;AA8BjB;IAzBET;QACE,MAAMU,IAASH,MAAMP;QACrBb,KAAKwB;QACLD,EAAOC;QACP,OAAOD;ADDP;ICOFN;QACE,MAAMM,IAASH,MAAMH;QACrBjB,KAAKwB;QACLD,EAAOC;QACP,OAAOD;ADDP;ICGFC;QACExB,KAAKsB,KAAe;QACpB,IAAItB,KAAKK,GAAO;YACdL,KAAKsB,MAAiBtB,KAAKK,EAAoCiB;ADD7D;QCGJ,IAAItB,KAAKM,GAAQ;YACfN,KAAKsB,MAAiBtB,KAAKM,EAAqCgB;ADD9D;AACJ;;;ACGH5B,QAAAE,sBAAAA","file":"TreeNode.js","sourcesContent":["export class TreeNode {\n    constructor(key, value) {\n        this._color = 1 /* TreeNodeColor.RED */;\n        this._key = undefined;\n        this._value = undefined;\n        this._left = undefined;\n        this._right = undefined;\n        this._parent = undefined;\n        this._key = key;\n        this._value = value;\n    }\n    /**\n     * @description Get the pre node.\n     * @returns TreeNode about the pre node.\n     */\n    _pre() {\n        let preNode = this;\n        if (preNode._color === 1 /* TreeNodeColor.RED */ &&\n            preNode._parent._parent === preNode) {\n            preNode = preNode._right;\n        }\n        else if (preNode._left) {\n            preNode = preNode._left;\n            while (preNode._right) {\n                preNode = preNode._right;\n            }\n        }\n        else {\n            let pre = preNode._parent;\n            while (pre._left === preNode) {\n                preNode = pre;\n                pre = preNode._parent;\n            }\n            preNode = pre;\n        }\n        return preNode;\n    }\n    /**\n     * @description Get the next node.\n     * @returns TreeNode about the next node.\n     */\n    _next() {\n        let nextNode = this;\n        if (nextNode._right) {\n            nextNode = nextNode._right;\n            while (nextNode._left) {\n                nextNode = nextNode._left;\n            }\n            return nextNode;\n        }\n        else {\n            let pre = nextNode._parent;\n            while (pre._right === nextNode) {\n                nextNode = pre;\n                pre = nextNode._parent;\n            }\n            if (nextNode._right !== pre) {\n                return pre;\n            }\n            else\n                return nextNode;\n        }\n    }\n    /**\n     * @description Rotate left.\n     * @returns TreeNode about moved to original position after rotation.\n     */\n    _rotateLeft() {\n        const PP = this._parent;\n        const V = this._right;\n        const R = V._left;\n        if (PP._parent === this)\n            PP._parent = V;\n        else if (PP._left === this)\n            PP._left = V;\n        else\n            PP._right = V;\n        V._parent = PP;\n        V._left = this;\n        this._parent = V;\n        this._right = R;\n        if (R)\n            R._parent = this;\n        return V;\n    }\n    /**\n     * @description Rotate right.\n     * @returns TreeNode about moved to original position after rotation.\n     */\n    _rotateRight() {\n        const PP = this._parent;\n        const F = this._left;\n        const K = F._right;\n        if (PP._parent === this)\n            PP._parent = F;\n        else if (PP._left === this)\n            PP._left = F;\n        else\n            PP._right = F;\n        F._parent = PP;\n        F._right = this;\n        this._parent = F;\n        this._left = K;\n        if (K)\n            K._parent = this;\n        return F;\n    }\n}\nexport class TreeNodeEnableIndex extends TreeNode {\n    constructor() {\n        super(...arguments);\n        this._subTreeSize = 1;\n    }\n    /**\n     * @description Rotate left and do recount.\n     * @returns TreeNode about moved to original position after rotation.\n     */\n    _rotateLeft() {\n        const parent = super._rotateLeft();\n        this._recount();\n        parent._recount();\n        return parent;\n    }\n    /**\n     * @description Rotate right and do recount.\n     * @returns TreeNode about moved to original position after rotation.\n     */\n    _rotateRight() {\n        const parent = super._rotateRight();\n        this._recount();\n        parent._recount();\n        return parent;\n    }\n    _recount() {\n        this._subTreeSize = 1;\n        if (this._left) {\n            this._subTreeSize += this._left._subTreeSize;\n        }\n        if (this._right) {\n            this._subTreeSize += this._right._subTreeSize;\n        }\n    }\n}\n","export const enum TreeNodeColor {\n  RED = 1,\n  BLACK = 0\n}\n\nexport class TreeNode<K, V> {\n  _color = TreeNodeColor.RED;\n  _key: K | undefined = undefined;\n  _value: V | undefined = undefined;\n  _left: TreeNode<K, V> | undefined = undefined;\n  _right: TreeNode<K, V> | undefined = undefined;\n  _parent: TreeNode<K, V> | undefined = undefined;\n  constructor(key?: K, value?: V) {\n    this._key = key;\n    this._value = value;\n  }\n  /**\n   * @description Get the pre node.\n   * @returns TreeNode about the pre node.\n   */\n  _pre() {\n    let preNode: TreeNode<K, V> = this;\n    if (\n      preNode._color === TreeNodeColor.RED &&\n      preNode._parent!._parent === preNode\n    ) {\n      preNode = preNode._right!;\n    } else if (preNode._left) {\n      preNode = preNode._left;\n      while (preNode._right) {\n        preNode = preNode._right;\n      }\n    } else {\n      let pre = preNode._parent!;\n      while (pre._left === preNode) {\n        preNode = pre;\n        pre = preNode._parent!;\n      }\n      preNode = pre;\n    }\n    return preNode;\n  }\n  /**\n   * @description Get the next node.\n   * @returns TreeNode about the next node.\n   */\n  _next() {\n    let nextNode: TreeNode<K, V> = this;\n    if (nextNode._right) {\n      nextNode = nextNode._right;\n      while (nextNode._left) {\n        nextNode = nextNode._left;\n      }\n      return nextNode;\n    } else {\n      let pre = nextNode._parent!;\n      while (pre._right === nextNode) {\n        nextNode = pre;\n        pre = nextNode._parent!;\n      }\n      if (nextNode._right !== pre) {\n        return pre;\n      } else return nextNode;\n    }\n  }\n  /**\n   * @description Rotate left.\n   * @returns TreeNode about moved to original position after rotation.\n   */\n  _rotateLeft() {\n    const PP = this._parent!;\n    const V = this._right!;\n    const R = V._left;\n\n    if (PP._parent === this) PP._parent = V;\n    else if (PP._left === this) PP._left = V;\n    else PP._right = V;\n\n    V._parent = PP;\n    V._left = this;\n\n    this._parent = V;\n    this._right = R;\n\n    if (R) R._parent = this;\n\n    return V;\n  }\n  /**\n   * @description Rotate right.\n   * @returns TreeNode about moved to original position after rotation.\n   */\n  _rotateRight() {\n    const PP = this._parent!;\n    const F = this._left!;\n    const K = F._right;\n\n    if (PP._parent === this) PP._parent = F;\n    else if (PP._left === this) PP._left = F;\n    else PP._right = F;\n\n    F._parent = PP;\n    F._right = this;\n\n    this._parent = F;\n    this._left = K;\n\n    if (K) K._parent = this;\n\n    return F;\n  }\n}\n\nexport class TreeNodeEnableIndex<K, V> extends TreeNode<K, V> {\n  _subTreeSize = 1;\n  /**\n   * @description Rotate left and do recount.\n   * @returns TreeNode about moved to original position after rotation.\n   */\n  _rotateLeft() {\n    const parent = super._rotateLeft() as TreeNodeEnableIndex<K, V>;\n    this._recount();\n    parent._recount();\n    return parent;\n  }\n  /**\n   * @description Rotate right and do recount.\n   * @returns TreeNode about moved to original position after rotation.\n   */\n  _rotateRight() {\n    const parent = super._rotateRight() as TreeNodeEnableIndex<K, V>;\n    this._recount();\n    parent._recount();\n    return parent;\n  }\n  _recount() {\n    this._subTreeSize = 1;\n    if (this._left) {\n      this._subTreeSize += (this._left as TreeNodeEnableIndex<K, V>)._subTreeSize;\n    }\n    if (this._right) {\n      this._subTreeSize += (this._right as TreeNodeEnableIndex<K, V>)._subTreeSize;\n    }\n  }\n}\n"]}

package/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;