nodejs-insta-private-api-mqtt 1.3.24 → 1.3.26

package/dist/node_modules/js-sdsl/dist/umd/js-sdsl.js

@@ -1,3154 +0,0 @@
-/*!
- * js-sdsl v4.3.0
- * https://github.com/js-sdsl/js-sdsl
- * (c) 2021-present ZLY201 <zilongyao1366@gmail.com>
- * MIT license
- */
-
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.sdsl = {}));
-})(this, (function (exports) { 'use strict';
-
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise */
-
-    var extendStatics = function (d, b) {
-      extendStatics = Object.setPrototypeOf || {
-        __proto__: []
-      } instanceof Array && function (d, b) {
-        d.__proto__ = b;
-      } || function (d, b) {
-        for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
-      };
-      return extendStatics(d, b);
-    };
-    function __extends(d, b) {
-      if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-      extendStatics(d, b);
-      function __() {
-        this.constructor = d;
-      }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    }
-    function __generator(thisArg, body) {
-      var _ = {
-          label: 0,
-          sent: function () {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-          },
-          trys: [],
-          ops: []
-        },
-        f,
-        y,
-        t,
-        g;
-      return g = {
-        next: verb(0),
-        "throw": verb(1),
-        "return": verb(2)
-      }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
-        return this;
-      }), g;
-      function verb(n) {
-        return function (v) {
-          return step([n, v]);
-        };
-      }
-      function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-          if (y = 0, t) op = [op[0] & 2, t.value];
-          switch (op[0]) {
-            case 0:
-            case 1:
-              t = op;
-              break;
-            case 4:
-              _.label++;
-              return {
-                value: op[1],
-                done: false
-              };
-            case 5:
-              _.label++;
-              y = op[1];
-              op = [0];
-              continue;
-            case 7:
-              op = _.ops.pop();
-              _.trys.pop();
-              continue;
-            default:
-              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                _ = 0;
-                continue;
-              }
-              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                _.label = op[1];
-                break;
-              }
-              if (op[0] === 6 && _.label < t[1]) {
-                _.label = t[1];
-                t = op;
-                break;
-              }
-              if (t && _.label < t[2]) {
-                _.label = t[2];
-                _.ops.push(op);
-                break;
-              }
-              if (t[2]) _.ops.pop();
-              _.trys.pop();
-              continue;
-          }
-          op = body.call(thisArg, _);
-        } catch (e) {
-          op = [6, e];
-          y = 0;
-        } finally {
-          f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-          value: op[0] ? op[1] : void 0,
-          done: true
-        };
-      }
-    }
-    function __values(o) {
-      var s = typeof Symbol === "function" && Symbol.iterator,
-        m = s && o[s],
-        i = 0;
-      if (m) return m.call(o);
-      if (o && typeof o.length === "number") return {
-        next: function () {
-          if (o && i >= o.length) o = void 0;
-          return {
-            value: o && o[i++],
-            done: !o
-          };
-        }
-      };
-      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-    }
-    function __read(o, n) {
-      var m = typeof Symbol === "function" && o[Symbol.iterator];
-      if (!m) return o;
-      var i = m.call(o),
-        r,
-        ar = [],
-        e;
-      try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-      } catch (error) {
-        e = {
-          error: error
-        };
-      } finally {
-        try {
-          if (r && !r.done && (m = i["return"])) m.call(i);
-        } finally {
-          if (e) throw e.error;
-        }
-      }
-      return ar;
-    }
-    function __spreadArray(to, from, pack) {
-      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
-        }
-      }
-      return to.concat(ar || Array.prototype.slice.call(from));
-    }
-
-    var ContainerIterator = /** @class */function () {
-      /**
-       * @internal
-       */
-      function ContainerIterator(iteratorType) {
-        if (iteratorType === void 0) {
-          iteratorType = 0 /* IteratorType.NORMAL */;
-        }
-        this.iteratorType = iteratorType;
-      }
-      /**
-       * @param iter - The other iterator you want to compare.
-       * @returns Whether this equals to obj.
-       * @example
-       * container.find(1).equals(container.end());
-       */
-      ContainerIterator.prototype.equals = function (iter) {
-        return this._node === iter._node;
-      };
-      return ContainerIterator;
-    }();
-    var Base = /** @class */function () {
-      function Base() {
-        /**
-         * @description Container's size.
-         * @internal
-         */
-        this._length = 0;
-      }
-      Object.defineProperty(Base.prototype, "length", {
-        /**
-         * @returns The size of the container.
-         * @example
-         * const container = new Vector([1, 2]);
-         * console.log(container.length); // 2
-         */
-        get: function () {
-          return this._length;
-        },
-        enumerable: false,
-        configurable: true
-      });
-      /**
-       * @returns The size of the container.
-       * @example
-       * const container = new Vector([1, 2]);
-       * console.log(container.size()); // 2
-       */
-      Base.prototype.size = function () {
-        return this._length;
-      };
-      /**
-       * @returns Whether the container is empty.
-       * @example
-       * container.clear();
-       * console.log(container.empty());  // true
-       */
-      Base.prototype.empty = function () {
-        return this._length === 0;
-      };
-      return Base;
-    }();
-    var Container = /** @class */function (_super) {
-      __extends(Container, _super);
-      function Container() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      return Container;
-    }(Base);
-
-    var Stack = /** @class */function (_super) {
-      __extends(Stack, _super);
-      function Stack(container) {
-        if (container === void 0) {
-          container = [];
-        }
-        var _this = _super.call(this) || this;
-        /**
-         * @internal
-         */
-        _this._stack = [];
-        var self = _this;
-        container.forEach(function (el) {
-          self.push(el);
-        });
-        return _this;
-      }
-      Stack.prototype.clear = function () {
-        this._length = 0;
-        this._stack = [];
-      };
-      /**
-       * @description Insert element to stack's end.
-       * @description The element you want to push to the back.
-       * @returns The container length after erasing.
-       */
-      Stack.prototype.push = function (element) {
-        this._stack.push(element);
-        this._length += 1;
-        return this._length;
-      };
-      /**
-       * @description Removes the end element.
-       * @returns The element you popped.
-       */
-      Stack.prototype.pop = function () {
-        if (this._length === 0) return;
-        this._length -= 1;
-        return this._stack.pop();
-      };
-      /**
-       * @description Accesses the end element.
-       * @returns The last element.
-       */
-      Stack.prototype.top = function () {
-        return this._stack[this._length - 1];
-      };
-      return Stack;
-    }(Base);
-
-    var Queue = /** @class */function (_super) {
-      __extends(Queue, _super);
-      function Queue(container) {
-        if (container === void 0) {
-          container = [];
-        }
-        var _this = _super.call(this) || this;
-        /**
-         * @internal
-         */
-        _this._first = 0;
-        /**
-         * @internal
-         */
-        _this._queue = [];
-        var self = _this;
-        container.forEach(function (el) {
-          self.push(el);
-        });
-        return _this;
-      }
-      Queue.prototype.clear = function () {
-        this._queue = [];
-        this._length = this._first = 0;
-      };
-      /**
-       * @description Inserts element to queue's end.
-       * @param element - The element you want to push to the front.
-       * @returns The container length after pushing.
-       */
-      Queue.prototype.push = function (element) {
-        var capacity = this._queue.length;
-        if (this._first / capacity > 0.5 /* QUEUE_CONSTANT.ALLOCATE_SIGMA */ && this._first + this._length >= capacity && capacity > 4096 /* QUEUE_CONSTANT.MIN_ALLOCATE_SIZE */) {
-          var length_1 = this._length;
-          for (var i = 0; i < length_1; ++i) {
-            this._queue[i] = this._queue[this._first + i];
-          }
-          this._first = 0;
-          this._queue[this._length] = element;
-        } else this._queue[this._first + this._length] = element;
-        return ++this._length;
-      };
-      /**
-       * @description Removes the first element.
-       * @returns The element you popped.
-       */
-      Queue.prototype.pop = function () {
-        if (this._length === 0) return;
-        var el = this._queue[this._first++];
-        this._length -= 1;
-        return el;
-      };
-      /**
-       * @description Access the first element.
-       * @returns The first element.
-       */
-      Queue.prototype.front = function () {
-        if (this._length === 0) return;
-        return this._queue[this._first];
-      };
-      return Queue;
-    }(Base);
-
-    var PriorityQueue = /** @class */function (_super) {
-      __extends(PriorityQueue, _super);
-      /**
-       * @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);
-       */
-      function PriorityQueue(container, cmp, copy) {
-        if (container === void 0) {
-          container = [];
-        }
-        if (cmp === void 0) {
-          cmp = function (x, y) {
-            if (x > y) return -1;
-            if (x < y) return 1;
-            return 0;
-          };
-        }
-        if (copy === void 0) {
-          copy = true;
-        }
-        var _this = _super.call(this) || this;
-        _this._cmp = cmp;
-        if (Array.isArray(container)) {
-          _this._priorityQueue = copy ? __spreadArray([], __read(container), false) : container;
-        } else {
-          _this._priorityQueue = [];
-          var self_1 = _this;
-          container.forEach(function (el) {
-            self_1._priorityQueue.push(el);
-          });
-        }
-        _this._length = _this._priorityQueue.length;
-        var halfLength = _this._length >> 1;
-        for (var parent_1 = _this._length - 1 >> 1; parent_1 >= 0; --parent_1) {
-          _this._pushDown(parent_1, halfLength);
-        }
-        return _this;
-      }
-      /**
-       * @internal
-       */
-      PriorityQueue.prototype._pushUp = function (pos) {
-        var item = this._priorityQueue[pos];
-        while (pos > 0) {
-          var parent_2 = pos - 1 >> 1;
-          var parentItem = this._priorityQueue[parent_2];
-          if (this._cmp(parentItem, item) <= 0) break;
-          this._priorityQueue[pos] = parentItem;
-          pos = parent_2;
-        }
-        this._priorityQueue[pos] = item;
-      };
-      /**
-       * @internal
-       */
-      PriorityQueue.prototype._pushDown = function (pos, halfLength) {
-        var item = this._priorityQueue[pos];
-        while (pos < halfLength) {
-          var left = pos << 1 | 1;
-          var right = left + 1;
-          var minItem = this._priorityQueue[left];
-          if (right < this._length && this._cmp(minItem, this._priorityQueue[right]) > 0) {
-            left = right;
-            minItem = this._priorityQueue[right];
-          }
-          if (this._cmp(minItem, item) >= 0) break;
-          this._priorityQueue[pos] = minItem;
-          pos = left;
-        }
-        this._priorityQueue[pos] = item;
-      };
-      PriorityQueue.prototype.clear = function () {
-        this._length = 0;
-        this._priorityQueue.length = 0;
-      };
-      /**
-       * @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);
-       */
-      PriorityQueue.prototype.push = function (item) {
-        this._priorityQueue.push(item);
-        this._pushUp(this._length);
-        this._length += 1;
-      };
-      /**
-       * @description Removes the top element.
-       * @returns The element you popped.
-       * @example
-       * queue.pop();
-       */
-      PriorityQueue.prototype.pop = function () {
-        if (this._length === 0) return;
-        var value = this._priorityQueue[0];
-        var last = this._priorityQueue.pop();
-        this._length -= 1;
-        if (this._length) {
-          this._priorityQueue[0] = last;
-          this._pushDown(0, this._length >> 1);
-        }
-        return value;
-      };
-      /**
-       * @description Accesses the top element.
-       * @example
-       * const top = queue.top();
-       */
-      PriorityQueue.prototype.top = function () {
-        return this._priorityQueue[0];
-      };
-      /**
-       * @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
-       */
-      PriorityQueue.prototype.find = function (item) {
-        return this._priorityQueue.indexOf(item) >= 0;
-      };
-      /**
-       * @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);
-       */
-      PriorityQueue.prototype.remove = function (item) {
-        var index = this._priorityQueue.indexOf(item);
-        if (index < 0) return false;
-        if (index === 0) {
-          this.pop();
-        } else if (index === this._length - 1) {
-          this._priorityQueue.pop();
-          this._length -= 1;
-        } else {
-          this._priorityQueue.splice(index, 1, this._priorityQueue.pop());
-          this._length -= 1;
-          this._pushUp(index);
-          this._pushDown(index, this._length >> 1);
-        }
-        return true;
-      };
-      /**
-       * @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);
-       */
-      PriorityQueue.prototype.updateItem = function (item) {
-        var index = this._priorityQueue.indexOf(item);
-        if (index < 0) return false;
-        this._pushUp(index);
-        this._pushDown(index, this._length >> 1);
-        return true;
-      };
-      /**
-       * @returns Return a copy array of heap.
-       * @example
-       * const arr = queue.toArray();
-       */
-      PriorityQueue.prototype.toArray = function () {
-        return __spreadArray([], __read(this._priorityQueue), false);
-      };
-      return PriorityQueue;
-    }(Base);
-
-    var SequentialContainer = /** @class */function (_super) {
-      __extends(SequentialContainer, _super);
-      function SequentialContainer() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      return SequentialContainer;
-    }(Container);
-
-    /**
-     * @description Throw an iterator access error.
-     * @internal
-     */
-    function throwIteratorAccessError() {
-      throw new RangeError('Iterator access denied!');
-    }
-
-    var RandomIterator = /** @class */function (_super) {
-      __extends(RandomIterator, _super);
-      /**
-       * @internal
-       */
-      function RandomIterator(index, iteratorType) {
-        var _this = _super.call(this, iteratorType) || this;
-        _this._node = index;
-        if (_this.iteratorType === 0 /* IteratorType.NORMAL */) {
-          _this.pre = function () {
-            if (this._node === 0) {
-              throwIteratorAccessError();
-            }
-            this._node -= 1;
-            return this;
-          };
-          _this.next = function () {
-            if (this._node === this.container.size()) {
-              throwIteratorAccessError();
-            }
-            this._node += 1;
-            return this;
-          };
-        } else {
-          _this.pre = function () {
-            if (this._node === this.container.size() - 1) {
-              throwIteratorAccessError();
-            }
-            this._node += 1;
-            return this;
-          };
-          _this.next = function () {
-            if (this._node === -1) {
-              throwIteratorAccessError();
-            }
-            this._node -= 1;
-            return this;
-          };
-        }
-        return _this;
-      }
-      Object.defineProperty(RandomIterator.prototype, "pointer", {
-        get: function () {
-          return this.container.getElementByPos(this._node);
-        },
-        set: function (newValue) {
-          this.container.setElementByPos(this._node, newValue);
-        },
-        enumerable: false,
-        configurable: true
-      });
-      return RandomIterator;
-    }(ContainerIterator);
-
-    var VectorIterator = /** @class */function (_super) {
-      __extends(VectorIterator, _super);
-      function VectorIterator(node, container, iteratorType) {
-        var _this = _super.call(this, node, iteratorType) || this;
-        _this.container = container;
-        return _this;
-      }
-      VectorIterator.prototype.copy = function () {
-        return new VectorIterator(this._node, this.container, this.iteratorType);
-      };
-      return VectorIterator;
-    }(RandomIterator);
-    var Vector = /** @class */function (_super) {
-      __extends(Vector, _super);
-      /**
-       * @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.
-       */
-      function Vector(container, copy) {
-        if (container === void 0) {
-          container = [];
-        }
-        if (copy === void 0) {
-          copy = true;
-        }
-        var _this = _super.call(this) || this;
-        if (Array.isArray(container)) {
-          _this._vector = copy ? __spreadArray([], __read(container), false) : container;
-          _this._length = container.length;
-        } else {
-          _this._vector = [];
-          var self_1 = _this;
-          container.forEach(function (el) {
-            self_1.pushBack(el);
-          });
-        }
-        return _this;
-      }
-      Vector.prototype.clear = function () {
-        this._length = 0;
-        this._vector.length = 0;
-      };
-      Vector.prototype.begin = function () {
-        return new VectorIterator(0, this);
-      };
-      Vector.prototype.end = function () {
-        return new VectorIterator(this._length, this);
-      };
-      Vector.prototype.rBegin = function () {
-        return new VectorIterator(this._length - 1, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      Vector.prototype.rEnd = function () {
-        return new VectorIterator(-1, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      Vector.prototype.front = function () {
-        return this._vector[0];
-      };
-      Vector.prototype.back = function () {
-        return this._vector[this._length - 1];
-      };
-      Vector.prototype.getElementByPos = function (pos) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        return this._vector[pos];
-      };
-      Vector.prototype.eraseElementByPos = function (pos) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        this._vector.splice(pos, 1);
-        this._length -= 1;
-        return this._length;
-      };
-      Vector.prototype.eraseElementByValue = function (value) {
-        var index = 0;
-        for (var i = 0; i < this._length; ++i) {
-          if (this._vector[i] !== value) {
-            this._vector[index++] = this._vector[i];
-          }
-        }
-        this._length = this._vector.length = index;
-        return this._length;
-      };
-      Vector.prototype.eraseElementByIterator = function (iter) {
-        var _node = iter._node;
-        iter = iter.next();
-        this.eraseElementByPos(_node);
-        return iter;
-      };
-      Vector.prototype.pushBack = function (element) {
-        this._vector.push(element);
-        this._length += 1;
-        return this._length;
-      };
-      Vector.prototype.popBack = function () {
-        if (this._length === 0) return;
-        this._length -= 1;
-        return this._vector.pop();
-      };
-      Vector.prototype.setElementByPos = function (pos, element) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        this._vector[pos] = element;
-      };
-      Vector.prototype.insert = function (pos, element, num) {
-        var _a;
-        if (num === void 0) {
-          num = 1;
-        }
-        if (pos < 0 || pos > this._length) {
-          throw new RangeError();
-        }
-        (_a = this._vector).splice.apply(_a, __spreadArray([pos, 0], __read(new Array(num).fill(element)), false));
-        this._length += num;
-        return this._length;
-      };
-      Vector.prototype.find = function (element) {
-        for (var i = 0; i < this._length; ++i) {
-          if (this._vector[i] === element) {
-            return new VectorIterator(i, this);
-          }
-        }
-        return this.end();
-      };
-      Vector.prototype.reverse = function () {
-        this._vector.reverse();
-      };
-      Vector.prototype.unique = function () {
-        var index = 1;
-        for (var i = 1; i < this._length; ++i) {
-          if (this._vector[i] !== this._vector[i - 1]) {
-            this._vector[index++] = this._vector[i];
-          }
-        }
-        this._length = this._vector.length = index;
-        return this._length;
-      };
-      Vector.prototype.sort = function (cmp) {
-        this._vector.sort(cmp);
-      };
-      Vector.prototype.forEach = function (callback) {
-        for (var i = 0; i < this._length; ++i) {
-          callback(this._vector[i], i, this);
-        }
-      };
-      Vector.prototype[Symbol.iterator] = function () {
-        return function () {
-          return __generator(this, function (_a) {
-            switch (_a.label) {
-              case 0:
-                return [5 /*yield**/, __values(this._vector)];
-              case 1:
-                _a.sent();
-                return [2 /*return*/];
-            }
-          });
-        }.bind(this)();
-      };
-      return Vector;
-    }(SequentialContainer);
-
-    var LinkListIterator = /** @class */function (_super) {
-      __extends(LinkListIterator, _super);
-      /**
-       * @internal
-       */
-      function LinkListIterator(_node, _header, container, iteratorType) {
-        var _this = _super.call(this, iteratorType) || this;
-        _this._node = _node;
-        _this._header = _header;
-        _this.container = container;
-        if (_this.iteratorType === 0 /* IteratorType.NORMAL */) {
-          _this.pre = function () {
-            if (this._node._pre === this._header) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._pre;
-            return this;
-          };
-          _this.next = function () {
-            if (this._node === this._header) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._next;
-            return this;
-          };
-        } else {
-          _this.pre = function () {
-            if (this._node._next === this._header) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._next;
-            return this;
-          };
-          _this.next = function () {
-            if (this._node === this._header) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._pre;
-            return this;
-          };
-        }
-        return _this;
-      }
-      Object.defineProperty(LinkListIterator.prototype, "pointer", {
-        get: function () {
-          if (this._node === this._header) {
-            throwIteratorAccessError();
-          }
-          return this._node._value;
-        },
-        set: function (newValue) {
-          if (this._node === this._header) {
-            throwIteratorAccessError();
-          }
-          this._node._value = newValue;
-        },
-        enumerable: false,
-        configurable: true
-      });
-      LinkListIterator.prototype.copy = function () {
-        return new LinkListIterator(this._node, this._header, this.container, this.iteratorType);
-      };
-      return LinkListIterator;
-    }(ContainerIterator);
-    var LinkList = /** @class */function (_super) {
-      __extends(LinkList, _super);
-      function LinkList(container) {
-        if (container === void 0) {
-          container = [];
-        }
-        var _this = _super.call(this) || this;
-        _this._header = {};
-        _this._head = _this._tail = _this._header._pre = _this._header._next = _this._header;
-        var self = _this;
-        container.forEach(function (el) {
-          self.pushBack(el);
-        });
-        return _this;
-      }
-      /**
-       * @internal
-       */
-      LinkList.prototype._eraseNode = function (node) {
-        var _pre = node._pre,
-          _next = node._next;
-        _pre._next = _next;
-        _next._pre = _pre;
-        if (node === this._head) {
-          this._head = _next;
-        }
-        if (node === this._tail) {
-          this._tail = _pre;
-        }
-        this._length -= 1;
-      };
-      /**
-       * @internal
-       */
-      LinkList.prototype._insertNode = function (value, pre) {
-        var next = pre._next;
-        var node = {
-          _value: value,
-          _pre: pre,
-          _next: next
-        };
-        pre._next = node;
-        next._pre = node;
-        if (pre === this._header) {
-          this._head = node;
-        }
-        if (next === this._header) {
-          this._tail = node;
-        }
-        this._length += 1;
-      };
-      LinkList.prototype.clear = function () {
-        this._length = 0;
-        this._head = this._tail = this._header._pre = this._header._next = this._header;
-      };
-      LinkList.prototype.begin = function () {
-        return new LinkListIterator(this._head, this._header, this);
-      };
-      LinkList.prototype.end = function () {
-        return new LinkListIterator(this._header, this._header, this);
-      };
-      LinkList.prototype.rBegin = function () {
-        return new LinkListIterator(this._tail, this._header, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      LinkList.prototype.rEnd = function () {
-        return new LinkListIterator(this._header, this._header, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      LinkList.prototype.front = function () {
-        return this._head._value;
-      };
-      LinkList.prototype.back = function () {
-        return this._tail._value;
-      };
-      LinkList.prototype.getElementByPos = function (pos) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        var curNode = this._head;
-        while (pos--) {
-          curNode = curNode._next;
-        }
-        return curNode._value;
-      };
-      LinkList.prototype.eraseElementByPos = function (pos) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        var curNode = this._head;
-        while (pos--) {
-          curNode = curNode._next;
-        }
-        this._eraseNode(curNode);
-        return this._length;
-      };
-      LinkList.prototype.eraseElementByValue = function (_value) {
-        var curNode = this._head;
-        while (curNode !== this._header) {
-          if (curNode._value === _value) {
-            this._eraseNode(curNode);
-          }
-          curNode = curNode._next;
-        }
-        return this._length;
-      };
-      LinkList.prototype.eraseElementByIterator = function (iter) {
-        var node = iter._node;
-        if (node === this._header) {
-          throwIteratorAccessError();
-        }
-        iter = iter.next();
-        this._eraseNode(node);
-        return iter;
-      };
-      LinkList.prototype.pushBack = function (element) {
-        this._insertNode(element, this._tail);
-        return this._length;
-      };
-      LinkList.prototype.popBack = function () {
-        if (this._length === 0) return;
-        var value = this._tail._value;
-        this._eraseNode(this._tail);
-        return value;
-      };
-      /**
-       * @description Push an element to the front.
-       * @param element - The element you want to push.
-       * @returns The size of queue after pushing.
-       */
-      LinkList.prototype.pushFront = function (element) {
-        this._insertNode(element, this._header);
-        return this._length;
-      };
-      /**
-       * @description Removes the first element.
-       * @returns The element you popped.
-       */
-      LinkList.prototype.popFront = function () {
-        if (this._length === 0) return;
-        var value = this._head._value;
-        this._eraseNode(this._head);
-        return value;
-      };
-      LinkList.prototype.setElementByPos = function (pos, element) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        var curNode = this._head;
-        while (pos--) {
-          curNode = curNode._next;
-        }
-        curNode._value = element;
-      };
-      LinkList.prototype.insert = function (pos, element, num) {
-        if (num === void 0) {
-          num = 1;
-        }
-        if (pos < 0 || pos > this._length) {
-          throw new RangeError();
-        }
-        if (num <= 0) return this._length;
-        if (pos === 0) {
-          while (num--) this.pushFront(element);
-        } else if (pos === this._length) {
-          while (num--) this.pushBack(element);
-        } else {
-          var curNode = this._head;
-          for (var i = 1; i < pos; ++i) {
-            curNode = curNode._next;
-          }
-          var next = curNode._next;
-          this._length += num;
-          while (num--) {
-            curNode._next = {
-              _value: element,
-              _pre: curNode
-            };
-            curNode._next._pre = curNode;
-            curNode = curNode._next;
-          }
-          curNode._next = next;
-          next._pre = curNode;
-        }
-        return this._length;
-      };
-      LinkList.prototype.find = function (element) {
-        var curNode = this._head;
-        while (curNode !== this._header) {
-          if (curNode._value === element) {
-            return new LinkListIterator(curNode, this._header, this);
-          }
-          curNode = curNode._next;
-        }
-        return this.end();
-      };
-      LinkList.prototype.reverse = function () {
-        if (this._length <= 1) return;
-        var pHead = this._head;
-        var pTail = this._tail;
-        var cnt = 0;
-        while (cnt << 1 < this._length) {
-          var tmp = pHead._value;
-          pHead._value = pTail._value;
-          pTail._value = tmp;
-          pHead = pHead._next;
-          pTail = pTail._pre;
-          cnt += 1;
-        }
-      };
-      LinkList.prototype.unique = function () {
-        if (this._length <= 1) {
-          return this._length;
-        }
-        var curNode = this._head;
-        while (curNode !== this._header) {
-          var tmpNode = curNode;
-          while (tmpNode._next !== this._header && tmpNode._value === tmpNode._next._value) {
-            tmpNode = tmpNode._next;
-            this._length -= 1;
-          }
-          curNode._next = tmpNode._next;
-          curNode._next._pre = curNode;
-          curNode = curNode._next;
-        }
-        return this._length;
-      };
-      LinkList.prototype.sort = function (cmp) {
-        if (this._length <= 1) return;
-        var arr = [];
-        this.forEach(function (el) {
-          arr.push(el);
-        });
-        arr.sort(cmp);
-        var curNode = this._head;
-        arr.forEach(function (element) {
-          curNode._value = element;
-          curNode = curNode._next;
-        });
-      };
-      /**
-       * @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];
-       */
-      LinkList.prototype.merge = function (list) {
-        var self = this;
-        if (this._length === 0) {
-          list.forEach(function (el) {
-            self.pushBack(el);
-          });
-        } else {
-          var curNode_1 = this._head;
-          list.forEach(function (el) {
-            while (curNode_1 !== self._header && curNode_1._value <= el) {
-              curNode_1 = curNode_1._next;
-            }
-            self._insertNode(el, curNode_1._pre);
-          });
-        }
-        return this._length;
-      };
-      LinkList.prototype.forEach = function (callback) {
-        var curNode = this._head;
-        var index = 0;
-        while (curNode !== this._header) {
-          callback(curNode._value, index++, this);
-          curNode = curNode._next;
-        }
-      };
-      LinkList.prototype[Symbol.iterator] = function () {
-        return function () {
-          var curNode;
-          return __generator(this, function (_a) {
-            switch (_a.label) {
-              case 0:
-                if (this._length === 0) return [2 /*return*/];
-                curNode = this._head;
-                _a.label = 1;
-              case 1:
-                if (!(curNode !== this._header)) return [3 /*break*/, 3];
-                return [4 /*yield*/, curNode._value];
-              case 2:
-                _a.sent();
-                curNode = curNode._next;
-                return [3 /*break*/, 1];
-              case 3:
-                return [2 /*return*/];
-            }
-          });
-        }.bind(this)();
-      };
-      return LinkList;
-    }(SequentialContainer);
-
-    var DequeIterator = /** @class */function (_super) {
-      __extends(DequeIterator, _super);
-      function DequeIterator(node, container, iteratorType) {
-        var _this = _super.call(this, node, iteratorType) || this;
-        _this.container = container;
-        return _this;
-      }
-      DequeIterator.prototype.copy = function () {
-        return new DequeIterator(this._node, this.container, this.iteratorType);
-      };
-      return DequeIterator;
-    }(RandomIterator);
-    var Deque = /** @class */function (_super) {
-      __extends(Deque, _super);
-      function Deque(container, _bucketSize) {
-        if (container === void 0) {
-          container = [];
-        }
-        if (_bucketSize === void 0) {
-          _bucketSize = 1 << 12;
-        }
-        var _this = _super.call(this) || this;
-        /**
-         * @internal
-         */
-        _this._first = 0;
-        /**
-         * @internal
-         */
-        _this._curFirst = 0;
-        /**
-         * @internal
-         */
-        _this._last = 0;
-        /**
-         * @internal
-         */
-        _this._curLast = 0;
-        /**
-         * @internal
-         */
-        _this._bucketNum = 0;
-        /**
-         * @internal
-         */
-        _this._map = [];
-        var _length = function () {
-          if (typeof container.length === "number") return container.length;
-          if (typeof container.size === "number") return container.size;
-          if (typeof container.size === "function") return container.size();
-          throw new TypeError("Cannot get the length or size of the container");
-        }();
-        _this._bucketSize = _bucketSize;
-        _this._bucketNum = Math.max(Math.ceil(_length / _this._bucketSize), 1);
-        for (var i = 0; i < _this._bucketNum; ++i) {
-          _this._map.push(new Array(_this._bucketSize));
-        }
-        var needBucketNum = Math.ceil(_length / _this._bucketSize);
-        _this._first = _this._last = (_this._bucketNum >> 1) - (needBucketNum >> 1);
-        _this._curFirst = _this._curLast = _this._bucketSize - _length % _this._bucketSize >> 1;
-        var self = _this;
-        container.forEach(function (element) {
-          self.pushBack(element);
-        });
-        return _this;
-      }
-      /**
-       * @description Growth the Deque.
-       * @internal
-       */
-      Deque.prototype._reAllocate = function () {
-        var newMap = [];
-        var addBucketNum = Math.max(this._bucketNum >> 1, 1);
-        for (var i = 0; i < addBucketNum; ++i) {
-          newMap[i] = new Array(this._bucketSize);
-        }
-        for (var i = this._first; i < this._bucketNum; ++i) {
-          newMap[newMap.length] = this._map[i];
-        }
-        for (var i = 0; i < this._last; ++i) {
-          newMap[newMap.length] = this._map[i];
-        }
-        newMap[newMap.length] = __spreadArray([], __read(this._map[this._last]), false);
-        this._first = addBucketNum;
-        this._last = newMap.length - 1;
-        for (var i = 0; i < addBucketNum; ++i) {
-          newMap[newMap.length] = new Array(this._bucketSize);
-        }
-        this._map = newMap;
-        this._bucketNum = newMap.length;
-      };
-      /**
-       * @description Get the bucket position of the element and the pointer position by index.
-       * @param pos - The element's index.
-       * @internal
-       */
-      Deque.prototype._getElementIndex = function (pos) {
-        var offset = this._curFirst + pos + 1;
-        var offsetRemainder = offset % this._bucketSize;
-        var curNodePointerIndex = offsetRemainder - 1;
-        var curNodeBucketIndex = this._first + (offset - offsetRemainder) / this._bucketSize;
-        if (offsetRemainder === 0) curNodeBucketIndex -= 1;
-        curNodeBucketIndex %= this._bucketNum;
-        if (curNodePointerIndex < 0) curNodePointerIndex += this._bucketSize;
-        return {
-          curNodeBucketIndex: curNodeBucketIndex,
-          curNodePointerIndex: curNodePointerIndex
-        };
-      };
-      Deque.prototype.clear = function () {
-        this._map = [new Array(this._bucketSize)];
-        this._bucketNum = 1;
-        this._first = this._last = this._length = 0;
-        this._curFirst = this._curLast = this._bucketSize >> 1;
-      };
-      Deque.prototype.begin = function () {
-        return new DequeIterator(0, this);
-      };
-      Deque.prototype.end = function () {
-        return new DequeIterator(this._length, this);
-      };
-      Deque.prototype.rBegin = function () {
-        return new DequeIterator(this._length - 1, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      Deque.prototype.rEnd = function () {
-        return new DequeIterator(-1, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      Deque.prototype.front = function () {
-        if (this._length === 0) return;
-        return this._map[this._first][this._curFirst];
-      };
-      Deque.prototype.back = function () {
-        if (this._length === 0) return;
-        return this._map[this._last][this._curLast];
-      };
-      Deque.prototype.pushBack = function (element) {
-        if (this._length) {
-          if (this._curLast < this._bucketSize - 1) {
-            this._curLast += 1;
-          } else if (this._last < this._bucketNum - 1) {
-            this._last += 1;
-            this._curLast = 0;
-          } else {
-            this._last = 0;
-            this._curLast = 0;
-          }
-          if (this._last === this._first && this._curLast === this._curFirst) this._reAllocate();
-        }
-        this._length += 1;
-        this._map[this._last][this._curLast] = element;
-        return this._length;
-      };
-      Deque.prototype.popBack = function () {
-        if (this._length === 0) return;
-        var value = this._map[this._last][this._curLast];
-        if (this._length !== 1) {
-          if (this._curLast > 0) {
-            this._curLast -= 1;
-          } else if (this._last > 0) {
-            this._last -= 1;
-            this._curLast = this._bucketSize - 1;
-          } else {
-            this._last = this._bucketNum - 1;
-            this._curLast = this._bucketSize - 1;
-          }
-        }
-        this._length -= 1;
-        return value;
-      };
-      /**
-       * @description Push the element to the front.
-       * @param element - The element you want to push.
-       * @returns The size of queue after pushing.
-       */
-      Deque.prototype.pushFront = function (element) {
-        if (this._length) {
-          if (this._curFirst > 0) {
-            this._curFirst -= 1;
-          } else if (this._first > 0) {
-            this._first -= 1;
-            this._curFirst = this._bucketSize - 1;
-          } else {
-            this._first = this._bucketNum - 1;
-            this._curFirst = this._bucketSize - 1;
-          }
-          if (this._first === this._last && this._curFirst === this._curLast) this._reAllocate();
-        }
-        this._length += 1;
-        this._map[this._first][this._curFirst] = element;
-        return this._length;
-      };
-      /**
-       * @description Remove the _first element.
-       * @returns The element you popped.
-       */
-      Deque.prototype.popFront = function () {
-        if (this._length === 0) return;
-        var value = this._map[this._first][this._curFirst];
-        if (this._length !== 1) {
-          if (this._curFirst < this._bucketSize - 1) {
-            this._curFirst += 1;
-          } else if (this._first < this._bucketNum - 1) {
-            this._first += 1;
-            this._curFirst = 0;
-          } else {
-            this._first = 0;
-            this._curFirst = 0;
-          }
-        }
-        this._length -= 1;
-        return value;
-      };
-      Deque.prototype.getElementByPos = function (pos) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        var _a = this._getElementIndex(pos),
-          curNodeBucketIndex = _a.curNodeBucketIndex,
-          curNodePointerIndex = _a.curNodePointerIndex;
-        return this._map[curNodeBucketIndex][curNodePointerIndex];
-      };
-      Deque.prototype.setElementByPos = function (pos, element) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        var _a = this._getElementIndex(pos),
-          curNodeBucketIndex = _a.curNodeBucketIndex,
-          curNodePointerIndex = _a.curNodePointerIndex;
-        this._map[curNodeBucketIndex][curNodePointerIndex] = element;
-      };
-      Deque.prototype.insert = function (pos, element, num) {
-        if (num === void 0) {
-          num = 1;
-        }
-        if (pos < 0 || pos > this._length) {
-          throw new RangeError();
-        }
-        if (pos === 0) {
-          while (num--) this.pushFront(element);
-        } else if (pos === this._length) {
-          while (num--) this.pushBack(element);
-        } else {
-          var arr = [];
-          for (var i = pos; i < this._length; ++i) {
-            arr.push(this.getElementByPos(i));
-          }
-          this.cut(pos - 1);
-          for (var i = 0; i < num; ++i) this.pushBack(element);
-          for (var i = 0; i < arr.length; ++i) this.pushBack(arr[i]);
-        }
-        return this._length;
-      };
-      /**
-       * @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]
-       */
-      Deque.prototype.cut = function (pos) {
-        if (pos < 0) {
-          this.clear();
-          return 0;
-        }
-        var _a = this._getElementIndex(pos),
-          curNodeBucketIndex = _a.curNodeBucketIndex,
-          curNodePointerIndex = _a.curNodePointerIndex;
-        this._last = curNodeBucketIndex;
-        this._curLast = curNodePointerIndex;
-        this._length = pos + 1;
-        return this._length;
-      };
-      Deque.prototype.eraseElementByPos = function (pos) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        if (pos === 0) this.popFront();else if (pos === this._length - 1) this.popBack();else {
-          var arr = [];
-          for (var i = pos + 1; i < this._length; ++i) {
-            arr.push(this.getElementByPos(i));
-          }
-          this.cut(pos);
-          this.popBack();
-          var self_1 = this;
-          arr.forEach(function (el) {
-            self_1.pushBack(el);
-          });
-        }
-        return this._length;
-      };
-      Deque.prototype.eraseElementByValue = function (value) {
-        if (this._length === 0) return 0;
-        var arr = [];
-        for (var i = 0; i < this._length; ++i) {
-          var element = this.getElementByPos(i);
-          if (element !== value) arr.push(element);
-        }
-        var _length = arr.length;
-        for (var i = 0; i < _length; ++i) this.setElementByPos(i, arr[i]);
-        return this.cut(_length - 1);
-      };
-      Deque.prototype.eraseElementByIterator = function (iter) {
-        var _node = iter._node;
-        this.eraseElementByPos(_node);
-        iter = iter.next();
-        return iter;
-      };
-      Deque.prototype.find = function (element) {
-        for (var i = 0; i < this._length; ++i) {
-          if (this.getElementByPos(i) === element) {
-            return new DequeIterator(i, this);
-          }
-        }
-        return this.end();
-      };
-      Deque.prototype.reverse = function () {
-        var l = 0;
-        var r = this._length - 1;
-        while (l < r) {
-          var tmp = this.getElementByPos(l);
-          this.setElementByPos(l, this.getElementByPos(r));
-          this.setElementByPos(r, tmp);
-          l += 1;
-          r -= 1;
-        }
-      };
-      Deque.prototype.unique = function () {
-        if (this._length <= 1) {
-          return this._length;
-        }
-        var index = 1;
-        var pre = this.getElementByPos(0);
-        for (var i = 1; i < this._length; ++i) {
-          var cur = this.getElementByPos(i);
-          if (cur !== pre) {
-            pre = cur;
-            this.setElementByPos(index++, cur);
-          }
-        }
-        while (this._length > index) this.popBack();
-        return this._length;
-      };
-      Deque.prototype.sort = function (cmp) {
-        var arr = [];
-        for (var i = 0; i < this._length; ++i) {
-          arr.push(this.getElementByPos(i));
-        }
-        arr.sort(cmp);
-        for (var i = 0; i < this._length; ++i) this.setElementByPos(i, arr[i]);
-      };
-      /**
-       * @description Remove as much useless space as possible.
-       */
-      Deque.prototype.shrinkToFit = function () {
-        if (this._length === 0) return;
-        var arr = [];
-        this.forEach(function (el) {
-          arr.push(el);
-        });
-        this._bucketNum = Math.max(Math.ceil(this._length / this._bucketSize), 1);
-        this._length = this._first = this._last = this._curFirst = this._curLast = 0;
-        this._map = [];
-        for (var i = 0; i < this._bucketNum; ++i) {
-          this._map.push(new Array(this._bucketSize));
-        }
-        for (var i = 0; i < arr.length; ++i) this.pushBack(arr[i]);
-      };
-      Deque.prototype.forEach = function (callback) {
-        for (var i = 0; i < this._length; ++i) {
-          callback(this.getElementByPos(i), i, this);
-        }
-      };
-      Deque.prototype[Symbol.iterator] = function () {
-        return function () {
-          var i;
-          return __generator(this, function (_a) {
-            switch (_a.label) {
-              case 0:
-                i = 0;
-                _a.label = 1;
-              case 1:
-                if (!(i < this._length)) return [3 /*break*/, 4];
-                return [4 /*yield*/, this.getElementByPos(i)];
-              case 2:
-                _a.sent();
-                _a.label = 3;
-              case 3:
-                ++i;
-                return [3 /*break*/, 1];
-              case 4:
-                return [2 /*return*/];
-            }
-          });
-        }.bind(this)();
-      };
-      return Deque;
-    }(SequentialContainer);
-
-    var TreeNode = /** @class */function () {
-      function TreeNode(key, value) {
-        this._color = 1 /* TreeNodeColor.RED */;
-        this._key = undefined;
-        this._value = undefined;
-        this._left = undefined;
-        this._right = undefined;
-        this._parent = undefined;
-        this._key = key;
-        this._value = value;
-      }
-      /**
-       * @description Get the pre node.
-       * @returns TreeNode about the pre node.
-       */
-      TreeNode.prototype._pre = function () {
-        var preNode = this;
-        if (preNode._color === 1 /* TreeNodeColor.RED */ && preNode._parent._parent === preNode) {
-          preNode = preNode._right;
-        } else if (preNode._left) {
-          preNode = preNode._left;
-          while (preNode._right) {
-            preNode = preNode._right;
-          }
-        } else {
-          var pre = preNode._parent;
-          while (pre._left === preNode) {
-            preNode = pre;
-            pre = preNode._parent;
-          }
-          preNode = pre;
-        }
-        return preNode;
-      };
-      /**
-       * @description Get the next node.
-       * @returns TreeNode about the next node.
-       */
-      TreeNode.prototype._next = function () {
-        var nextNode = this;
-        if (nextNode._right) {
-          nextNode = nextNode._right;
-          while (nextNode._left) {
-            nextNode = nextNode._left;
-          }
-          return nextNode;
-        } else {
-          var pre = nextNode._parent;
-          while (pre._right === nextNode) {
-            nextNode = pre;
-            pre = nextNode._parent;
-          }
-          if (nextNode._right !== pre) {
-            return pre;
-          } else return nextNode;
-        }
-      };
-      /**
-       * @description Rotate left.
-       * @returns TreeNode about moved to original position after rotation.
-       */
-      TreeNode.prototype._rotateLeft = function () {
-        var PP = this._parent;
-        var V = this._right;
-        var R = V._left;
-        if (PP._parent === this) PP._parent = V;else if (PP._left === this) PP._left = V;else PP._right = V;
-        V._parent = PP;
-        V._left = this;
-        this._parent = V;
-        this._right = R;
-        if (R) R._parent = this;
-        return V;
-      };
-      /**
-       * @description Rotate right.
-       * @returns TreeNode about moved to original position after rotation.
-       */
-      TreeNode.prototype._rotateRight = function () {
-        var PP = this._parent;
-        var F = this._left;
-        var K = F._right;
-        if (PP._parent === this) PP._parent = F;else if (PP._left === this) PP._left = F;else PP._right = F;
-        F._parent = PP;
-        F._right = this;
-        this._parent = F;
-        this._left = K;
-        if (K) K._parent = this;
-        return F;
-      };
-      return TreeNode;
-    }();
-    var TreeNodeEnableIndex = /** @class */function (_super) {
-      __extends(TreeNodeEnableIndex, _super);
-      function TreeNodeEnableIndex() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._subTreeSize = 1;
-        return _this;
-      }
-      /**
-       * @description Rotate left and do recount.
-       * @returns TreeNode about moved to original position after rotation.
-       */
-      TreeNodeEnableIndex.prototype._rotateLeft = function () {
-        var parent = _super.prototype._rotateLeft.call(this);
-        this._recount();
-        parent._recount();
-        return parent;
-      };
-      /**
-       * @description Rotate right and do recount.
-       * @returns TreeNode about moved to original position after rotation.
-       */
-      TreeNodeEnableIndex.prototype._rotateRight = function () {
-        var parent = _super.prototype._rotateRight.call(this);
-        this._recount();
-        parent._recount();
-        return parent;
-      };
-      TreeNodeEnableIndex.prototype._recount = function () {
-        this._subTreeSize = 1;
-        if (this._left) {
-          this._subTreeSize += this._left._subTreeSize;
-        }
-        if (this._right) {
-          this._subTreeSize += this._right._subTreeSize;
-        }
-      };
-      return TreeNodeEnableIndex;
-    }(TreeNode);
-
-    var TreeContainer = /** @class */function (_super) {
-      __extends(TreeContainer, _super);
-      /**
-       * @internal
-       */
-      function TreeContainer(cmp, enableIndex) {
-        if (cmp === void 0) {
-          cmp = function (x, y) {
-            if (x < y) return -1;
-            if (x > y) return 1;
-            return 0;
-          };
-        }
-        if (enableIndex === void 0) {
-          enableIndex = false;
-        }
-        var _this = _super.call(this) || this;
-        /**
-         * @internal
-         */
-        _this._root = undefined;
-        _this._cmp = cmp;
-        if (enableIndex) {
-          _this._TreeNodeClass = TreeNodeEnableIndex;
-          _this._set = function (key, value, hint) {
-            var curNode = this._preSet(key, value, hint);
-            if (curNode) {
-              var p = curNode._parent;
-              while (p !== this._header) {
-                p._subTreeSize += 1;
-                p = p._parent;
-              }
-              var nodeList = this._insertNodeSelfBalance(curNode);
-              if (nodeList) {
-                var _a = nodeList,
-                  parentNode = _a.parentNode,
-                  grandParent = _a.grandParent,
-                  curNode_1 = _a.curNode;
-                parentNode._recount();
-                grandParent._recount();
-                curNode_1._recount();
-              }
-            }
-            return this._length;
-          };
-          _this._eraseNode = function (curNode) {
-            var p = this._preEraseNode(curNode);
-            while (p !== this._header) {
-              p._subTreeSize -= 1;
-              p = p._parent;
-            }
-          };
-        } else {
-          _this._TreeNodeClass = TreeNode;
-          _this._set = function (key, value, hint) {
-            var curNode = this._preSet(key, value, hint);
-            if (curNode) this._insertNodeSelfBalance(curNode);
-            return this._length;
-          };
-          _this._eraseNode = _this._preEraseNode;
-        }
-        _this._header = new _this._TreeNodeClass();
-        return _this;
-      }
-      /**
-       * @internal
-       */
-      TreeContainer.prototype._lowerBound = function (curNode, key) {
-        var resNode = this._header;
-        while (curNode) {
-          var cmpResult = this._cmp(curNode._key, key);
-          if (cmpResult < 0) {
-            curNode = curNode._right;
-          } else if (cmpResult > 0) {
-            resNode = curNode;
-            curNode = curNode._left;
-          } else return curNode;
-        }
-        return resNode;
-      };
-      /**
-       * @internal
-       */
-      TreeContainer.prototype._upperBound = function (curNode, key) {
-        var resNode = this._header;
-        while (curNode) {
-          var cmpResult = this._cmp(curNode._key, key);
-          if (cmpResult <= 0) {
-            curNode = curNode._right;
-          } else {
-            resNode = curNode;
-            curNode = curNode._left;
-          }
-        }
-        return resNode;
-      };
-      /**
-       * @internal
-       */
-      TreeContainer.prototype._reverseLowerBound = function (curNode, key) {
-        var resNode = this._header;
-        while (curNode) {
-          var cmpResult = this._cmp(curNode._key, key);
-          if (cmpResult < 0) {
-            resNode = curNode;
-            curNode = curNode._right;
-          } else if (cmpResult > 0) {
-            curNode = curNode._left;
-          } else return curNode;
-        }
-        return resNode;
-      };
-      /**
-       * @internal
-       */
-      TreeContainer.prototype._reverseUpperBound = function (curNode, key) {
-        var resNode = this._header;
-        while (curNode) {
-          var cmpResult = this._cmp(curNode._key, key);
-          if (cmpResult < 0) {
-            resNode = curNode;
-            curNode = curNode._right;
-          } else {
-            curNode = curNode._left;
-          }
-        }
-        return resNode;
-      };
-      /**
-       * @internal
-       */
-      TreeContainer.prototype._eraseNodeSelfBalance = function (curNode) {
-        while (true) {
-          var parentNode = curNode._parent;
-          if (parentNode === this._header) return;
-          if (curNode._color === 1 /* TreeNodeColor.RED */) {
-            curNode._color = 0 /* TreeNodeColor.BLACK */;
-            return;
-          }
-          if (curNode === parentNode._left) {
-            var brother = parentNode._right;
-            if (brother._color === 1 /* TreeNodeColor.RED */) {
-              brother._color = 0 /* TreeNodeColor.BLACK */;
-              parentNode._color = 1 /* TreeNodeColor.RED */;
-              if (parentNode === this._root) {
-                this._root = parentNode._rotateLeft();
-              } else parentNode._rotateLeft();
-            } else {
-              if (brother._right && brother._right._color === 1 /* TreeNodeColor.RED */) {
-                brother._color = parentNode._color;
-                parentNode._color = 0 /* TreeNodeColor.BLACK */;
-                brother._right._color = 0 /* TreeNodeColor.BLACK */;
-                if (parentNode === this._root) {
-                  this._root = parentNode._rotateLeft();
-                } else parentNode._rotateLeft();
-                return;
-              } else if (brother._left && brother._left._color === 1 /* TreeNodeColor.RED */) {
-                brother._color = 1 /* TreeNodeColor.RED */;
-                brother._left._color = 0 /* TreeNodeColor.BLACK */;
-                brother._rotateRight();
-              } else {
-                brother._color = 1 /* TreeNodeColor.RED */;
-                curNode = parentNode;
-              }
-            }
-          } else {
-            var brother = parentNode._left;
-            if (brother._color === 1 /* TreeNodeColor.RED */) {
-              brother._color = 0 /* TreeNodeColor.BLACK */;
-              parentNode._color = 1 /* TreeNodeColor.RED */;
-              if (parentNode === this._root) {
-                this._root = parentNode._rotateRight();
-              } else parentNode._rotateRight();
-            } else {
-              if (brother._left && brother._left._color === 1 /* TreeNodeColor.RED */) {
-                brother._color = parentNode._color;
-                parentNode._color = 0 /* TreeNodeColor.BLACK */;
-                brother._left._color = 0 /* TreeNodeColor.BLACK */;
-                if (parentNode === this._root) {
-                  this._root = parentNode._rotateRight();
-                } else parentNode._rotateRight();
-                return;
-              } else if (brother._right && brother._right._color === 1 /* TreeNodeColor.RED */) {
-                brother._color = 1 /* TreeNodeColor.RED */;
-                brother._right._color = 0 /* TreeNodeColor.BLACK */;
-                brother._rotateLeft();
-              } else {
-                brother._color = 1 /* TreeNodeColor.RED */;
-                curNode = parentNode;
-              }
-            }
-          }
-        }
-      };
-      /**
-       * @internal
-       */
-      TreeContainer.prototype._preEraseNode = function (curNode) {
-        var _a, _b;
-        if (this._length === 1) {
-          this.clear();
-          return this._header;
-        }
-        var swapNode = curNode;
-        while (swapNode._left || swapNode._right) {
-          if (swapNode._right) {
-            swapNode = swapNode._right;
-            while (swapNode._left) swapNode = swapNode._left;
-          } else {
-            swapNode = swapNode._left;
-          }
-          _a = __read([swapNode._key, curNode._key], 2), curNode._key = _a[0], swapNode._key = _a[1];
-          _b = __read([swapNode._value, curNode._value], 2), curNode._value = _b[0], swapNode._value = _b[1];
-          curNode = swapNode;
-        }
-        if (this._header._left === swapNode) {
-          this._header._left = swapNode._parent;
-        } else if (this._header._right === swapNode) {
-          this._header._right = swapNode._parent;
-        }
-        this._eraseNodeSelfBalance(swapNode);
-        var _parent = swapNode._parent;
-        if (swapNode === _parent._left) {
-          _parent._left = undefined;
-        } else _parent._right = undefined;
-        this._length -= 1;
-        this._root._color = 0 /* TreeNodeColor.BLACK */;
-        return _parent;
-      };
-      /**
-       * @internal
-       */
-      TreeContainer.prototype._inOrderTraversal = function (curNode, callback) {
-        if (curNode === undefined) return false;
-        var ifReturn = this._inOrderTraversal(curNode._left, callback);
-        if (ifReturn) return true;
-        if (callback(curNode)) return true;
-        return this._inOrderTraversal(curNode._right, callback);
-      };
-      /**
-       * @internal
-       */
-      TreeContainer.prototype._insertNodeSelfBalance = function (curNode) {
-        while (true) {
-          var parentNode = curNode._parent;
-          if (parentNode._color === 0 /* TreeNodeColor.BLACK */) return;
-          var grandParent = parentNode._parent;
-          if (parentNode === grandParent._left) {
-            var uncle = grandParent._right;
-            if (uncle && uncle._color === 1 /* TreeNodeColor.RED */) {
-              uncle._color = parentNode._color = 0 /* TreeNodeColor.BLACK */;
-              if (grandParent === this._root) return;
-              grandParent._color = 1 /* TreeNodeColor.RED */;
-              curNode = grandParent;
-              continue;
-            } else if (curNode === parentNode._right) {
-              curNode._color = 0 /* TreeNodeColor.BLACK */;
-              if (curNode._left) curNode._left._parent = parentNode;
-              if (curNode._right) curNode._right._parent = grandParent;
-              parentNode._right = curNode._left;
-              grandParent._left = curNode._right;
-              curNode._left = parentNode;
-              curNode._right = grandParent;
-              if (grandParent === this._root) {
-                this._root = curNode;
-                this._header._parent = curNode;
-              } else {
-                var GP = grandParent._parent;
-                if (GP._left === grandParent) {
-                  GP._left = curNode;
-                } else GP._right = curNode;
-              }
-              curNode._parent = grandParent._parent;
-              parentNode._parent = curNode;
-              grandParent._parent = curNode;
-              grandParent._color = 1 /* TreeNodeColor.RED */;
-              return {
-                parentNode: parentNode,
-                grandParent: grandParent,
-                curNode: curNode
-              };
-            } else {
-              parentNode._color = 0 /* TreeNodeColor.BLACK */;
-              if (grandParent === this._root) {
-                this._root = grandParent._rotateRight();
-              } else grandParent._rotateRight();
-              grandParent._color = 1 /* TreeNodeColor.RED */;
-            }
-          } else {
-            var uncle = grandParent._left;
-            if (uncle && uncle._color === 1 /* TreeNodeColor.RED */) {
-              uncle._color = parentNode._color = 0 /* TreeNodeColor.BLACK */;
-              if (grandParent === this._root) return;
-              grandParent._color = 1 /* TreeNodeColor.RED */;
-              curNode = grandParent;
-              continue;
-            } else if (curNode === parentNode._left) {
-              curNode._color = 0 /* TreeNodeColor.BLACK */;
-              if (curNode._left) curNode._left._parent = grandParent;
-              if (curNode._right) curNode._right._parent = parentNode;
-              grandParent._right = curNode._left;
-              parentNode._left = curNode._right;
-              curNode._left = grandParent;
-              curNode._right = parentNode;
-              if (grandParent === this._root) {
-                this._root = curNode;
-                this._header._parent = curNode;
-              } else {
-                var GP = grandParent._parent;
-                if (GP._left === grandParent) {
-                  GP._left = curNode;
-                } else GP._right = curNode;
-              }
-              curNode._parent = grandParent._parent;
-              parentNode._parent = curNode;
-              grandParent._parent = curNode;
-              grandParent._color = 1 /* TreeNodeColor.RED */;
-              return {
-                parentNode: parentNode,
-                grandParent: grandParent,
-                curNode: curNode
-              };
-            } else {
-              parentNode._color = 0 /* TreeNodeColor.BLACK */;
-              if (grandParent === this._root) {
-                this._root = grandParent._rotateLeft();
-              } else grandParent._rotateLeft();
-              grandParent._color = 1 /* TreeNodeColor.RED */;
-            }
-          }
-
-          return;
-        }
-      };
-      /**
-       * @internal
-       */
-      TreeContainer.prototype._preSet = function (key, value, hint) {
-        if (this._root === undefined) {
-          this._length += 1;
-          this._root = new this._TreeNodeClass(key, value);
-          this._root._color = 0 /* TreeNodeColor.BLACK */;
-          this._root._parent = this._header;
-          this._header._parent = this._root;
-          this._header._left = this._root;
-          this._header._right = this._root;
-          return;
-        }
-        var curNode;
-        var minNode = this._header._left;
-        var compareToMin = this._cmp(minNode._key, key);
-        if (compareToMin === 0) {
-          minNode._value = value;
-          return;
-        } else if (compareToMin > 0) {
-          minNode._left = new this._TreeNodeClass(key, value);
-          minNode._left._parent = minNode;
-          curNode = minNode._left;
-          this._header._left = curNode;
-        } else {
-          var maxNode = this._header._right;
-          var compareToMax = this._cmp(maxNode._key, key);
-          if (compareToMax === 0) {
-            maxNode._value = value;
-            return;
-          } else if (compareToMax < 0) {
-            maxNode._right = new this._TreeNodeClass(key, value);
-            maxNode._right._parent = maxNode;
-            curNode = maxNode._right;
-            this._header._right = curNode;
-          } else {
-            if (hint !== undefined) {
-              var iterNode = hint._node;
-              if (iterNode !== this._header) {
-                var iterCmpRes = this._cmp(iterNode._key, key);
-                if (iterCmpRes === 0) {
-                  iterNode._value = value;
-                  return;
-                } else /* istanbul ignore else */if (iterCmpRes > 0) {
-                    var preNode = iterNode._pre();
-                    var preCmpRes = this._cmp(preNode._key, key);
-                    if (preCmpRes === 0) {
-                      preNode._value = value;
-                      return;
-                    } else if (preCmpRes < 0) {
-                      curNode = new this._TreeNodeClass(key, value);
-                      if (preNode._right === undefined) {
-                        preNode._right = curNode;
-                        curNode._parent = preNode;
-                      } else {
-                        iterNode._left = curNode;
-                        curNode._parent = iterNode;
-                      }
-                    }
-                  }
-              }
-            }
-            if (curNode === undefined) {
-              curNode = this._root;
-              while (true) {
-                var cmpResult = this._cmp(curNode._key, key);
-                if (cmpResult > 0) {
-                  if (curNode._left === undefined) {
-                    curNode._left = new this._TreeNodeClass(key, value);
-                    curNode._left._parent = curNode;
-                    curNode = curNode._left;
-                    break;
-                  }
-                  curNode = curNode._left;
-                } else if (cmpResult < 0) {
-                  if (curNode._right === undefined) {
-                    curNode._right = new this._TreeNodeClass(key, value);
-                    curNode._right._parent = curNode;
-                    curNode = curNode._right;
-                    break;
-                  }
-                  curNode = curNode._right;
-                } else {
-                  curNode._value = value;
-                  return;
-                }
-              }
-            }
-          }
-        }
-        this._length += 1;
-        return curNode;
-      };
-      /**
-       * @internal
-       */
-      TreeContainer.prototype._findElementNode = function (curNode, key) {
-        while (curNode) {
-          var cmpResult = this._cmp(curNode._key, key);
-          if (cmpResult < 0) {
-            curNode = curNode._right;
-          } else if (cmpResult > 0) {
-            curNode = curNode._left;
-          } else return curNode;
-        }
-        return curNode || this._header;
-      };
-      TreeContainer.prototype.clear = function () {
-        this._length = 0;
-        this._root = undefined;
-        this._header._parent = undefined;
-        this._header._left = this._header._right = undefined;
-      };
-      /**
-       * @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]
-       */
-      TreeContainer.prototype.updateKeyByIterator = function (iter, key) {
-        var node = iter._node;
-        if (node === this._header) {
-          throwIteratorAccessError();
-        }
-        if (this._length === 1) {
-          node._key = key;
-          return true;
-        }
-        if (node === this._header._left) {
-          if (this._cmp(node._next()._key, key) > 0) {
-            node._key = key;
-            return true;
-          }
-          return false;
-        }
-        if (node === this._header._right) {
-          if (this._cmp(node._pre()._key, key) < 0) {
-            node._key = key;
-            return true;
-          }
-          return false;
-        }
-        var preKey = node._pre()._key;
-        if (this._cmp(preKey, key) >= 0) return false;
-        var nextKey = node._next()._key;
-        if (this._cmp(nextKey, key) <= 0) return false;
-        node._key = key;
-        return true;
-      };
-      TreeContainer.prototype.eraseElementByPos = function (pos) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        var index = 0;
-        var self = this;
-        this._inOrderTraversal(this._root, function (curNode) {
-          if (pos === index) {
-            self._eraseNode(curNode);
-            return true;
-          }
-          index += 1;
-          return false;
-        });
-        return this._length;
-      };
-      /**
-       * @description Remove the element of the specified key.
-       * @param key - The key you want to remove.
-       * @returns Whether erase successfully.
-       */
-      TreeContainer.prototype.eraseElementByKey = function (key) {
-        if (this._length === 0) return false;
-        var curNode = this._findElementNode(this._root, key);
-        if (curNode === this._header) return false;
-        this._eraseNode(curNode);
-        return true;
-      };
-      TreeContainer.prototype.eraseElementByIterator = function (iter) {
-        var node = iter._node;
-        if (node === this._header) {
-          throwIteratorAccessError();
-        }
-        var hasNoRight = node._right === undefined;
-        var isNormal = iter.iteratorType === 0 /* IteratorType.NORMAL */;
-        // For the normal iterator, the `next` node will be swapped to `this` node when has right.
-        if (isNormal) {
-          // So we should move it to next when it's right is null.
-          if (hasNoRight) iter.next();
-        } else {
-          // For the reverse iterator, only when it doesn't have right and has left the `next` node will be swapped.
-          // So when it has right, or it is a leaf node we should move it to `next`.
-          if (!hasNoRight || node._left === undefined) iter.next();
-        }
-        this._eraseNode(node);
-        return iter;
-      };
-      TreeContainer.prototype.forEach = function (callback) {
-        var e_1, _a;
-        var index = 0;
-        try {
-          for (var _b = __values(this), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var element = _c.value;
-            callback(element, index++, this);
-          }
-        } catch (e_1_1) {
-          e_1 = {
-            error: e_1_1
-          };
-        } finally {
-          try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-          } finally {
-            if (e_1) throw e_1.error;
-          }
-        }
-      };
-      TreeContainer.prototype.getElementByPos = function (pos) {
-        var e_2, _a;
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        var res;
-        var index = 0;
-        try {
-          for (var _b = __values(this), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var element = _c.value;
-            if (index === pos) {
-              res = element;
-              break;
-            }
-            index += 1;
-          }
-        } catch (e_2_1) {
-          e_2 = {
-            error: e_2_1
-          };
-        } finally {
-          try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-          } finally {
-            if (e_2) throw e_2.error;
-          }
-        }
-        return res;
-      };
-      /**
-       * @description Get the height of the tree.
-       * @returns Number about the height of the RB-tree.
-       */
-      TreeContainer.prototype.getHeight = function () {
-        if (this._length === 0) return 0;
-        var traversal = function (curNode) {
-          if (!curNode) return 0;
-          return Math.max(traversal(curNode._left), traversal(curNode._right)) + 1;
-        };
-        return traversal(this._root);
-      };
-      return TreeContainer;
-    }(Container);
-
-    var TreeIterator = /** @class */function (_super) {
-      __extends(TreeIterator, _super);
-      /**
-       * @internal
-       */
-      function TreeIterator(node, header, iteratorType) {
-        var _this = _super.call(this, iteratorType) || this;
-        _this._node = node;
-        _this._header = header;
-        if (_this.iteratorType === 0 /* IteratorType.NORMAL */) {
-          _this.pre = function () {
-            if (this._node === this._header._left) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._pre();
-            return this;
-          };
-          _this.next = function () {
-            if (this._node === this._header) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._next();
-            return this;
-          };
-        } else {
-          _this.pre = function () {
-            if (this._node === this._header._right) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._next();
-            return this;
-          };
-          _this.next = function () {
-            if (this._node === this._header) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._pre();
-            return this;
-          };
-        }
-        return _this;
-      }
-      Object.defineProperty(TreeIterator.prototype, "index", {
-        /**
-         * @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: function () {
-          var _node = this._node;
-          var root = this._header._parent;
-          if (_node === this._header) {
-            if (root) {
-              return root._subTreeSize - 1;
-            }
-            return 0;
-          }
-          var index = 0;
-          if (_node._left) {
-            index += _node._left._subTreeSize;
-          }
-          while (_node !== root) {
-            var _parent = _node._parent;
-            if (_node === _parent._right) {
-              index += 1;
-              if (_parent._left) {
-                index += _parent._left._subTreeSize;
-              }
-            }
-            _node = _parent;
-          }
-          return index;
-        },
-        enumerable: false,
-        configurable: true
-      });
-      return TreeIterator;
-    }(ContainerIterator);
-
-    var OrderedSetIterator = /** @class */function (_super) {
-      __extends(OrderedSetIterator, _super);
-      function OrderedSetIterator(node, header, container, iteratorType) {
-        var _this = _super.call(this, node, header, iteratorType) || this;
-        _this.container = container;
-        return _this;
-      }
-      Object.defineProperty(OrderedSetIterator.prototype, "pointer", {
-        get: function () {
-          if (this._node === this._header) {
-            throwIteratorAccessError();
-          }
-          return this._node._key;
-        },
-        enumerable: false,
-        configurable: true
-      });
-      OrderedSetIterator.prototype.copy = function () {
-        return new OrderedSetIterator(this._node, this._header, this.container, this.iteratorType);
-      };
-      return OrderedSetIterator;
-    }(TreeIterator);
-    var OrderedSet = /** @class */function (_super) {
-      __extends(OrderedSet, _super);
-      /**
-       * @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);
-       */
-      function OrderedSet(container, cmp, enableIndex) {
-        if (container === void 0) {
-          container = [];
-        }
-        var _this = _super.call(this, cmp, enableIndex) || this;
-        var self = _this;
-        container.forEach(function (el) {
-          self.insert(el);
-        });
-        return _this;
-      }
-      /**
-       * @internal
-       */
-      OrderedSet.prototype._iterationFunc = function (curNode) {
-        return __generator(this, function (_a) {
-          switch (_a.label) {
-            case 0:
-              if (curNode === undefined) return [2 /*return*/];
-              return [5 /*yield**/, __values(this._iterationFunc(curNode._left))];
-            case 1:
-              _a.sent();
-              return [4 /*yield*/, curNode._key];
-            case 2:
-              _a.sent();
-              return [5 /*yield**/, __values(this._iterationFunc(curNode._right))];
-            case 3:
-              _a.sent();
-              return [2 /*return*/];
-          }
-        });
-      };
-
-      OrderedSet.prototype.begin = function () {
-        return new OrderedSetIterator(this._header._left || this._header, this._header, this);
-      };
-      OrderedSet.prototype.end = function () {
-        return new OrderedSetIterator(this._header, this._header, this);
-      };
-      OrderedSet.prototype.rBegin = function () {
-        return new OrderedSetIterator(this._header._right || this._header, this._header, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      OrderedSet.prototype.rEnd = function () {
-        return new OrderedSetIterator(this._header, this._header, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      OrderedSet.prototype.front = function () {
-        return this._header._left ? this._header._left._key : undefined;
-      };
-      OrderedSet.prototype.back = function () {
-        return this._header._right ? this._header._right._key : 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.
-       */
-      OrderedSet.prototype.insert = function (key, hint) {
-        return this._set(key, undefined, hint);
-      };
-      OrderedSet.prototype.find = function (element) {
-        var resNode = this._findElementNode(this._root, element);
-        return new OrderedSetIterator(resNode, this._header, this);
-      };
-      OrderedSet.prototype.lowerBound = function (key) {
-        var resNode = this._lowerBound(this._root, key);
-        return new OrderedSetIterator(resNode, this._header, this);
-      };
-      OrderedSet.prototype.upperBound = function (key) {
-        var resNode = this._upperBound(this._root, key);
-        return new OrderedSetIterator(resNode, this._header, this);
-      };
-      OrderedSet.prototype.reverseLowerBound = function (key) {
-        var resNode = this._reverseLowerBound(this._root, key);
-        return new OrderedSetIterator(resNode, this._header, this);
-      };
-      OrderedSet.prototype.reverseUpperBound = function (key) {
-        var resNode = this._reverseUpperBound(this._root, key);
-        return new OrderedSetIterator(resNode, this._header, this);
-      };
-      OrderedSet.prototype.union = function (other) {
-        var self = this;
-        other.forEach(function (el) {
-          self.insert(el);
-        });
-        return this._length;
-      };
-      OrderedSet.prototype[Symbol.iterator] = function () {
-        return this._iterationFunc(this._root);
-      };
-      return OrderedSet;
-    }(TreeContainer);
-
-    var OrderedMapIterator = /** @class */function (_super) {
-      __extends(OrderedMapIterator, _super);
-      function OrderedMapIterator(node, header, container, iteratorType) {
-        var _this = _super.call(this, node, header, iteratorType) || this;
-        _this.container = container;
-        return _this;
-      }
-      Object.defineProperty(OrderedMapIterator.prototype, "pointer", {
-        get: function () {
-          if (this._node === this._header) {
-            throwIteratorAccessError();
-          }
-          var self = this;
-          return new Proxy([], {
-            get: function (_, props) {
-              if (props === '0') return self._node._key;else if (props === '1') return self._node._value;
-            },
-            set: function (_, props, newValue) {
-              if (props !== '1') {
-                throw new TypeError('props must be 1');
-              }
-              self._node._value = newValue;
-              return true;
-            }
-          });
-        },
-        enumerable: false,
-        configurable: true
-      });
-      OrderedMapIterator.prototype.copy = function () {
-        return new OrderedMapIterator(this._node, this._header, this.container, this.iteratorType);
-      };
-      return OrderedMapIterator;
-    }(TreeIterator);
-    var OrderedMap = /** @class */function (_super) {
-      __extends(OrderedMap, _super);
-      /**
-       * @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);
-       */
-      function OrderedMap(container, cmp, enableIndex) {
-        if (container === void 0) {
-          container = [];
-        }
-        var _this = _super.call(this, cmp, enableIndex) || this;
-        var self = _this;
-        container.forEach(function (el) {
-          self.setElement(el[0], el[1]);
-        });
-        return _this;
-      }
-      /**
-       * @internal
-       */
-      OrderedMap.prototype._iterationFunc = function (curNode) {
-        return __generator(this, function (_a) {
-          switch (_a.label) {
-            case 0:
-              if (curNode === undefined) return [2 /*return*/];
-              return [5 /*yield**/, __values(this._iterationFunc(curNode._left))];
-            case 1:
-              _a.sent();
-              return [4 /*yield*/, [curNode._key, curNode._value]];
-            case 2:
-              _a.sent();
-              return [5 /*yield**/, __values(this._iterationFunc(curNode._right))];
-            case 3:
-              _a.sent();
-              return [2 /*return*/];
-          }
-        });
-      };
-
-      OrderedMap.prototype.begin = function () {
-        return new OrderedMapIterator(this._header._left || this._header, this._header, this);
-      };
-      OrderedMap.prototype.end = function () {
-        return new OrderedMapIterator(this._header, this._header, this);
-      };
-      OrderedMap.prototype.rBegin = function () {
-        return new OrderedMapIterator(this._header._right || this._header, this._header, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      OrderedMap.prototype.rEnd = function () {
-        return new OrderedMapIterator(this._header, this._header, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      OrderedMap.prototype.front = function () {
-        if (this._length === 0) return;
-        var minNode = this._header._left;
-        return [minNode._key, minNode._value];
-      };
-      OrderedMap.prototype.back = function () {
-        if (this._length === 0) return;
-        var maxNode = this._header._right;
-        return [maxNode._key, maxNode._value];
-      };
-      OrderedMap.prototype.lowerBound = function (key) {
-        var resNode = this._lowerBound(this._root, key);
-        return new OrderedMapIterator(resNode, this._header, this);
-      };
-      OrderedMap.prototype.upperBound = function (key) {
-        var resNode = this._upperBound(this._root, key);
-        return new OrderedMapIterator(resNode, this._header, this);
-      };
-      OrderedMap.prototype.reverseLowerBound = function (key) {
-        var resNode = this._reverseLowerBound(this._root, key);
-        return new OrderedMapIterator(resNode, this._header, this);
-      };
-      OrderedMap.prototype.reverseUpperBound = function (key) {
-        var resNode = this._reverseUpperBound(this._root, key);
-        return new OrderedMapIterator(resNode, this._header, this);
-      };
-      /**
-       * @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.
-       */
-      OrderedMap.prototype.setElement = function (key, value, hint) {
-        return this._set(key, value, hint);
-      };
-      OrderedMap.prototype.find = function (key) {
-        var curNode = this._findElementNode(this._root, key);
-        return new OrderedMapIterator(curNode, this._header, this);
-      };
-      /**
-       * @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);
-       */
-      OrderedMap.prototype.getElementByKey = function (key) {
-        var curNode = this._findElementNode(this._root, key);
-        return curNode._value;
-      };
-      OrderedMap.prototype.union = function (other) {
-        var self = this;
-        other.forEach(function (el) {
-          self.setElement(el[0], el[1]);
-        });
-        return this._length;
-      };
-      OrderedMap.prototype[Symbol.iterator] = function () {
-        return this._iterationFunc(this._root);
-      };
-      return OrderedMap;
-    }(TreeContainer);
-
-    /**
-     * @description Determine whether the type of key is `object`.
-     * @param key - The key want to check.
-     * @returns Whether the type of key is `object`.
-     * @internal
-     */
-    function checkObject(key) {
-      var t = typeof key;
-      return t === 'object' && key !== null || t === 'function';
-    }
-
-    var HashContainerIterator = /** @class */function (_super) {
-      __extends(HashContainerIterator, _super);
-      /**
-       * @internal
-       */
-      function HashContainerIterator(node, header, iteratorType) {
-        var _this = _super.call(this, iteratorType) || this;
-        _this._node = node;
-        _this._header = header;
-        if (_this.iteratorType === 0 /* IteratorType.NORMAL */) {
-          _this.pre = function () {
-            if (this._node._pre === this._header) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._pre;
-            return this;
-          };
-          _this.next = function () {
-            if (this._node === this._header) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._next;
-            return this;
-          };
-        } else {
-          _this.pre = function () {
-            if (this._node._next === this._header) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._next;
-            return this;
-          };
-          _this.next = function () {
-            if (this._node === this._header) {
-              throwIteratorAccessError();
-            }
-            this._node = this._node._pre;
-            return this;
-          };
-        }
-        return _this;
-      }
-      return HashContainerIterator;
-    }(ContainerIterator);
-    var HashContainer = /** @class */function (_super) {
-      __extends(HashContainer, _super);
-      /**
-       * @internal
-       */
-      function HashContainer() {
-        var _this = _super.call(this) || this;
-        /**
-         * @internal
-         */
-        _this._objMap = [];
-        /**
-         * @internal
-         */
-        _this._originMap = {};
-        /**
-         * @description Unique symbol used to tag object.
-         */
-        _this.HASH_TAG = Symbol('@@HASH_TAG');
-        Object.setPrototypeOf(_this._originMap, null);
-        _this._header = {};
-        _this._header._pre = _this._header._next = _this._head = _this._tail = _this._header;
-        return _this;
-      }
-      /**
-       * @internal
-       */
-      HashContainer.prototype._eraseNode = function (node) {
-        var _pre = node._pre,
-          _next = node._next;
-        _pre._next = _next;
-        _next._pre = _pre;
-        if (node === this._head) {
-          this._head = _next;
-        }
-        if (node === this._tail) {
-          this._tail = _pre;
-        }
-        this._length -= 1;
-      };
-      /**
-       * @internal
-       */
-      HashContainer.prototype._set = function (key, value, isObject) {
-        if (isObject === undefined) isObject = checkObject(key);
-        var newTail;
-        if (isObject) {
-          var index = key[this.HASH_TAG];
-          if (index !== undefined) {
-            this._objMap[index]._value = value;
-            return this._length;
-          }
-          Object.defineProperty(key, this.HASH_TAG, {
-            value: this._objMap.length,
-            configurable: true
-          });
-          newTail = {
-            _key: key,
-            _value: value,
-            _pre: this._tail,
-            _next: this._header
-          };
-          this._objMap.push(newTail);
-        } else {
-          var node = this._originMap[key];
-          if (node) {
-            node._value = value;
-            return this._length;
-          }
-          newTail = {
-            _key: key,
-            _value: value,
-            _pre: this._tail,
-            _next: this._header
-          };
-          this._originMap[key] = newTail;
-        }
-        if (this._length === 0) {
-          this._head = newTail;
-          this._header._next = newTail;
-        } else {
-          this._tail._next = newTail;
-        }
-        this._tail = newTail;
-        this._header._pre = newTail;
-        return ++this._length;
-      };
-      /**
-       * @internal
-       */
-      HashContainer.prototype._findElementNode = function (key, isObject) {
-        if (isObject === undefined) isObject = checkObject(key);
-        if (isObject) {
-          var index = key[this.HASH_TAG];
-          if (index === undefined) return this._header;
-          return this._objMap[index];
-        } else {
-          return this._originMap[key] || this._header;
-        }
-      };
-      HashContainer.prototype.clear = function () {
-        var HASH_TAG = this.HASH_TAG;
-        this._objMap.forEach(function (el) {
-          delete el._key[HASH_TAG];
-        });
-        this._objMap = [];
-        this._originMap = {};
-        Object.setPrototypeOf(this._originMap, null);
-        this._length = 0;
-        this._head = this._tail = this._header._pre = this._header._next = this._header;
-      };
-      /**
-       * @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.
-       */
-      HashContainer.prototype.eraseElementByKey = function (key, isObject) {
-        var node;
-        if (isObject === undefined) isObject = checkObject(key);
-        if (isObject) {
-          var index = key[this.HASH_TAG];
-          if (index === undefined) return false;
-          delete key[this.HASH_TAG];
-          node = this._objMap[index];
-          delete this._objMap[index];
-        } else {
-          node = this._originMap[key];
-          if (node === undefined) return false;
-          delete this._originMap[key];
-        }
-        this._eraseNode(node);
-        return true;
-      };
-      HashContainer.prototype.eraseElementByIterator = function (iter) {
-        var node = iter._node;
-        if (node === this._header) {
-          throwIteratorAccessError();
-        }
-        this._eraseNode(node);
-        return iter.next();
-      };
-      HashContainer.prototype.eraseElementByPos = function (pos) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        var node = this._head;
-        while (pos--) {
-          node = node._next;
-        }
-        this._eraseNode(node);
-        return this._length;
-      };
-      return HashContainer;
-    }(Container);
-
-    var HashSetIterator = /** @class */function (_super) {
-      __extends(HashSetIterator, _super);
-      function HashSetIterator(node, header, container, iteratorType) {
-        var _this = _super.call(this, node, header, iteratorType) || this;
-        _this.container = container;
-        return _this;
-      }
-      Object.defineProperty(HashSetIterator.prototype, "pointer", {
-        get: function () {
-          if (this._node === this._header) {
-            throwIteratorAccessError();
-          }
-          return this._node._key;
-        },
-        enumerable: false,
-        configurable: true
-      });
-      HashSetIterator.prototype.copy = function () {
-        return new HashSetIterator(this._node, this._header, this.container, this.iteratorType);
-      };
-      return HashSetIterator;
-    }(HashContainerIterator);
-    var HashSet = /** @class */function (_super) {
-      __extends(HashSet, _super);
-      function HashSet(container) {
-        if (container === void 0) {
-          container = [];
-        }
-        var _this = _super.call(this) || this;
-        var self = _this;
-        container.forEach(function (el) {
-          self.insert(el);
-        });
-        return _this;
-      }
-      HashSet.prototype.begin = function () {
-        return new HashSetIterator(this._head, this._header, this);
-      };
-      HashSet.prototype.end = function () {
-        return new HashSetIterator(this._header, this._header, this);
-      };
-      HashSet.prototype.rBegin = function () {
-        return new HashSetIterator(this._tail, this._header, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      HashSet.prototype.rEnd = function () {
-        return new HashSetIterator(this._header, this._header, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      HashSet.prototype.front = function () {
-        return this._head._key;
-      };
-      HashSet.prototype.back = function () {
-        return this._tail._key;
-      };
-      /**
-       * @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.
-       */
-      HashSet.prototype.insert = function (key, isObject) {
-        return this._set(key, undefined, isObject);
-      };
-      HashSet.prototype.getElementByPos = function (pos) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        var node = this._head;
-        while (pos--) {
-          node = node._next;
-        }
-        return node._key;
-      };
-      /**
-       * @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.
-       */
-      HashSet.prototype.find = function (key, isObject) {
-        var node = this._findElementNode(key, isObject);
-        return new HashSetIterator(node, this._header, this);
-      };
-      HashSet.prototype.forEach = function (callback) {
-        var index = 0;
-        var node = this._head;
-        while (node !== this._header) {
-          callback(node._key, index++, this);
-          node = node._next;
-        }
-      };
-      HashSet.prototype[Symbol.iterator] = function () {
-        return function () {
-          var node;
-          return __generator(this, function (_a) {
-            switch (_a.label) {
-              case 0:
-                node = this._head;
-                _a.label = 1;
-              case 1:
-                if (!(node !== this._header)) return [3 /*break*/, 3];
-                return [4 /*yield*/, node._key];
-              case 2:
-                _a.sent();
-                node = node._next;
-                return [3 /*break*/, 1];
-              case 3:
-                return [2 /*return*/];
-            }
-          });
-        }.bind(this)();
-      };
-      return HashSet;
-    }(HashContainer);
-
-    var HashMapIterator = /** @class */function (_super) {
-      __extends(HashMapIterator, _super);
-      function HashMapIterator(node, header, container, iteratorType) {
-        var _this = _super.call(this, node, header, iteratorType) || this;
-        _this.container = container;
-        return _this;
-      }
-      Object.defineProperty(HashMapIterator.prototype, "pointer", {
-        get: function () {
-          if (this._node === this._header) {
-            throwIteratorAccessError();
-          }
-          var self = this;
-          return new Proxy([], {
-            get: function (_, props) {
-              if (props === '0') return self._node._key;else if (props === '1') return self._node._value;
-            },
-            set: function (_, props, newValue) {
-              if (props !== '1') {
-                throw new TypeError('props must be 1');
-              }
-              self._node._value = newValue;
-              return true;
-            }
-          });
-        },
-        enumerable: false,
-        configurable: true
-      });
-      HashMapIterator.prototype.copy = function () {
-        return new HashMapIterator(this._node, this._header, this.container, this.iteratorType);
-      };
-      return HashMapIterator;
-    }(HashContainerIterator);
-    var HashMap = /** @class */function (_super) {
-      __extends(HashMap, _super);
-      function HashMap(container) {
-        if (container === void 0) {
-          container = [];
-        }
-        var _this = _super.call(this) || this;
-        var self = _this;
-        container.forEach(function (el) {
-          self.setElement(el[0], el[1]);
-        });
-        return _this;
-      }
-      HashMap.prototype.begin = function () {
-        return new HashMapIterator(this._head, this._header, this);
-      };
-      HashMap.prototype.end = function () {
-        return new HashMapIterator(this._header, this._header, this);
-      };
-      HashMap.prototype.rBegin = function () {
-        return new HashMapIterator(this._tail, this._header, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      HashMap.prototype.rEnd = function () {
-        return new HashMapIterator(this._header, this._header, this, 1 /* IteratorType.REVERSE */);
-      };
-
-      HashMap.prototype.front = function () {
-        if (this._length === 0) return;
-        return [this._head._key, this._head._value];
-      };
-      HashMap.prototype.back = function () {
-        if (this._length === 0) return;
-        return [this._tail._key, this._tail._value];
-      };
-      /**
-       * @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.
-       */
-      HashMap.prototype.setElement = function (key, value, isObject) {
-        return this._set(key, value, isObject);
-      };
-      /**
-       * @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);
-       */
-      HashMap.prototype.getElementByKey = function (key, isObject) {
-        if (isObject === undefined) isObject = checkObject(key);
-        if (isObject) {
-          var index = key[this.HASH_TAG];
-          return index !== undefined ? this._objMap[index]._value : undefined;
-        }
-        var node = this._originMap[key];
-        return node ? node._value : undefined;
-      };
-      HashMap.prototype.getElementByPos = function (pos) {
-        if (pos < 0 || pos > this._length - 1) {
-          throw new RangeError();
-        }
-        var node = this._head;
-        while (pos--) {
-          node = node._next;
-        }
-        return [node._key, node._value];
-      };
-      /**
-       * @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.
-       */
-      HashMap.prototype.find = function (key, isObject) {
-        var node = this._findElementNode(key, isObject);
-        return new HashMapIterator(node, this._header, this);
-      };
-      HashMap.prototype.forEach = function (callback) {
-        var index = 0;
-        var node = this._head;
-        while (node !== this._header) {
-          callback([node._key, node._value], index++, this);
-          node = node._next;
-        }
-      };
-      HashMap.prototype[Symbol.iterator] = function () {
-        return function () {
-          var node;
-          return __generator(this, function (_a) {
-            switch (_a.label) {
-              case 0:
-                node = this._head;
-                _a.label = 1;
-              case 1:
-                if (!(node !== this._header)) return [3 /*break*/, 3];
-                return [4 /*yield*/, [node._key, node._value]];
-              case 2:
-                _a.sent();
-                node = node._next;
-                return [3 /*break*/, 1];
-              case 3:
-                return [2 /*return*/];
-            }
-          });
-        }.bind(this)();
-      };
-      return HashMap;
-    }(HashContainer);
-
-    exports.Deque = Deque;
-    exports.HashMap = HashMap;
-    exports.HashSet = HashSet;
-    exports.LinkList = LinkList;
-    exports.OrderedMap = OrderedMap;
-    exports.OrderedSet = OrderedSet;
-    exports.PriorityQueue = PriorityQueue;
-    exports.Queue = Queue;
-    exports.Stack = Stack;
-    exports.Vector = Vector;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));