data-structure-typed 2.5.0 → 2.5.2

package/dist/leetcode/tree-counter.mjs

@@ -1,3039 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-function isPrimitiveComparable(value) {
-  const valueType = typeof value;
-  if (valueType === "number") return true;
-  return valueType === "bigint" || valueType === "string" || valueType === "boolean";
-}
-__name(isPrimitiveComparable, "isPrimitiveComparable");
-function tryObjectToPrimitive(obj) {
-  if (typeof obj.valueOf === "function") {
-    const valueOfResult = obj.valueOf();
-    if (valueOfResult !== obj) {
-      if (isPrimitiveComparable(valueOfResult)) return valueOfResult;
-      if (typeof valueOfResult === "object" && valueOfResult !== null) return tryObjectToPrimitive(valueOfResult);
-    }
-  }
-  if (typeof obj.toString === "function") {
-    const stringResult = obj.toString();
-    if (stringResult !== "[object Object]") return stringResult;
-  }
-  return null;
-}
-__name(tryObjectToPrimitive, "tryObjectToPrimitive");
-function isComparable(value, isForceObjectComparable = false) {
-  if (value === null || value === void 0) return false;
-  if (isPrimitiveComparable(value)) return true;
-  if (typeof value !== "object") return false;
-  if (value instanceof Date) return true;
-  if (isForceObjectComparable) return true;
-  const comparableValue = tryObjectToPrimitive(value);
-  if (comparableValue === null || comparableValue === void 0) return false;
-  return isPrimitiveComparable(comparableValue);
-}
-__name(isComparable, "isComparable");
-var makeTrampolineThunk =  __name((computation) => ({
-  isThunk: true,
-  fn: computation
-}), "makeTrampolineThunk");
-var isTrampolineThunk =  __name((value) => typeof value === "object" && // Must be an object
-value !== null && // Must not be null
-"isThunk" in value && // Must have the 'isThunk' property
-value.isThunk, "isTrampolineThunk");
-function trampoline(initial) {
-  let current = initial;
-  while (isTrampolineThunk(current)) {
-    current = current.fn();
-  }
-  return current;
-}
-__name(trampoline, "trampoline");
-function makeTrampoline(fn) {
-  return (...args) => trampoline(fn(...args));
-}
-__name(makeTrampoline, "makeTrampoline");
-var IterableElementBase = class {
-  static {
-    __name(this, "IterableElementBase");
-  }
-  constructor(options) {
-    if (options) {
-      const { toElementFn } = options;
-      if (typeof toElementFn === "function") this._toElementFn = toElementFn;
-      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
-    }
-  }
-  _toElementFn;
-  get toElementFn() {
-    return this._toElementFn;
-  }
-  *[Symbol.iterator](...args) {
-    yield* this._getIterator(...args);
-  }
-  *values() {
-    for (const item of this) yield item;
-  }
-  every(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (thisArg === void 0) {
-        if (!predicate(item, index++, this)) return false;
-      } else {
-        const fn = predicate;
-        if (!fn.call(thisArg, item, index++, this)) return false;
-      }
-    }
-    return true;
-  }
-  some(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (thisArg === void 0) {
-        if (predicate(item, index++, this)) return true;
-      } else {
-        const fn = predicate;
-        if (fn.call(thisArg, item, index++, this)) return true;
-      }
-    }
-    return false;
-  }
-  forEach(callbackfn, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (thisArg === void 0) {
-        callbackfn(item, index++, this);
-      } else {
-        const fn = callbackfn;
-        fn.call(thisArg, item, index++, this);
-      }
-    }
-  }
-  find(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (thisArg === void 0) {
-        if (predicate(item, index++, this)) return item;
-      } else {
-        const fn = predicate;
-        if (fn.call(thisArg, item, index++, this)) return item;
-      }
-    }
-    return;
-  }
-  has(element) {
-    for (const ele of this) if (ele === element) return true;
-    return false;
-  }
-  reduce(callbackfn, initialValue) {
-    let index = 0;
-    const iter = this[Symbol.iterator]();
-    let acc;
-    if (arguments.length >= 2) {
-      acc = initialValue;
-    } else {
-      const first = iter.next();
-      if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
-      acc = first.value;
-      index = 1;
-    }
-    for (const value of iter) {
-      acc = callbackfn(acc, value, index++, this);
-    }
-    return acc;
-  }
-  toArray() {
-    return [...this];
-  }
-  toVisual() {
-    return [...this];
-  }
-  print() {
-    console.log(this.toVisual());
-  }
-};
-var LinearBase = class _LinearBase extends IterableElementBase {
-  static {
-    __name(this, "LinearBase");
-  }
-  constructor(options) {
-    super(options);
-    if (options) {
-      const { maxLen } = options;
-      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
-    }
-  }
-  _maxLen = -1;
-  get maxLen() {
-    return this._maxLen;
-  }
-  indexOf(searchElement, fromIndex = 0) {
-    if (this.length === 0) return -1;
-    if (fromIndex < 0) fromIndex = this.length + fromIndex;
-    if (fromIndex < 0) fromIndex = 0;
-    for (let i = fromIndex; i < this.length; i++) {
-      const element = this.at(i);
-      if (element === searchElement) return i;
-    }
-    return -1;
-  }
-  lastIndexOf(searchElement, fromIndex = this.length - 1) {
-    if (this.length === 0) return -1;
-    if (fromIndex >= this.length) fromIndex = this.length - 1;
-    if (fromIndex < 0) fromIndex = this.length + fromIndex;
-    for (let i = fromIndex; i >= 0; i--) {
-      const element = this.at(i);
-      if (element === searchElement) return i;
-    }
-    return -1;
-  }
-  findIndex(predicate, thisArg) {
-    for (let i = 0; i < this.length; i++) {
-      const item = this.at(i);
-      if (item !== void 0 && predicate.call(thisArg, item, i, this)) return i;
-    }
-    return -1;
-  }
-  concat(...items) {
-    const newList = this.clone();
-    for (const item of items) {
-      if (item instanceof _LinearBase) {
-        newList.pushMany(item);
-      } else {
-        newList.push(item);
-      }
-    }
-    return newList;
-  }
-  sort(compareFn) {
-    const arr = this.toArray();
-    arr.sort(compareFn);
-    this.clear();
-    for (const item of arr) this.push(item);
-    return this;
-  }
-  splice(start, deleteCount = 0, ...items) {
-    const removedList = this._createInstance();
-    start = start < 0 ? this.length + start : start;
-    start = Math.max(0, Math.min(start, this.length));
-    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
-    for (let i = 0; i < deleteCount; i++) {
-      const removed = this.deleteAt(start);
-      if (removed !== void 0) {
-        removedList.push(removed);
-      }
-    }
-    for (let i = 0; i < items.length; i++) {
-      this.addAt(start + i, items[i]);
-    }
-    return removedList;
-  }
-  join(separator = ",") {
-    return this.toArray().join(separator);
-  }
-  toReversedArray() {
-    const array = [];
-    for (let i = this.length - 1; i >= 0; i--) {
-      array.push(this.at(i));
-    }
-    return array;
-  }
-  reduceRight(callbackfn, initialValue) {
-    let accumulator = initialValue ?? 0;
-    for (let i = this.length - 1; i >= 0; i--) {
-      accumulator = callbackfn(accumulator, this.at(i), i, this);
-    }
-    return accumulator;
-  }
-  slice(start = 0, end = this.length) {
-    start = start < 0 ? this.length + start : start;
-    end = end < 0 ? this.length + end : end;
-    const newList = this._createInstance();
-    for (let i = start; i < end; i++) {
-      newList.push(this.at(i));
-    }
-    return newList;
-  }
-  fill(value, start = 0, end = this.length) {
-    start = start < 0 ? this.length + start : start;
-    end = end < 0 ? this.length + end : end;
-    if (start < 0) start = 0;
-    if (end > this.length) end = this.length;
-    if (start >= end) return this;
-    for (let i = start; i < end; i++) {
-      this.setAt(i, value);
-    }
-    return this;
-  }
-};
-var Queue = class _Queue extends LinearBase {
-  static {
-    __name(this, "Queue");
-  }
-  constructor(elements = [], options) {
-    super(options);
-    if (options) {
-      const { autoCompactRatio = 0.5 } = options;
-      this._autoCompactRatio = autoCompactRatio;
-    }
-    this.pushMany(elements);
-  }
-  _elements = [];
-  get elements() {
-    return this._elements;
-  }
-  _offset = 0;
-  get offset() {
-    return this._offset;
-  }
-  _autoCompactRatio = 0.5;
-  get autoCompactRatio() {
-    return this._autoCompactRatio;
-  }
-  set autoCompactRatio(value) {
-    this._autoCompactRatio = value;
-  }
-  get length() {
-    return this.elements.length - this._offset;
-  }
-  get first() {
-    return this.length > 0 ? this.elements[this._offset] : void 0;
-  }
-  get last() {
-    return this.length > 0 ? this.elements[this.elements.length - 1] : void 0;
-  }
-  static fromArray(elements) {
-    return new _Queue(elements);
-  }
-  isEmpty() {
-    return this.length === 0;
-  }
-  push(element) {
-    this.elements.push(element);
-    if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
-    return true;
-  }
-  pushMany(elements) {
-    const ans = [];
-    for (const el of elements) {
-      if (this.toElementFn) ans.push(this.push(this.toElementFn(el)));
-      else ans.push(this.push(el));
-    }
-    return ans;
-  }
-  shift() {
-    if (this.length === 0) return void 0;
-    const first = this.first;
-    this._offset += 1;
-    if (this.elements.length > 0 && this.offset / this.elements.length > this.autoCompactRatio) this.compact();
-    return first;
-  }
-  delete(element) {
-    for (let i = this._offset; i < this.elements.length; i++) {
-      if (Object.is(this.elements[i], element)) {
-        this.elements.splice(i, 1);
-        return true;
-      }
-    }
-    return false;
-  }
-  at(index) {
-    if (index < 0 || index >= this.length) return void 0;
-    return this._elements[this._offset + index];
-  }
-  deleteAt(index) {
-    if (index < 0 || index >= this.length) return void 0;
-    const gi = this._offset + index;
-    const [deleted] = this.elements.splice(gi, 1);
-    return deleted;
-  }
-  addAt(index, newElement) {
-    if (index < 0 || index > this.length) return false;
-    this._elements.splice(this._offset + index, 0, newElement);
-    return true;
-  }
-  setAt(index, newElement) {
-    if (index < 0 || index >= this.length) return false;
-    this._elements[this._offset + index] = newElement;
-    return true;
-  }
-  reverse() {
-    this._elements = this.elements.slice(this._offset).reverse();
-    this._offset = 0;
-    return this;
-  }
-  clear() {
-    this._elements = [];
-    this._offset = 0;
-  }
-  compact() {
-    this._elements = this.elements.slice(this._offset);
-    this._offset = 0;
-    return true;
-  }
-  splice(start, deleteCount = 0, ...items) {
-    start = Math.max(0, Math.min(start, this.length));
-    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
-    const gi = this._offset + start;
-    const removedArray = this._elements.splice(gi, deleteCount, ...items);
-    if (this.elements.length > 0 && this.offset / this.elements.length > this.autoCompactRatio) this.compact();
-    const removed = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
-    removed._setAutoCompactRatio(this._autoCompactRatio);
-    removed.pushMany(removedArray);
-    return removed;
-  }
-  clone() {
-    const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
-    out._setAutoCompactRatio(this._autoCompactRatio);
-    for (let i = this._offset; i < this.elements.length; i++) out.push(this.elements[i]);
-    return out;
-  }
-  filter(predicate, thisArg) {
-    const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
-    out._setAutoCompactRatio(this._autoCompactRatio);
-    let index = 0;
-    for (const v of this) {
-      if (predicate.call(thisArg, v, index, this)) out.push(v);
-      index++;
-    }
-    return out;
-  }
-  map(callback, options, thisArg) {
-    const out = new this.constructor([], {
-      toElementFn: options?.toElementFn,
-      maxLen: options?.maxLen ?? this._maxLen,
-      autoCompactRatio: options?.autoCompactRatio ?? this._autoCompactRatio
-    });
-    let index = 0;
-    for (const v of this)
-      out.push(thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this));
-    return out;
-  }
-  mapSame(callback, thisArg) {
-    const Ctor = this.constructor;
-    const out = new Ctor([], {
-      toElementFn: this.toElementFn,
-      maxLen: this._maxLen,
-      autoCompactRatio: this._autoCompactRatio
-    });
-    out._setAutoCompactRatio?.(this._autoCompactRatio);
-    let index = 0;
-    for (const v of this) {
-      const mv = thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this);
-      out.push(mv);
-    }
-    return out;
-  }
-  _setAutoCompactRatio(value) {
-    this._autoCompactRatio = value;
-  }
-  *_getIterator() {
-    for (let i = this._offset; i < this.elements.length; i++) yield this.elements[i];
-  }
-  *_getReverseIterator() {
-    for (let i = this.length - 1; i >= 0; i--) {
-      const cur = this.at(i);
-      if (cur !== void 0) yield cur;
-    }
-  }
-  _createInstance(options) {
-    const Ctor = this.constructor;
-    return new Ctor([], options);
-  }
-  _createLike(elements = [], options) {
-    const Ctor = this.constructor;
-    return new Ctor(elements, options);
-  }
-};
-var IterableEntryBase = class {
-  static {
-    __name(this, "IterableEntryBase");
-  }
-  *[Symbol.iterator](...args) {
-    yield* this._getIterator(...args);
-  }
-  *entries() {
-    for (const item of this) {
-      yield item;
-    }
-  }
-  *keys() {
-    for (const item of this) {
-      yield item[0];
-    }
-  }
-  *values() {
-    for (const item of this) {
-      yield item[1];
-    }
-  }
-  every(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  some(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (predicate.call(thisArg, item[1], item[0], index++, this)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  forEach(callbackfn, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      const [key, value] = item;
-      callbackfn.call(thisArg, value, key, index++, this);
-    }
-  }
-  find(callbackfn, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      const [key, value] = item;
-      if (callbackfn.call(thisArg, value, key, index++, this)) return item;
-    }
-    return;
-  }
-  has(key) {
-    for (const item of this) {
-      const [itemKey] = item;
-      if (itemKey === key) return true;
-    }
-    return false;
-  }
-  hasValue(value) {
-    for (const [, elementValue] of this) {
-      if (elementValue === value) return true;
-    }
-    return false;
-  }
-  get(key) {
-    for (const item of this) {
-      const [itemKey, value] = item;
-      if (itemKey === key) return value;
-    }
-    return;
-  }
-  reduce(callbackfn, initialValue) {
-    let accumulator = initialValue;
-    let index = 0;
-    for (const item of this) {
-      const [key, value] = item;
-      accumulator = callbackfn(accumulator, value, key, index++, this);
-    }
-    return accumulator;
-  }
-  toArray() {
-    return [...this];
-  }
-  toVisual() {
-    return [...this];
-  }
-  print() {
-    console.log(this.toVisual());
-  }
-};
-var Range = class {
-  constructor(low, high, includeLow = true, includeHigh = true) {
-    this.low = low;
-    this.high = high;
-    this.includeLow = includeLow;
-    this.includeHigh = includeHigh;
-  }
-  static {
-    __name(this, "Range");
-  }
-  isInRange(key, comparator) {
-    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-    return lowCheck && highCheck;
-  }
-};
-var BinaryTreeNode = class {
-  static {
-    __name(this, "BinaryTreeNode");
-  }
-  key;
-  value;
-  parent = void 0;
-  constructor(key, value) {
-    this.key = key;
-    this.value = value;
-  }
-  _left = void 0;
-  get left() {
-    return this._left;
-  }
-  set left(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._left = v;
-  }
-  _right = void 0;
-  get right() {
-    return this._right;
-  }
-  set right(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._right = v;
-  }
-  _height = 0;
-  get height() {
-    return this._height;
-  }
-  set height(value) {
-    this._height = value;
-  }
-  _color = "BLACK";
-  get color() {
-    return this._color;
-  }
-  set color(value) {
-    this._color = value;
-  }
-  _count = 1;
-  get count() {
-    return this._count;
-  }
-  set count(value) {
-    this._count = value;
-  }
-  get familyPosition() {
-    if (!this.parent) {
-      return this.left || this.right ? "ROOT" : "ISOLATED";
-    }
-    if (this.parent.left === this) {
-      return this.left || this.right ? "ROOT_LEFT" : "LEFT";
-    } else if (this.parent.right === this) {
-      return this.left || this.right ? "ROOT_RIGHT" : "RIGHT";
-    }
-    return "MAL_NODE";
-  }
-};
-var BinaryTree = class extends IterableEntryBase {
-  static {
-    __name(this, "BinaryTree");
-  }
-  iterationType = "ITERATIVE";
-  constructor(keysNodesEntriesOrRaws = [], options) {
-    super();
-    if (options) {
-      const { iterationType, toEntryFn, isMapMode, isDuplicate } = options;
-      if (iterationType) this.iterationType = iterationType;
-      if (isMapMode !== void 0) this._isMapMode = isMapMode;
-      if (isDuplicate !== void 0) this._isDuplicate = isDuplicate;
-      if (typeof toEntryFn === "function") this._toEntryFn = toEntryFn;
-      else if (toEntryFn) throw TypeError("toEntryFn must be a function type");
-    }
-    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
-  }
-  _isMapMode = true;
-  get isMapMode() {
-    return this._isMapMode;
-  }
-  _isDuplicate = false;
-  get isDuplicate() {
-    return this._isDuplicate;
-  }
-  _store =  new Map();
-  get store() {
-    return this._store;
-  }
-  _root;
-  get root() {
-    return this._root;
-  }
-  _size = 0;
-  get size() {
-    return this._size;
-  }
-  _NIL = new BinaryTreeNode(NaN);
-  get NIL() {
-    return this._NIL;
-  }
-  _toEntryFn;
-  get toEntryFn() {
-    return this._toEntryFn;
-  }
-  createNode(key, value) {
-    return new BinaryTreeNode(key, this._isMapMode ? void 0 : value);
-  }
-  createTree(options) {
-    return this._createInstance(options);
-  }
-  ensureNode(keyNodeOrEntry, iterationType = this.iterationType) {
-    if (keyNodeOrEntry === null) return null;
-    if (keyNodeOrEntry === void 0) return;
-    if (keyNodeOrEntry === this._NIL) return;
-    if (this.isNode(keyNodeOrEntry)) return keyNodeOrEntry;
-    if (this.isEntry(keyNodeOrEntry)) {
-      const key = keyNodeOrEntry[0];
-      if (key === null) return null;
-      if (key === void 0) return;
-      return this.getNode(key, this._root, iterationType);
-    }
-    return this.getNode(keyNodeOrEntry, this._root, iterationType);
-  }
-  isNode(keyNodeOrEntry) {
-    return keyNodeOrEntry instanceof BinaryTreeNode;
-  }
-  isRaw(keyNodeEntryOrRaw) {
-    return this._toEntryFn !== void 0 && typeof keyNodeEntryOrRaw === "object";
-  }
-  isRealNode(keyNodeOrEntry) {
-    if (keyNodeOrEntry === this._NIL || keyNodeOrEntry === null || keyNodeOrEntry === void 0) return false;
-    return this.isNode(keyNodeOrEntry);
-  }
-  isRealNodeOrNull(keyNodeOrEntry) {
-    return keyNodeOrEntry === null || this.isRealNode(keyNodeOrEntry);
-  }
-  isNIL(keyNodeOrEntry) {
-    return keyNodeOrEntry === this._NIL;
-  }
-  isRange(keyNodeEntryOrPredicate) {
-    return keyNodeEntryOrPredicate instanceof Range;
-  }
-  isLeaf(keyNodeOrEntry) {
-    keyNodeOrEntry = this.ensureNode(keyNodeOrEntry);
-    if (keyNodeOrEntry === void 0) return false;
-    if (keyNodeOrEntry === null) return true;
-    return !this.isRealNode(keyNodeOrEntry.left) && !this.isRealNode(keyNodeOrEntry.right);
-  }
-  isEntry(keyNodeOrEntry) {
-    return Array.isArray(keyNodeOrEntry) && keyNodeOrEntry.length === 2;
-  }
-  isValidKey(key) {
-    if (key === null) return true;
-    return isComparable(key);
-  }
-  add(keyNodeOrEntry) {
-    return this.set(keyNodeOrEntry);
-  }
-  set(keyNodeOrEntry, value) {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
-    if (newNode === void 0) return false;
-    if (!this._root) {
-      this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
-      this._size = 1;
-      return true;
-    }
-    const queue = new Queue([this._root]);
-    let potentialParent;
-    while (queue.length > 0) {
-      const cur = queue.shift();
-      if (!cur) continue;
-      if (!this._isDuplicate) {
-        if (newNode !== null && cur.key === newNode.key) {
-          this._replaceNode(cur, newNode);
-          if (this._isMapMode) this._setValue(cur.key, newValue);
-          return true;
-        }
-      }
-      if (potentialParent === void 0 && (cur.left === void 0 || cur.right === void 0)) {
-        potentialParent = cur;
-      }
-      if (cur.left !== null) {
-        if (cur.left) queue.push(cur.left);
-      }
-      if (cur.right !== null) {
-        if (cur.right) queue.push(cur.right);
-      }
-    }
-    if (potentialParent) {
-      if (potentialParent.left === void 0) {
-        potentialParent.left = newNode;
-      } else if (potentialParent.right === void 0) {
-        potentialParent.right = newNode;
-      }
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
-      this._size++;
-      return true;
-    }
-    return false;
-  }
-  addMany(keysNodesEntriesOrRaws) {
-    return this.setMany(keysNodesEntriesOrRaws);
-  }
-  setMany(keysNodesEntriesOrRaws, values) {
-    const inserted = [];
-    let valuesIterator;
-    if (values) {
-      valuesIterator = values[Symbol.iterator]();
-    }
-    for (let keyNodeEntryOrRaw of keysNodesEntriesOrRaws) {
-      let value = void 0;
-      if (valuesIterator) {
-        const valueResult = valuesIterator.next();
-        if (!valueResult.done) {
-          value = valueResult.value;
-        }
-      }
-      if (this.isRaw(keyNodeEntryOrRaw)) keyNodeEntryOrRaw = this._toEntryFn(keyNodeEntryOrRaw);
-      inserted.push(this.set(keyNodeEntryOrRaw, value));
-    }
-    return inserted;
-  }
-  merge(anotherTree) {
-    this.setMany(anotherTree, []);
-  }
-  refill(keysNodesEntriesOrRaws, values) {
-    this.clear();
-    this.setMany(keysNodesEntriesOrRaws, values);
-  }
-  delete(keyNodeOrEntry) {
-    const deletedResult = [];
-    if (!this._root) return deletedResult;
-    const curr = this.getNode(keyNodeOrEntry);
-    if (!curr) return deletedResult;
-    const parent = curr?.parent;
-    let needBalanced;
-    let orgCurrent = curr;
-    if (!curr.left && !curr.right && !parent) {
-      this._setRoot(void 0);
-    } else if (curr.left) {
-      const leftSubTreeRightMost = this.getRightMost((node) => node, curr.left);
-      if (leftSubTreeRightMost) {
-        const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-        orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
-        if (parentOfLeftSubTreeMax) {
-          if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
-            parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
-          else parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
-          needBalanced = parentOfLeftSubTreeMax;
-        }
-      }
-    } else if (parent) {
-      const { familyPosition: fp } = curr;
-      if (fp === "LEFT" || fp === "ROOT_LEFT") {
-        parent.left = curr.right;
-      } else if (fp === "RIGHT" || fp === "ROOT_RIGHT") {
-        parent.right = curr.right;
-      }
-      needBalanced = parent;
-    } else {
-      this._setRoot(curr.right);
-      curr.right = void 0;
-    }
-    this._size = this._size - 1;
-    deletedResult.push({ deleted: orgCurrent, needBalanced });
-    if (this._isMapMode && orgCurrent) this._store.delete(orgCurrent.key);
-    return deletedResult;
-  }
-  search(keyNodeEntryOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    if (keyNodeEntryOrPredicate === void 0) return [];
-    if (keyNodeEntryOrPredicate === null) return [];
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    const predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
-    const ans = [];
-    if (iterationType === "RECURSIVE") {
-      const dfs =  __name((cur) => {
-        if (predicate(cur)) {
-          ans.push(callback(cur));
-          if (onlyOne) return;
-        }
-        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
-        if (this.isRealNode(cur.left)) dfs(cur.left);
-        if (this.isRealNode(cur.right)) dfs(cur.right);
-      }, "dfs");
-      dfs(startNode);
-    } else {
-      const stack = [startNode];
-      while (stack.length > 0) {
-        const cur = stack.pop();
-        if (this.isRealNode(cur)) {
-          if (predicate(cur)) {
-            ans.push(callback(cur));
-            if (onlyOne) return ans;
-          }
-          if (this.isRealNode(cur.left)) stack.push(cur.left);
-          if (this.isRealNode(cur.right)) stack.push(cur.right);
-        }
-      }
-    }
-    return ans;
-  }
-  getNodes(keyNodeEntryOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
-    return this.search(keyNodeEntryOrPredicate, onlyOne, (node) => node, startNode, iterationType);
-  }
-  getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType)[0];
-  }
-  get(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    if (this._isMapMode) {
-      const key = this._extractKey(keyNodeEntryOrPredicate);
-      if (key === null || key === void 0) return;
-      return this._store.get(key);
-    }
-    return this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)?.value;
-  }
-  has(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType).length > 0;
-  }
-  clear() {
-    this._clearNodes();
-    if (this._isMapMode) this._clearValues();
-  }
-  isEmpty() {
-    return this._size === 0;
-  }
-  isPerfectlyBalanced(startNode = this._root) {
-    return this.getMinHeight(startNode) + 1 >= this.getHeight(startNode);
-  }
-  isBST(startNode = this._root, iterationType = this.iterationType) {
-    const startNodeSired = this.ensureNode(startNode);
-    if (!startNodeSired) return true;
-    if (iterationType === "RECURSIVE") {
-      const dfs =  __name((cur, min, max) => {
-        if (!this.isRealNode(cur)) return true;
-        const numKey = Number(cur.key);
-        if (numKey <= min || numKey >= max) return false;
-        return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
-      }, "dfs");
-      const isStandardBST = dfs(startNodeSired, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-      const isInverseBST = dfs(startNodeSired, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
-      return isStandardBST || isInverseBST;
-    } else {
-      const checkBST =  __name((checkMax = false) => {
-        const stack = [];
-        let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
-        let curr = startNodeSired;
-        while (this.isRealNode(curr) || stack.length > 0) {
-          while (this.isRealNode(curr)) {
-            stack.push(curr);
-            curr = curr.left;
-          }
-          curr = stack.pop();
-          const numKey = Number(curr.key);
-          if (!this.isRealNode(curr) || !checkMax && prev >= numKey || checkMax && prev <= numKey) return false;
-          prev = numKey;
-          curr = curr.right;
-        }
-        return true;
-      }, "checkBST");
-      const isStandardBST = checkBST(false);
-      const isInverseBST = checkBST(true);
-      return isStandardBST || isInverseBST;
-    }
-  }
-  getDepth(dist, startNode = this._root) {
-    let distEnsured = this.ensureNode(dist);
-    const beginRootEnsured = this.ensureNode(startNode);
-    let depth = 0;
-    while (distEnsured?.parent) {
-      if (distEnsured === beginRootEnsured) {
-        return depth;
-      }
-      depth++;
-      distEnsured = distEnsured.parent;
-    }
-    return depth;
-  }
-  getHeight(startNode = this._root, iterationType = this.iterationType) {
-    startNode = this.ensureNode(startNode);
-    if (!this.isRealNode(startNode)) return -1;
-    if (iterationType === "RECURSIVE") {
-      const _getMaxHeight =  __name((cur) => {
-        if (!this.isRealNode(cur)) return -1;
-        const leftHeight = _getMaxHeight(cur.left);
-        const rightHeight = _getMaxHeight(cur.right);
-        return Math.max(leftHeight, rightHeight) + 1;
-      }, "_getMaxHeight");
-      return _getMaxHeight(startNode);
-    } else {
-      const stack = [{ node: startNode, depth: 0 }];
-      let maxHeight = 0;
-      while (stack.length > 0) {
-        const { node, depth } = stack.pop();
-        if (this.isRealNode(node.left)) stack.push({ node: node.left, depth: depth + 1 });
-        if (this.isRealNode(node.right)) stack.push({ node: node.right, depth: depth + 1 });
-        maxHeight = Math.max(maxHeight, depth);
-      }
-      return maxHeight;
-    }
-  }
-  getMinHeight(startNode = this._root, iterationType = this.iterationType) {
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return -1;
-    if (iterationType === "RECURSIVE") {
-      const _getMinHeight =  __name((cur) => {
-        if (!this.isRealNode(cur)) return 0;
-        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return 0;
-        const leftMinHeight = _getMinHeight(cur.left);
-        const rightMinHeight = _getMinHeight(cur.right);
-        return Math.min(leftMinHeight, rightMinHeight) + 1;
-      }, "_getMinHeight");
-      return _getMinHeight(startNode);
-    } else {
-      const stack = [];
-      let node = startNode, last = null;
-      const depths =  new Map();
-      while (stack.length > 0 || node) {
-        if (this.isRealNode(node)) {
-          stack.push(node);
-          node = node.left;
-        } else {
-          node = stack[stack.length - 1];
-          if (!this.isRealNode(node.right) || last === node.right) {
-            node = stack.pop();
-            if (this.isRealNode(node)) {
-              const leftMinHeight = this.isRealNode(node.left) ? depths.get(node.left) : -1;
-              const rightMinHeight = this.isRealNode(node.right) ? depths.get(node.right) : -1;
-              depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
-              last = node;
-              node = null;
-            }
-          } else node = node.right;
-        }
-      }
-      return depths.get(startNode);
-    }
-  }
-  getPathToRoot(beginNode, callback = this._DEFAULT_NODE_CALLBACK, isReverse = false) {
-    const result = [];
-    let beginNodeEnsured = this.ensureNode(beginNode);
-    if (!beginNodeEnsured) return result;
-    while (beginNodeEnsured.parent) {
-      result.push(callback(beginNodeEnsured));
-      beginNodeEnsured = beginNodeEnsured.parent;
-    }
-    result.push(callback(beginNodeEnsured));
-    return isReverse ? result.reverse() : result;
-  }
-  getLeftMost(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    if (this.isNIL(startNode)) return callback(void 0);
-    const ensuredStartNode = this.ensureNode(startNode);
-    if (!this.isRealNode(ensuredStartNode)) return callback(void 0);
-    if (iterationType === "RECURSIVE") {
-      const dfs =  __name((cur) => {
-        const { left } = cur;
-        if (!this.isRealNode(left)) return cur;
-        return dfs(left);
-      }, "dfs");
-      return callback(dfs(ensuredStartNode));
-    } else {
-      const dfs = makeTrampoline((cur) => {
-        const { left } = cur;
-        if (!this.isRealNode(left)) return cur;
-        return makeTrampolineThunk(() => dfs(left));
-      });
-      return callback(dfs(ensuredStartNode));
-    }
-  }
-  getRightMost(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    if (this.isNIL(startNode)) return callback(void 0);
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return callback(void 0);
-    if (iterationType === "RECURSIVE") {
-      const dfs =  __name((cur) => {
-        const { right } = cur;
-        if (!this.isRealNode(right)) return cur;
-        return dfs(right);
-      }, "dfs");
-      return callback(dfs(startNode));
-    } else {
-      const dfs = makeTrampoline((cur) => {
-        const { right } = cur;
-        if (!this.isRealNode(right)) return cur;
-        return makeTrampolineThunk(() => dfs(right));
-      });
-      return callback(dfs(startNode));
-    }
-  }
-  getPredecessor(node) {
-    if (this.isRealNode(node.left)) {
-      let predecessor = node.left;
-      while (!this.isRealNode(predecessor) || this.isRealNode(predecessor.right) && predecessor.right !== node) {
-        if (this.isRealNode(predecessor)) {
-          predecessor = predecessor.right;
-        }
-      }
-      return predecessor;
-    } else {
-      return node;
-    }
-  }
-  getSuccessor(x) {
-    x = this.ensureNode(x);
-    if (!this.isRealNode(x)) return void 0;
-    if (this.isRealNode(x.right)) {
-      return this.getLeftMost((node) => node, x.right);
-    }
-    let y = x.parent;
-    while (this.isRealNode(y) && x === y.right) {
-      x = y;
-      y = y.parent;
-    }
-    return y;
-  }
-  dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", onlyOne = false, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    return this._dfs(callback, pattern, onlyOne, startNode, iterationType, includeNull);
-  }
-  bfs(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    const ans = [];
-    if (iterationType === "RECURSIVE") {
-      const queue = new Queue([
-        startNode
-      ]);
-      const dfs =  __name((level) => {
-        if (queue.length === 0) return;
-        const current = queue.shift();
-        ans.push(callback(current));
-        if (includeNull) {
-          if (current && this.isRealNodeOrNull(current.left)) queue.push(current.left);
-          if (current && this.isRealNodeOrNull(current.right)) queue.push(current.right);
-        } else {
-          if (this.isRealNode(current.left)) queue.push(current.left);
-          if (this.isRealNode(current.right)) queue.push(current.right);
-        }
-        dfs(level + 1);
-      }, "dfs");
-      dfs(0);
-    } else {
-      const queue = new Queue([startNode]);
-      while (queue.length > 0) {
-        const levelSize = queue.length;
-        for (let i = 0; i < levelSize; i++) {
-          const current = queue.shift();
-          ans.push(callback(current));
-          if (includeNull) {
-            if (current && this.isRealNodeOrNull(current.left)) queue.push(current.left);
-            if (current && this.isRealNodeOrNull(current.right)) queue.push(current.right);
-          } else {
-            if (this.isRealNode(current.left)) queue.push(current.left);
-            if (this.isRealNode(current.right)) queue.push(current.right);
-          }
-        }
-      }
-    }
-    return ans;
-  }
-  leaves(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    startNode = this.ensureNode(startNode);
-    const leaves = [];
-    if (!this.isRealNode(startNode)) return [];
-    if (iterationType === "RECURSIVE") {
-      const dfs =  __name((cur) => {
-        if (this.isLeaf(cur)) {
-          leaves.push(callback(cur));
-        }
-        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
-        if (this.isRealNode(cur.left)) dfs(cur.left);
-        if (this.isRealNode(cur.right)) dfs(cur.right);
-      }, "dfs");
-      dfs(startNode);
-    } else {
-      const queue = new Queue([startNode]);
-      while (queue.length > 0) {
-        const cur = queue.shift();
-        if (this.isRealNode(cur)) {
-          if (this.isLeaf(cur)) {
-            leaves.push(callback(cur));
-          }
-          if (this.isRealNode(cur.left)) queue.push(cur.left);
-          if (this.isRealNode(cur.right)) queue.push(cur.right);
-        }
-      }
-    }
-    return leaves;
-  }
-  listLevels(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
-    startNode = this.ensureNode(startNode);
-    const levelsNodes = [];
-    if (!startNode) return levelsNodes;
-    if (iterationType === "RECURSIVE") {
-      const _recursive =  __name((node, level) => {
-        if (!levelsNodes[level]) levelsNodes[level] = [];
-        levelsNodes[level].push(callback(node));
-        if (includeNull) {
-          if (node && this.isRealNodeOrNull(node.left)) _recursive(node.left, level + 1);
-          if (node && this.isRealNodeOrNull(node.right)) _recursive(node.right, level + 1);
-        } else {
-          if (node && node.left) _recursive(node.left, level + 1);
-          if (node && node.right) _recursive(node.right, level + 1);
-        }
-      }, "_recursive");
-      _recursive(startNode, 0);
-    } else {
-      const stack = [[startNode, 0]];
-      while (stack.length > 0) {
-        const head = stack.pop();
-        const [node, level] = head;
-        if (!levelsNodes[level]) levelsNodes[level] = [];
-        levelsNodes[level].push(callback(node));
-        if (includeNull) {
-          if (node && this.isRealNodeOrNull(node.right)) stack.push([node.right, level + 1]);
-          if (node && this.isRealNodeOrNull(node.left)) stack.push([node.left, level + 1]);
-        } else {
-          if (node && node.right) stack.push([node.right, level + 1]);
-          if (node && node.left) stack.push([node.left, level + 1]);
-        }
-      }
-    }
-    return levelsNodes;
-  }
-  morris(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", startNode = this._root) {
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    const ans = [];
-    let cur = startNode;
-    const _reverseEdge =  __name((node) => {
-      let pre = null;
-      let next = null;
-      while (node) {
-        next = node.right;
-        node.right = pre;
-        pre = node;
-        node = next;
-      }
-      return pre;
-    }, "_reverseEdge");
-    const _printEdge =  __name((node) => {
-      const tail = _reverseEdge(node);
-      let cur2 = tail;
-      while (cur2) {
-        ans.push(callback(cur2));
-        cur2 = cur2.right;
-      }
-      _reverseEdge(tail);
-    }, "_printEdge");
-    switch (pattern) {
-      case "IN":
-        while (cur) {
-          if (cur.left) {
-            const predecessor = this.getPredecessor(cur);
-            if (!predecessor.right) {
-              predecessor.right = cur;
-              cur = cur.left;
-              continue;
-            } else {
-              predecessor.right = null;
-            }
-          }
-          ans.push(callback(cur));
-          cur = cur.right;
-        }
-        break;
-      case "PRE":
-        while (cur) {
-          if (cur.left) {
-            const predecessor = this.getPredecessor(cur);
-            if (!predecessor.right) {
-              predecessor.right = cur;
-              ans.push(callback(cur));
-              cur = cur.left;
-              continue;
-            } else {
-              predecessor.right = null;
-            }
-          } else {
-            ans.push(callback(cur));
-          }
-          cur = cur.right;
-        }
-        break;
-      case "POST":
-        while (cur) {
-          if (cur.left) {
-            const predecessor = this.getPredecessor(cur);
-            if (predecessor.right === null) {
-              predecessor.right = cur;
-              cur = cur.left;
-              continue;
-            } else {
-              predecessor.right = null;
-              _printEdge(cur.left);
-            }
-          }
-          cur = cur.right;
-        }
-        _printEdge(startNode);
-        break;
-    }
-    return ans;
-  }
-  clone() {
-    const out = this._createInstance();
-    this._clone(out);
-    return out;
-  }
-  filter(predicate, thisArg) {
-    const out = this._createInstance();
-    let i = 0;
-    for (const [k, v] of this) if (predicate.call(thisArg, v, k, i++, this)) out.set([k, v]);
-    return out;
-  }
-  map(cb, options, thisArg) {
-    const out = this._createLike([], options);
-    let i = 0;
-    for (const [k, v] of this) out.set(cb.call(thisArg, v, k, i++, this));
-    return out;
-  }
-  toVisual(startNode = this._root, options) {
-    const opts = { isShowUndefined: false, isShowNull: true, isShowRedBlackNIL: false, ...options };
-    startNode = this.ensureNode(startNode);
-    let output = "";
-    if (!startNode) return output;
-    if (opts.isShowUndefined) output += `U for undefined
-`;
-    if (opts.isShowNull) output += `N for null
-`;
-    if (opts.isShowRedBlackNIL) output += `S for Sentinel Node(NIL)
-`;
-    const display =  __name((root) => {
-      const [lines] = this._displayAux(root, opts);
-      let paragraph = "";
-      for (const line of lines) {
-        paragraph += line + "\n";
-      }
-      output += paragraph;
-    }, "display");
-    display(startNode);
-    return output;
-  }
-  print(options, startNode = this._root) {
-    console.log(this.toVisual(startNode, options));
-  }
-  _dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", onlyOne = false, startNode = this._root, iterationType = this.iterationType, includeNull = false, shouldVisitLeft = (node) => !!node, shouldVisitRight = (node) => !!node, shouldVisitRoot = (node) => {
-    if (includeNull) return this.isRealNodeOrNull(node);
-    return this.isRealNode(node);
-  }, shouldProcessRoot = (node) => this.isRealNodeOrNull(node)) {
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    const ans = [];
-    if (iterationType === "RECURSIVE") {
-      const dfs =  __name((node) => {
-        if (!shouldVisitRoot(node)) return;
-        const visitLeft =  __name(() => {
-          if (shouldVisitLeft(node) && node?.left !== void 0) dfs(node?.left);
-        }, "visitLeft");
-        const visitRight =  __name(() => {
-          if (shouldVisitRight(node) && node?.right !== void 0) dfs(node?.right);
-        }, "visitRight");
-        switch (pattern) {
-          case "IN":
-            visitLeft();
-            if (shouldProcessRoot(node)) {
-              ans.push(callback(node));
-              if (onlyOne) return;
-            }
-            visitRight();
-            break;
-          case "PRE":
-            if (shouldProcessRoot(node)) {
-              ans.push(callback(node));
-              if (onlyOne) return;
-            }
-            visitLeft();
-            visitRight();
-            break;
-          case "POST":
-            visitLeft();
-            visitRight();
-            if (shouldProcessRoot(node)) {
-              ans.push(callback(node));
-              if (onlyOne) return;
-            }
-            break;
-        }
-      }, "dfs");
-      dfs(startNode);
-    } else {
-      const stack = [{ opt: 0 , node: startNode }];
-      const pushLeft =  __name((cur) => {
-        if (shouldVisitLeft(cur.node)) stack.push({ opt: 0 , node: cur.node?.left });
-      }, "pushLeft");
-      const pushRight =  __name((cur) => {
-        if (shouldVisitRight(cur.node)) stack.push({ opt: 0 , node: cur.node?.right });
-      }, "pushRight");
-      const pushRoot =  __name((cur) => {
-        if (shouldVisitRoot(cur.node)) stack.push({ opt: 1 , node: cur.node });
-      }, "pushRoot");
-      while (stack.length > 0) {
-        const cur = stack.pop();
-        if (cur === void 0) continue;
-        if (!shouldVisitRoot(cur.node)) continue;
-        if (cur.opt === 1 ) {
-          if (shouldProcessRoot(cur.node) && cur.node !== void 0) {
-            ans.push(callback(cur.node));
-            if (onlyOne) return ans;
-          }
-        } else {
-          switch (pattern) {
-            case "IN":
-              pushRight(cur);
-              pushRoot(cur);
-              pushLeft(cur);
-              break;
-            case "PRE":
-              pushRight(cur);
-              pushLeft(cur);
-              pushRoot(cur);
-              break;
-            case "POST":
-              pushRoot(cur);
-              pushRight(cur);
-              pushLeft(cur);
-              break;
-          }
-        }
-      }
-    }
-    return ans;
-  }
-  *_getIterator(node = this._root) {
-    if (!node) return;
-    if (this.iterationType === "ITERATIVE") {
-      const stack = [];
-      let current = node;
-      while (current || stack.length > 0) {
-        while (this.isRealNode(current)) {
-          stack.push(current);
-          current = current.left;
-        }
-        current = stack.pop();
-        if (this.isRealNode(current)) {
-          if (this._isMapMode) yield [current.key, this._store.get(current.key)];
-          else yield [current.key, current.value];
-          current = current.right;
-        }
-      }
-    } else {
-      if (node.left && this.isRealNode(node)) {
-        yield* this[Symbol.iterator](node.left);
-      }
-      if (this._isMapMode) yield [node.key, this._store.get(node.key)];
-      else yield [node.key, node.value];
-      if (node.right && this.isRealNode(node)) {
-        yield* this[Symbol.iterator](node.right);
-      }
-    }
-  }
-  _DEFAULT_NODE_CALLBACK =  __name((node) => node ? node.key : void 0, "_DEFAULT_NODE_CALLBACK");
-  _snapshotOptions() {
-    return {
-      iterationType: this.iterationType,
-      toEntryFn: this.toEntryFn,
-      isMapMode: this.isMapMode,
-      isDuplicate: this.isDuplicate
-    };
-  }
-  _createInstance(options) {
-    const Ctor = this.constructor;
-    return new Ctor([], { ...this._snapshotOptions(), ...options ?? {} });
-  }
-  _createLike(iter = [], options) {
-    const Ctor = this.constructor;
-    return new Ctor(iter, { ...this._snapshotOptions(), ...options ?? {} });
-  }
-  _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value) {
-    if (keyNodeOrEntry === void 0) return [void 0, void 0];
-    if (keyNodeOrEntry === null) return [null, void 0];
-    if (this.isNode(keyNodeOrEntry)) return [keyNodeOrEntry, value];
-    if (this.isEntry(keyNodeOrEntry)) {
-      const [key, entryValue] = keyNodeOrEntry;
-      if (key === void 0) return [void 0, void 0];
-      else if (key === null) return [null, void 0];
-      const finalValue = value ?? entryValue;
-      return [this.createNode(key, finalValue), finalValue];
-    }
-    return [this.createNode(keyNodeOrEntry, value), value];
-  }
-  _clone(cloned) {
-    this.bfs(
-      (node) => {
-        if (node === null) cloned.set(null);
-        else {
-          if (this._isMapMode) cloned.set([node.key, this._store.get(node.key)]);
-          else cloned.set([node.key, node.value]);
-        }
-      },
-      this._root,
-      this.iterationType,
-      true
-    );
-    if (this._isMapMode) cloned._store = this._store;
-  }
-  _displayAux(node, options) {
-    const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
-    const emptyDisplayLayout = [["\u2500"], 1, 0, 0];
-    if (node === null && !isShowNull) {
-      return emptyDisplayLayout;
-    } else if (node === void 0 && !isShowUndefined) {
-      return emptyDisplayLayout;
-    } else if (this.isNIL(node) && !isShowRedBlackNIL) {
-      return emptyDisplayLayout;
-    } else if (node !== null && node !== void 0) {
-      const key = node.key, line = this.isNIL(node) ? "S" : String(key), width = line.length;
-      return _buildNodeDisplay(
-        line,
-        width,
-        this._displayAux(node.left, options),
-        this._displayAux(node.right, options)
-      );
-    } else {
-      const line = node === void 0 ? "U" : "N", width = line.length;
-      return _buildNodeDisplay(line, width, [[""], 1, 0, 0], [[""], 1, 0, 0]);
-    }
-    function _buildNodeDisplay(line, width, left, right) {
-      const [leftLines, leftWidth, leftHeight, leftMiddle] = left;
-      const [rightLines, rightWidth, rightHeight, rightMiddle] = right;
-      const firstLine = " ".repeat(Math.max(0, leftMiddle + 1)) + "_".repeat(Math.max(0, leftWidth - leftMiddle - 1)) + line + "_".repeat(Math.max(0, rightMiddle)) + " ".repeat(Math.max(0, rightWidth - rightMiddle));
-      const secondLine = (leftHeight > 0 ? " ".repeat(leftMiddle) + "/" + " ".repeat(leftWidth - leftMiddle - 1) : " ".repeat(leftWidth)) + " ".repeat(width) + (rightHeight > 0 ? " ".repeat(rightMiddle) + "\\" + " ".repeat(rightWidth - rightMiddle - 1) : " ".repeat(rightWidth));
-      const mergedLines = [firstLine, secondLine];
-      for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
-        const leftLine = i < leftHeight ? leftLines[i] : " ".repeat(leftWidth);
-        const rightLine = i < rightHeight ? rightLines[i] : " ".repeat(rightWidth);
-        mergedLines.push(leftLine + " ".repeat(width) + rightLine);
-      }
-      return [
-        mergedLines,
-        leftWidth + width + rightWidth,
-        Math.max(leftHeight, rightHeight) + 2,
-        leftWidth + Math.floor(width / 2)
-      ];
-    }
-    __name(_buildNodeDisplay, "_buildNodeDisplay");
-  }
-  _swapProperties(srcNode, destNode) {
-    srcNode = this.ensureNode(srcNode);
-    destNode = this.ensureNode(destNode);
-    if (srcNode && destNode) {
-      const { key, value } = destNode;
-      const tempNode = this.createNode(key, value);
-      if (tempNode) {
-        destNode.key = srcNode.key;
-        if (!this._isMapMode) destNode.value = srcNode.value;
-        srcNode.key = tempNode.key;
-        if (!this._isMapMode) srcNode.value = tempNode.value;
-      }
-      return destNode;
-    }
-    return void 0;
-  }
-  _replaceNode(oldNode, newNode) {
-    if (oldNode.parent) {
-      if (oldNode.parent.left === oldNode) {
-        oldNode.parent.left = newNode;
-      } else if (oldNode.parent.right === oldNode) {
-        oldNode.parent.right = newNode;
-      }
-    }
-    newNode.left = oldNode.left;
-    newNode.right = oldNode.right;
-    newNode.parent = oldNode.parent;
-    if (this._root === oldNode) {
-      this._setRoot(newNode);
-    }
-    return newNode;
-  }
-  _setRoot(v) {
-    if (v) {
-      v.parent = void 0;
-    }
-    this._root = v;
-  }
-  _ensurePredicate(keyNodeEntryOrPredicate) {
-    if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0)
-      return (node) => node ? false : false;
-    if (this._isPredicate(keyNodeEntryOrPredicate)) return keyNodeEntryOrPredicate;
-    if (this.isRealNode(keyNodeEntryOrPredicate))
-      return (node) => node === keyNodeEntryOrPredicate;
-    if (this.isEntry(keyNodeEntryOrPredicate)) {
-      const [key] = keyNodeEntryOrPredicate;
-      return (node) => {
-        if (!node) return false;
-        return node.key === key;
-      };
-    }
-    return (node) => {
-      if (!node) return false;
-      return node.key === keyNodeEntryOrPredicate;
-    };
-  }
-  _isPredicate(p) {
-    return typeof p === "function";
-  }
-  _extractKey(keyNodeOrEntry) {
-    if (keyNodeOrEntry === null) return null;
-    if (keyNodeOrEntry === void 0) return;
-    if (keyNodeOrEntry === this._NIL) return;
-    if (this.isNode(keyNodeOrEntry)) return keyNodeOrEntry.key;
-    if (this.isEntry(keyNodeOrEntry)) return keyNodeOrEntry[0];
-    return keyNodeOrEntry;
-  }
-  _setValue(key, value) {
-    if (key === null || key === void 0) return false;
-    if (value === void 0) return false;
-    return this._store.set(key, value);
-  }
-  _clearNodes() {
-    this._setRoot(void 0);
-    this._size = 0;
-  }
-  _clearValues() {
-    this._store.clear();
-  }
-};
-var BSTNode = class {
-  static {
-    __name(this, "BSTNode");
-  }
-  key;
-  value;
-  parent = void 0;
-  constructor(key, value) {
-    this.key = key;
-    this.value = value;
-  }
-  _left = void 0;
-  get left() {
-    return this._left;
-  }
-  set left(v) {
-    if (v) v.parent = this;
-    this._left = v;
-  }
-  _right = void 0;
-  get right() {
-    return this._right;
-  }
-  set right(v) {
-    if (v) v.parent = this;
-    this._right = v;
-  }
-  _height = 0;
-  get height() {
-    return this._height;
-  }
-  set height(value) {
-    this._height = value;
-  }
-  _color = "BLACK";
-  get color() {
-    return this._color;
-  }
-  set color(value) {
-    this._color = value;
-  }
-  _count = 1;
-  get count() {
-    return this._count;
-  }
-  set count(value) {
-    this._count = value;
-  }
-  get familyPosition() {
-    if (!this.parent) {
-      return this.left || this.right ? "ROOT" : "ISOLATED";
-    }
-    if (this.parent.left === this) {
-      return this.left || this.right ? "ROOT_LEFT" : "LEFT";
-    } else if (this.parent.right === this) {
-      return this.left || this.right ? "ROOT_RIGHT" : "RIGHT";
-    }
-    return "MAL_NODE";
-  }
-};
-var BST = class extends BinaryTree {
-  static {
-    __name(this, "BST");
-  }
-  constructor(keysNodesEntriesOrRaws = [], options) {
-    super([], options);
-    if (options) {
-      if ("comparator" in options && options.comparator !== void 0) {
-        this._comparator = options.comparator;
-      } else {
-        this._comparator = this._createDefaultComparator();
-      }
-    } else {
-      this._comparator = this._createDefaultComparator();
-    }
-    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
-  }
-  _root = void 0;
-  get root() {
-    return this._root;
-  }
-  _comparator;
-  get comparator() {
-    return this._comparator;
-  }
-  createNode(key, value) {
-    return new BSTNode(key, this._isMapMode ? void 0 : value);
-  }
-  ensureNode(keyNodeOrEntry, iterationType = this.iterationType) {
-    return super.ensureNode(keyNodeOrEntry, iterationType) ?? void 0;
-  }
-  isNode(keyNodeOrEntry) {
-    return keyNodeOrEntry instanceof BSTNode;
-  }
-  isValidKey(key) {
-    return isComparable(key);
-  }
-  dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
-    return super.dfs(callback, pattern, onlyOne, startNode, iterationType);
-  }
-  bfs(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    return super.bfs(callback, startNode, iterationType, false);
-  }
-  listLevels(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    return super.listLevels(callback, startNode, iterationType, false);
-  }
-  getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? void 0;
-  }
-  search(keyNodeEntryOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    if (keyNodeEntryOrPredicate === void 0) return [];
-    if (keyNodeEntryOrPredicate === null) return [];
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    let predicate;
-    const isRange = this.isRange(keyNodeEntryOrPredicate);
-    if (isRange) {
-      predicate =  __name((node) => {
-        if (!node) return false;
-        return keyNodeEntryOrPredicate.isInRange(node.key, this._comparator);
-      }, "predicate");
-    } else {
-      predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
-    }
-    const shouldVisitLeft =  __name((cur) => {
-      if (!cur) return false;
-      if (!this.isRealNode(cur.left)) return false;
-      if (isRange) {
-        const range = keyNodeEntryOrPredicate;
-        const leftS = range.low;
-        const leftI = range.includeLow;
-        return leftI && this._compare(cur.key, leftS) >= 0 || !leftI && this._compare(cur.key, leftS) > 0;
-      }
-      if (!isRange && !this._isPredicate(keyNodeEntryOrPredicate)) {
-        const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
-        return benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) > 0;
-      }
-      return true;
-    }, "shouldVisitLeft");
-    const shouldVisitRight =  __name((cur) => {
-      if (!cur) return false;
-      if (!this.isRealNode(cur.right)) return false;
-      if (isRange) {
-        const range = keyNodeEntryOrPredicate;
-        const rightS = range.high;
-        const rightI = range.includeHigh;
-        return rightI && this._compare(cur.key, rightS) <= 0 || !rightI && this._compare(cur.key, rightS) < 0;
-      }
-      if (!isRange && !this._isPredicate(keyNodeEntryOrPredicate)) {
-        const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
-        return benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) < 0;
-      }
-      return true;
-    }, "shouldVisitRight");
-    return super._dfs(
-      callback,
-      "IN",
-      onlyOne,
-      startNode,
-      iterationType,
-      false,
-      shouldVisitLeft,
-      shouldVisitRight,
-      () => true,
-      (cur) => !!cur && predicate(cur)
-    );
-  }
-  rangeSearch(range, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    const searchRange = range instanceof Range ? range : new Range(range[0], range[1]);
-    return this.search(searchRange, false, callback, startNode, iterationType);
-  }
-  set(keyNodeOrEntry, value) {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
-    if (newNode === void 0) return false;
-    if (this._root === void 0) {
-      this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
-      this._size++;
-      return true;
-    }
-    let current = this._root;
-    while (current !== void 0) {
-      if (this._compare(current.key, newNode.key) === 0) {
-        this._replaceNode(current, newNode);
-        if (this._isMapMode) this._setValue(current.key, newValue);
-        return true;
-      } else if (this._compare(current.key, newNode.key) > 0) {
-        if (current.left === void 0) {
-          current.left = newNode;
-          if (this._isMapMode) this._setValue(newNode?.key, newValue);
-          this._size++;
-          return true;
-        }
-        if (current.left !== null) current = current.left;
-      } else {
-        if (current.right === void 0) {
-          current.right = newNode;
-          if (this._isMapMode) this._setValue(newNode?.key, newValue);
-          this._size++;
-          return true;
-        }
-        if (current.right !== null) current = current.right;
-      }
-    }
-    return false;
-  }
-  setMany(keysNodesEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
-    const inserted = [];
-    const valuesIterator = values?.[Symbol.iterator]();
-    if (!isBalanceAdd) {
-      for (let kve of keysNodesEntriesOrRaws) {
-        const val = valuesIterator?.next().value;
-        if (this.isRaw(kve)) kve = this._toEntryFn(kve);
-        inserted.push(this.set(kve, val));
-      }
-      return inserted;
-    }
-    const realBTNExemplars = [];
-    let i = 0;
-    for (const kve of keysNodesEntriesOrRaws) {
-      realBTNExemplars.push({ key: kve, value: valuesIterator?.next().value, orgIndex: i++ });
-    }
-    const sorted = realBTNExemplars.sort(({ key: a }, { key: b }) => {
-      let keyA, keyB;
-      if (this.isRaw(a)) keyA = this._toEntryFn(a)[0];
-      else if (this.isEntry(a)) keyA = a[0];
-      else if (this.isRealNode(a)) keyA = a.key;
-      else keyA = a;
-      if (this.isRaw(b)) keyB = this._toEntryFn(b)[0];
-      else if (this.isEntry(b)) keyB = b[0];
-      else if (this.isRealNode(b)) keyB = b.key;
-      else keyB = b;
-      if (keyA != null && keyB != null) return this._compare(keyA, keyB);
-      return 0;
-    });
-    const _dfs =  __name((arr) => {
-      if (arr.length === 0) return;
-      const mid = Math.floor((arr.length - 1) / 2);
-      const { key, value, orgIndex } = arr[mid];
-      if (this.isRaw(key)) {
-        const entry = this._toEntryFn(key);
-        inserted[orgIndex] = this.set(entry);
-      } else {
-        inserted[orgIndex] = this.set(key, value);
-      }
-      _dfs(arr.slice(0, mid));
-      _dfs(arr.slice(mid + 1));
-    }, "_dfs");
-    const _iterate =  __name(() => {
-      const n = sorted.length;
-      const stack = [[0, n - 1]];
-      while (stack.length > 0) {
-        const popped = stack.pop();
-        if (!popped) continue;
-        const [l, r] = popped;
-        if (l > r) continue;
-        const m = l + Math.floor((r - l) / 2);
-        const { key, value, orgIndex } = sorted[m];
-        if (this.isRaw(key)) {
-          const entry = this._toEntryFn(key);
-          inserted[orgIndex] = this.set(entry);
-        } else {
-          inserted[orgIndex] = this.set(key, value);
-        }
-        stack.push([m + 1, r]);
-        stack.push([l, m - 1]);
-      }
-    }, "_iterate");
-    if (iterationType === "RECURSIVE") _dfs(sorted);
-    else _iterate();
-    return inserted;
-  }
-  ceiling(keyNodeEntryOrPredicate, callback = this._DEFAULT_NODE_CALLBACK, iterationType) {
-    let actualCallback = void 0;
-    let actualIterationType = this.iterationType;
-    if (typeof callback === "string") {
-      actualIterationType = callback;
-    } else if (callback) {
-      actualCallback = callback;
-      if (iterationType) {
-        actualIterationType = iterationType;
-      }
-    }
-    const node = this._bound(keyNodeEntryOrPredicate, true, actualIterationType);
-    if (!actualCallback) {
-      return node?.key;
-    }
-    return node ? actualCallback(node) : void 0;
-  }
-  higher(keyNodeEntryOrPredicate, callback = this._DEFAULT_NODE_CALLBACK, iterationType) {
-    let actualCallback = void 0;
-    let actualIterationType = this.iterationType;
-    if (typeof callback === "string") {
-      actualIterationType = callback;
-    } else if (callback) {
-      actualCallback = callback;
-      if (iterationType) {
-        actualIterationType = iterationType;
-      }
-    }
-    const node = this._bound(keyNodeEntryOrPredicate, false, actualIterationType);
-    if (!actualCallback) {
-      return node?.key;
-    }
-    return node ? actualCallback(node) : void 0;
-  }
-  floor(keyNodeEntryOrPredicate, callback = this._DEFAULT_NODE_CALLBACK, iterationType) {
-    if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) {
-      if (typeof callback === "string" || !callback) {
-        return void 0;
-      }
-      return void 0;
-    }
-    let actualCallback = void 0;
-    let actualIterationType = this.iterationType;
-    if (typeof callback === "string") {
-      actualIterationType = callback;
-    } else if (callback) {
-      actualCallback = callback;
-      if (iterationType) {
-        actualIterationType = iterationType;
-      }
-    }
-    if (this._isPredicate(keyNodeEntryOrPredicate)) {
-      const node = this._floorByPredicate(keyNodeEntryOrPredicate, actualIterationType);
-      if (!actualCallback) {
-        return node?.key;
-      }
-      return node ? actualCallback(node) : void 0;
-    }
-    let targetKey;
-    if (this.isNode(keyNodeEntryOrPredicate)) {
-      targetKey = keyNodeEntryOrPredicate.key;
-    } else if (this.isEntry(keyNodeEntryOrPredicate)) {
-      const key = keyNodeEntryOrPredicate[0];
-      if (key === null || key === void 0) {
-        if (typeof callback === "string" || !callback) {
-          return void 0;
-        }
-        return void 0;
-      }
-      targetKey = key;
-    } else {
-      targetKey = keyNodeEntryOrPredicate;
-    }
-    if (targetKey !== void 0) {
-      const node = this._floorByKey(targetKey, actualIterationType);
-      if (!actualCallback) {
-        return node?.key;
-      }
-      return node ? actualCallback(node) : void 0;
-    }
-    if (typeof callback === "string" || !callback) {
-      return void 0;
-    }
-    return void 0;
-  }
-  lower(keyNodeEntryOrPredicate, callback, iterationType) {
-    if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) {
-      if (typeof callback === "string" || !callback) {
-        return void 0;
-      }
-      return void 0;
-    }
-    let actualCallback = void 0;
-    let actualIterationType = this.iterationType;
-    if (typeof callback === "string") {
-      actualIterationType = callback;
-    } else if (callback) {
-      actualCallback = callback;
-      if (iterationType) {
-        actualIterationType = iterationType;
-      }
-    }
-    if (this._isPredicate(keyNodeEntryOrPredicate)) {
-      const node = this._lowerByPredicate(keyNodeEntryOrPredicate, actualIterationType);
-      if (!actualCallback) {
-        return node?.key;
-      }
-      return node ? actualCallback(node) : void 0;
-    }
-    let targetKey;
-    if (this.isNode(keyNodeEntryOrPredicate)) {
-      targetKey = keyNodeEntryOrPredicate.key;
-    } else if (this.isEntry(keyNodeEntryOrPredicate)) {
-      const key = keyNodeEntryOrPredicate[0];
-      if (key === null || key === void 0) {
-        if (typeof callback === "string" || !callback) {
-          return void 0;
-        }
-        return void 0;
-      }
-      targetKey = key;
-    } else {
-      targetKey = keyNodeEntryOrPredicate;
-    }
-    if (targetKey !== void 0) {
-      const node = this._lowerByKey(targetKey, actualIterationType);
-      if (!actualCallback) {
-        return node?.key;
-      }
-      return node ? actualCallback(node) : void 0;
-    }
-    if (typeof callback === "string" || !callback) {
-      return void 0;
-    }
-    return void 0;
-  }
-  lesserOrGreaterTraverse(callback = this._DEFAULT_NODE_CALLBACK, lesserOrGreater = -1, targetNode = this._root, iterationType = this.iterationType) {
-    const targetNodeEnsured = this.ensureNode(targetNode);
-    const ans = [];
-    if (!this._root || !targetNodeEnsured) return ans;
-    const targetKey = targetNodeEnsured.key;
-    if (iterationType === "RECURSIVE") {
-      const dfs =  __name((cur) => {
-        const compared = this._compare(cur.key, targetKey);
-        if (Math.sign(compared) == lesserOrGreater) ans.push(callback(cur));
-        if (this.isRealNode(cur.left)) dfs(cur.left);
-        if (this.isRealNode(cur.right)) dfs(cur.right);
-      }, "dfs");
-      dfs(this._root);
-      return ans;
-    } else {
-      const queue = new Queue([this._root]);
-      while (queue.length > 0) {
-        const cur = queue.shift();
-        if (this.isRealNode(cur)) {
-          const compared = this._compare(cur.key, targetKey);
-          if (Math.sign(compared) == lesserOrGreater) ans.push(callback(cur));
-          if (this.isRealNode(cur.left)) queue.push(cur.left);
-          if (this.isRealNode(cur.right)) queue.push(cur.right);
-        }
-      }
-      return ans;
-    }
-  }
-  perfectlyBalance(iterationType = this.iterationType) {
-    const nodes = this.dfs((node) => node, "IN", false, this._root, iterationType);
-    const n = nodes.length;
-    this._clearNodes();
-    if (n === 0) return false;
-    const build =  __name((l, r, parent) => {
-      if (l > r) return void 0;
-      const m = l + (r - l >> 1);
-      const root = nodes[m];
-      const leftChild = build(l, m - 1, root);
-      const rightChild = build(m + 1, r, root);
-      root.left = leftChild;
-      root.right = rightChild;
-      root.parent = parent;
-      return root;
-    }, "build");
-    const newRoot = build(0, n - 1, void 0);
-    this._setRoot(newRoot);
-    this._size = n;
-    return true;
-  }
-  isAVLBalanced(iterationType = this.iterationType) {
-    if (!this._root) return true;
-    let balanced = true;
-    if (iterationType === "RECURSIVE") {
-      const _height =  __name((cur) => {
-        if (!cur) return 0;
-        const leftHeight = _height(cur.left);
-        const rightHeight = _height(cur.right);
-        if (Math.abs(leftHeight - rightHeight) > 1) balanced = false;
-        return Math.max(leftHeight, rightHeight) + 1;
-      }, "_height");
-      _height(this._root);
-    } else {
-      const stack = [];
-      let node = this._root, last = void 0;
-      const depths =  new Map();
-      while (stack.length > 0 || node) {
-        if (node) {
-          stack.push(node);
-          if (node.left !== null) node = node.left;
-        } else {
-          node = stack[stack.length - 1];
-          if (!node.right || last === node.right) {
-            node = stack.pop();
-            if (node) {
-              const left = node.left ? depths.get(node.left) : -1;
-              const right = node.right ? depths.get(node.right) : -1;
-              if (Math.abs(left - right) > 1) return false;
-              depths.set(node, 1 + Math.max(left, right));
-              last = node;
-              node = void 0;
-            }
-          } else node = node.right;
-        }
-      }
-    }
-    return balanced;
-  }
-  map(callback, options, thisArg) {
-    const out = this._createLike([], options);
-    let index = 0;
-    for (const [key, value] of this) {
-      out.set(callback.call(thisArg, value, key, index++, this));
-    }
-    return out;
-  }
-  deleteWhere(keyNodeEntryOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
-    const toDelete = this.search(keyNodeEntryOrPredicate, onlyOne, (node) => node, startNode, iterationType);
-    let results = [];
-    for (const node of toDelete) {
-      const deleteInfo = this.delete(node);
-      results = results.concat(deleteInfo);
-    }
-    return results;
-  }
-  _createDefaultComparator() {
-    return (a, b) => {
-      if (isComparable(a) && isComparable(b)) {
-        if (a > b) return 1;
-        if (a < b) return -1;
-        return 0;
-      }
-      if (typeof a === "object" || typeof b === "object") {
-        throw TypeError(
-          `When comparing object type keys, a custom comparator must be provided in the constructor's options!`
-        );
-      }
-      return 0;
-    };
-  }
-  _floorByKey(key, iterationType) {
-    if (iterationType === "RECURSIVE") {
-      const dfs =  __name((cur) => {
-        if (!this.isRealNode(cur)) return void 0;
-        const cmp = this.comparator(cur.key, key);
-        if (cmp <= 0) {
-          const rightResult = dfs(cur.right);
-          return rightResult ?? cur;
-        } else {
-          return dfs(cur.left);
-        }
-      }, "dfs");
-      return dfs(this.root);
-    } else {
-      let current = this.root;
-      let result = void 0;
-      while (this.isRealNode(current)) {
-        const cmp = this.comparator(current.key, key);
-        if (cmp <= 0) {
-          result = current;
-          current = current.right ?? void 0;
-        } else {
-          current = current.left ?? void 0;
-        }
-      }
-      return result;
-    }
-  }
-  _floorByPredicate(predicate, iterationType) {
-    if (iterationType === "RECURSIVE") {
-      let result = void 0;
-      const dfs =  __name((cur) => {
-        if (!this.isRealNode(cur)) return;
-        if (this.isRealNode(cur.left)) dfs(cur.left);
-        if (predicate(cur)) {
-          result = cur;
-        }
-        if (this.isRealNode(cur.right)) dfs(cur.right);
-      }, "dfs");
-      dfs(this.root);
-      return result;
-    } else {
-      const stack = [];
-      let current = this.root;
-      let result = void 0;
-      while (stack.length > 0 || this.isRealNode(current)) {
-        if (this.isRealNode(current)) {
-          stack.push(current);
-          current = current.left;
-        } else {
-          const node = stack.pop();
-          if (!this.isRealNode(node)) break;
-          if (predicate(node)) {
-            result = node;
-          }
-          current = node.right;
-        }
-      }
-      return result;
-    }
-  }
-  _lowerByKey(key, iterationType) {
-    if (iterationType === "RECURSIVE") {
-      const dfs =  __name((cur) => {
-        if (!this.isRealNode(cur)) return void 0;
-        const cmp = this.comparator(cur.key, key);
-        if (cmp < 0) {
-          const rightResult = dfs(cur.right);
-          return rightResult ?? cur;
-        } else {
-          return dfs(cur.left);
-        }
-      }, "dfs");
-      return dfs(this.root);
-    } else {
-      let current = this.root;
-      let result = void 0;
-      while (this.isRealNode(current)) {
-        const cmp = this.comparator(current.key, key);
-        if (cmp < 0) {
-          result = current;
-          current = current.right ?? void 0;
-        } else {
-          current = current.left ?? void 0;
-        }
-      }
-      return result;
-    }
-  }
-  _lowerByPredicate(predicate, iterationType) {
-    if (iterationType === "RECURSIVE") {
-      let result = void 0;
-      const dfs =  __name((cur) => {
-        if (!this.isRealNode(cur)) return;
-        if (this.isRealNode(cur.left)) dfs(cur.left);
-        if (predicate(cur)) {
-          result = cur;
-        }
-        if (this.isRealNode(cur.right)) dfs(cur.right);
-      }, "dfs");
-      dfs(this.root);
-      return result;
-    } else {
-      const stack = [];
-      let current = this.root;
-      let result = void 0;
-      while (stack.length > 0 || this.isRealNode(current)) {
-        if (this.isRealNode(current)) {
-          stack.push(current);
-          current = current.left;
-        } else {
-          const node = stack.pop();
-          if (!this.isRealNode(node)) break;
-          if (predicate(node)) {
-            result = node;
-          }
-          current = node.right;
-        }
-      }
-      return result;
-    }
-  }
-  _bound(keyNodeEntryOrPredicate, isLower, iterationType) {
-    if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) {
-      return void 0;
-    }
-    if (this._isPredicate(keyNodeEntryOrPredicate)) {
-      return this._boundByPredicate(keyNodeEntryOrPredicate, iterationType);
-    }
-    let targetKey;
-    if (this.isNode(keyNodeEntryOrPredicate)) {
-      targetKey = keyNodeEntryOrPredicate.key;
-    } else if (this.isEntry(keyNodeEntryOrPredicate)) {
-      const key = keyNodeEntryOrPredicate[0];
-      if (key === null || key === void 0) {
-        return void 0;
-      }
-      targetKey = key;
-    } else {
-      targetKey = keyNodeEntryOrPredicate;
-    }
-    if (targetKey !== void 0) {
-      return this._boundByKey(targetKey, isLower, iterationType);
-    }
-    return void 0;
-  }
-  _boundByKey(key, isLower, iterationType) {
-    if (iterationType === "RECURSIVE") {
-      const dfs =  __name((cur) => {
-        if (!this.isRealNode(cur)) return void 0;
-        const cmp = this.comparator(cur.key, key);
-        const condition = isLower ? cmp >= 0 : cmp > 0;
-        if (condition) {
-          const leftResult = dfs(cur.left);
-          return leftResult ?? cur;
-        } else {
-          return dfs(cur.right);
-        }
-      }, "dfs");
-      return dfs(this.root);
-    } else {
-      let current = this.root;
-      let result = void 0;
-      while (this.isRealNode(current)) {
-        const cmp = this.comparator(current.key, key);
-        const condition = isLower ? cmp >= 0 : cmp > 0;
-        if (condition) {
-          result = current;
-          current = current.left ?? void 0;
-        } else {
-          current = current.right ?? void 0;
-        }
-      }
-      return result;
-    }
-  }
-  _boundByPredicate(predicate, iterationType) {
-    if (iterationType === "RECURSIVE") {
-      let result = void 0;
-      const dfs =  __name((cur) => {
-        if (result || !this.isRealNode(cur)) return;
-        if (this.isRealNode(cur.left)) dfs(cur.left);
-        if (!result && predicate(cur)) {
-          result = cur;
-        }
-        if (!result && this.isRealNode(cur.right)) dfs(cur.right);
-      }, "dfs");
-      dfs(this.root);
-      return result;
-    } else {
-      const stack = [];
-      let current = this.root;
-      while (stack.length > 0 || this.isRealNode(current)) {
-        if (this.isRealNode(current)) {
-          stack.push(current);
-          current = current.left;
-        } else {
-          const node = stack.pop();
-          if (!this.isRealNode(node)) break;
-          if (predicate(node)) {
-            return node;
-          }
-          current = node.right;
-        }
-      }
-      return void 0;
-    }
-  }
-  _createInstance(options) {
-    const Ctor = this.constructor;
-    return new Ctor([], { ...this._snapshotOptions(), ...options ?? {} });
-  }
-  _createLike(iter = [], options) {
-    const Ctor = this.constructor;
-    return new Ctor(iter, { ...this._snapshotOptions(), ...options ?? {} });
-  }
-  _snapshotOptions() {
-    return {
-      ...super._snapshotOptions(),
-      comparator: this._comparator
-    };
-  }
-  _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value) {
-    const [node, entryValue] = super._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
-    if (node === null) return [void 0, void 0];
-    return [node, value ?? entryValue];
-  }
-  _setRoot(v) {
-    if (v) v.parent = void 0;
-    this._root = v;
-  }
-  _compare(a, b) {
-    return this._comparator(a, b);
-  }
-  _deleteByKey(key) {
-    let node = this._root;
-    while (node) {
-      const cmp = this._compare(node.key, key);
-      if (cmp === 0) break;
-      node = cmp > 0 ? node.left : node.right;
-    }
-    if (!node) return false;
-    const transplant =  __name((u, v) => {
-      const p = u?.parent;
-      if (!p) {
-        this._setRoot(v);
-      } else if (p.left === u) {
-        p.left = v;
-      } else {
-        p.right = v;
-      }
-      if (v) v.parent = p;
-    }, "transplant");
-    const minNode =  __name((x) => {
-      if (!x) return void 0;
-      while (x.left !== void 0 && x.left !== null) x = x.left;
-      return x;
-    }, "minNode");
-    if (node.left === void 0) {
-      transplant(node, node.right);
-    } else if (node.right === void 0) {
-      transplant(node, node.left);
-    } else {
-      const succ = minNode(node.right);
-      if (succ.parent !== node) {
-        transplant(succ, succ.right);
-        succ.right = node.right;
-        if (succ.right) succ.right.parent = succ;
-      }
-      transplant(node, succ);
-      succ.left = node.left;
-      if (succ.left) succ.left.parent = succ;
-    }
-    this._size = Math.max(0, (this._size ?? 0) - 1);
-    return true;
-  }
-};
-var RedBlackTreeNode = class {
-  static {
-    __name(this, "RedBlackTreeNode");
-  }
-  key;
-  value;
-  parent = void 0;
-  constructor(key, value, color = "BLACK") {
-    this.key = key;
-    this.value = value;
-    this.color = color;
-  }
-  _left = void 0;
-  get left() {
-    return this._left;
-  }
-  set left(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._left = v;
-  }
-  _right = void 0;
-  get right() {
-    return this._right;
-  }
-  set right(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._right = v;
-  }
-  _height = 0;
-  get height() {
-    return this._height;
-  }
-  set height(value) {
-    this._height = value;
-  }
-  _color = "BLACK";
-  get color() {
-    return this._color;
-  }
-  set color(value) {
-    this._color = value;
-  }
-  _count = 1;
-  get count() {
-    return this._count;
-  }
-  set count(value) {
-    this._count = value;
-  }
-  get familyPosition() {
-    if (!this.parent) {
-      return this.left || this.right ? "ROOT" : "ISOLATED";
-    }
-    if (this.parent.left === this) {
-      return this.left || this.right ? "ROOT_LEFT" : "LEFT";
-    } else if (this.parent.right === this) {
-      return this.left || this.right ? "ROOT_RIGHT" : "RIGHT";
-    }
-    return "MAL_NODE";
-  }
-};
-var RedBlackTree = class extends BST {
-  static {
-    __name(this, "RedBlackTree");
-  }
-  constructor(keysNodesEntriesOrRaws = [], options) {
-    super([], options);
-    this._root = this.NIL;
-    if (keysNodesEntriesOrRaws) {
-      this.setMany(keysNodesEntriesOrRaws);
-    }
-  }
-  _root;
-  get root() {
-    return this._root;
-  }
-  createNode(key, value, color = "BLACK") {
-    return new RedBlackTreeNode(key, this._isMapMode ? void 0 : value, color);
-  }
-  isNode(keyNodeOrEntry) {
-    return keyNodeOrEntry instanceof RedBlackTreeNode;
-  }
-  clear() {
-    super.clear();
-    this._root = this.NIL;
-  }
-  set(keyNodeOrEntry, value) {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
-    if (!this.isRealNode(newNode)) return false;
-    const insertStatus = this._insert(newNode);
-    if (insertStatus === "CREATED") {
-      if (this.isRealNode(this._root)) {
-        this._root.color = "BLACK";
-      } else {
-        return false;
-      }
-      if (this._isMapMode) this._setValue(newNode.key, newValue);
-      this._size++;
-      return true;
-    }
-    if (insertStatus === "UPDATED") {
-      if (this._isMapMode) this._setValue(newNode.key, newValue);
-      return true;
-    }
-    return false;
-  }
-  delete(keyNodeOrEntry) {
-    if (keyNodeOrEntry === null) return [];
-    const results = [];
-    let nodeToDelete;
-    if (this._isPredicate(keyNodeOrEntry)) nodeToDelete = this.getNode(keyNodeOrEntry);
-    else nodeToDelete = this.isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : this.getNode(keyNodeOrEntry);
-    if (!nodeToDelete) {
-      return results;
-    }
-    let originalColor = nodeToDelete.color;
-    let replacementNode;
-    if (!this.isRealNode(nodeToDelete.left)) {
-      if (nodeToDelete.right !== null) {
-        replacementNode = nodeToDelete.right;
-        this._transplant(nodeToDelete, nodeToDelete.right);
-      }
-    } else if (!this.isRealNode(nodeToDelete.right)) {
-      replacementNode = nodeToDelete.left;
-      this._transplant(nodeToDelete, nodeToDelete.left);
-    } else {
-      const successor = this.getLeftMost((node) => node, nodeToDelete.right);
-      if (successor) {
-        originalColor = successor.color;
-        if (successor.right !== null) replacementNode = successor.right;
-        if (successor.parent === nodeToDelete) {
-          if (this.isRealNode(replacementNode)) {
-            replacementNode.parent = successor;
-          }
-        } else {
-          if (successor.right !== null) {
-            this._transplant(successor, successor.right);
-            successor.right = nodeToDelete.right;
-          }
-          if (this.isRealNode(successor.right)) {
-            successor.right.parent = successor;
-          }
-        }
-        this._transplant(nodeToDelete, successor);
-        successor.left = nodeToDelete.left;
-        if (this.isRealNode(successor.left)) {
-          successor.left.parent = successor;
-        }
-        successor.color = nodeToDelete.color;
-      }
-    }
-    if (this._isMapMode) this._store.delete(nodeToDelete.key);
-    this._size--;
-    if (originalColor === "BLACK") {
-      this._deleteFixup(replacementNode);
-    }
-    results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-    return results;
-  }
-  map(callback, options, thisArg) {
-    const out = this._createLike([], options);
-    let index = 0;
-    for (const [key, value] of this) {
-      out.set(callback.call(thisArg, value, key, index++, this));
-    }
-    return out;
-  }
-  _createInstance(options) {
-    const Ctor = this.constructor;
-    return new Ctor([], { ...this._snapshotOptions(), ...options ?? {} });
-  }
-  _createLike(iter = [], options) {
-    const Ctor = this.constructor;
-    return new Ctor(iter, { ...this._snapshotOptions(), ...options ?? {} });
-  }
-  _setRoot(v) {
-    if (v) {
-      v.parent = void 0;
-    }
-    this._root = v;
-  }
-  _replaceNode(oldNode, newNode) {
-    newNode.color = oldNode.color;
-    return super._replaceNode(oldNode, newNode);
-  }
-  _insert(node) {
-    let current = this.root ?? this.NIL;
-    let parent = void 0;
-    while (current !== this.NIL) {
-      parent = current;
-      const compared = this._compare(node.key, current.key);
-      if (compared < 0) {
-        current = current.left ?? this.NIL;
-      } else if (compared > 0) {
-        current = current.right ?? this.NIL;
-      } else {
-        this._replaceNode(current, node);
-        return "UPDATED";
-      }
-    }
-    node.parent = parent;
-    if (!parent) {
-      this._setRoot(node);
-    } else if (this._compare(node.key, parent.key) < 0) {
-      parent.left = node;
-    } else {
-      parent.right = node;
-    }
-    node.left = this.NIL;
-    node.right = this.NIL;
-    node.color = "RED";
-    this._insertFixup(node);
-    return "CREATED";
-  }
-  _transplant(u, v) {
-    if (!u.parent) {
-      this._setRoot(v);
-    } else if (u === u.parent.left) {
-      u.parent.left = v;
-    } else {
-      u.parent.right = v;
-    }
-    if (v) {
-      v.parent = u.parent;
-    }
-  }
-  _insertFixup(z) {
-    while (z?.parent?.color === "RED") {
-      if (z.parent === z.parent.parent?.left) {
-        const y = z.parent.parent.right;
-        if (y?.color === "RED") {
-          z.parent.color = "BLACK";
-          y.color = "BLACK";
-          z.parent.parent.color = "RED";
-          z = z.parent.parent;
-        } else {
-          if (z === z.parent.right) {
-            z = z.parent;
-            this._leftRotate(z);
-          }
-          if (z && z.parent && z.parent.parent) {
-            z.parent.color = "BLACK";
-            z.parent.parent.color = "RED";
-            this._rightRotate(z.parent.parent);
-          }
-        }
-      } else {
-        const y = z?.parent?.parent?.left ?? void 0;
-        if (y?.color === "RED") {
-          z.parent.color = "BLACK";
-          y.color = "BLACK";
-          z.parent.parent.color = "RED";
-          z = z.parent.parent;
-        } else {
-          if (z === z.parent.left) {
-            z = z.parent;
-            this._rightRotate(z);
-          }
-          if (z && z.parent && z.parent.parent) {
-            z.parent.color = "BLACK";
-            z.parent.parent.color = "RED";
-            this._leftRotate(z.parent.parent);
-          }
-        }
-      }
-    }
-    if (this.isRealNode(this._root)) this._root.color = "BLACK";
-  }
-  _deleteFixup(node) {
-    if (!node || node === this.root || node.color === "BLACK") {
-      if (node) {
-        node.color = "BLACK";
-      }
-      return;
-    }
-    while (node && node !== this.root && node.color === "BLACK") {
-      const parent = node.parent;
-      if (!parent) {
-        break;
-      }
-      if (node === parent.left) {
-        let sibling = parent.right;
-        if (sibling?.color === "RED") {
-          sibling.color = "BLACK";
-          parent.color = "RED";
-          this._leftRotate(parent);
-          sibling = parent.right;
-        }
-        if ((sibling?.left?.color ?? "BLACK") === "BLACK") {
-          if (sibling) sibling.color = "RED";
-          node = parent;
-        } else {
-          if (sibling?.left) sibling.left.color = "BLACK";
-          if (sibling) sibling.color = parent.color;
-          parent.color = "BLACK";
-          this._rightRotate(parent);
-          node = this.root;
-        }
-      } else {
-        let sibling = parent.left;
-        if (sibling?.color === "RED") {
-          sibling.color = "BLACK";
-          if (parent) parent.color = "RED";
-          this._rightRotate(parent);
-          if (parent) sibling = parent.left;
-        }
-        if ((sibling?.right?.color ?? "BLACK") === "BLACK") {
-          if (sibling) sibling.color = "RED";
-          node = parent;
-        } else {
-          if (sibling?.right) sibling.right.color = "BLACK";
-          if (sibling) sibling.color = parent.color;
-          if (parent) parent.color = "BLACK";
-          this._leftRotate(parent);
-          node = this.root;
-        }
-      }
-    }
-    if (node) {
-      node.color = "BLACK";
-    }
-  }
-  _leftRotate(x) {
-    if (!x || !x.right) {
-      return;
-    }
-    const y = x.right;
-    x.right = y.left;
-    if (y.left && y.left !== this.NIL) {
-      y.left.parent = x;
-    }
-    y.parent = x.parent;
-    if (!x.parent) {
-      this._setRoot(y);
-    } else if (x === x.parent.left) {
-      x.parent.left = y;
-    } else {
-      x.parent.right = y;
-    }
-    y.left = x;
-    x.parent = y;
-  }
-  _rightRotate(y) {
-    if (!y || !y.left) {
-      return;
-    }
-    const x = y.left;
-    y.left = x.right;
-    if (x.right && x.right !== this.NIL) {
-      x.right.parent = y;
-    }
-    x.parent = y.parent;
-    if (!y.parent) {
-      this._setRoot(x);
-    } else if (y === y.parent.left) {
-      y.parent.left = x;
-    } else {
-      y.parent.right = x;
-    }
-    x.right = y;
-    y.parent = x;
-  }
-};
-var TreeCounterNode = class {
-  static {
-    __name(this, "TreeCounterNode");
-  }
-  key;
-  value;
-  parent = void 0;
-  constructor(key, value, count = 1, color = "BLACK") {
-    this.key = key;
-    this.value = value;
-    this.color = color;
-    this.count = count;
-  }
-  _left = void 0;
-  get left() {
-    return this._left;
-  }
-  set left(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._left = v;
-  }
-  _right = void 0;
-  get right() {
-    return this._right;
-  }
-  set right(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._right = v;
-  }
-  _height = 0;
-  get height() {
-    return this._height;
-  }
-  set height(value) {
-    this._height = value;
-  }
-  _color = "BLACK";
-  get color() {
-    return this._color;
-  }
-  set color(value) {
-    this._color = value;
-  }
-  _count = 1;
-  get count() {
-    return this._count;
-  }
-  set count(value) {
-    this._count = value;
-  }
-  get familyPosition() {
-    if (!this.parent) {
-      return this.left || this.right ? "ROOT" : "ISOLATED";
-    }
-    if (this.parent.left === this) {
-      return this.left || this.right ? "ROOT_LEFT" : "LEFT";
-    } else if (this.parent.right === this) {
-      return this.left || this.right ? "ROOT_RIGHT" : "RIGHT";
-    }
-    return "MAL_NODE";
-  }
-};
-var TreeCounter = class extends RedBlackTree {
-  static {
-    __name(this, "TreeCounter");
-  }
-  constructor(keysNodesEntriesOrRaws = [], options) {
-    super([], options);
-    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
-  }
-  _count = 0;
-  get count() {
-    return this._count;
-  }
-  getComputedCount() {
-    let sum = 0;
-    this.dfs((node) => sum += node ? node.count : 0);
-    return sum;
-  }
-  createNode(key, value, color = "BLACK", count) {
-    return new TreeCounterNode(key, this._isMapMode ? void 0 : value, count, color);
-  }
-  isNode(keyNodeOrEntry) {
-    return keyNodeOrEntry instanceof TreeCounterNode;
-  }
-  set(keyNodeOrEntry, value, count = 1) {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
-    const orgCount = newNode?.count || 0;
-    const isSuccessAdded = super.set(newNode, newValue);
-    if (isSuccessAdded) {
-      this._count += orgCount;
-      return true;
-    } else {
-      return false;
-    }
-  }
-  delete(keyNodeOrEntry, ignoreCount = false) {
-    if (keyNodeOrEntry === null) return [];
-    const results = [];
-    let nodeToDelete;
-    if (this._isPredicate(keyNodeOrEntry)) nodeToDelete = this.getNode(keyNodeOrEntry);
-    else nodeToDelete = this.isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : this.getNode(keyNodeOrEntry);
-    if (!nodeToDelete) {
-      return results;
-    }
-    let originalColor = nodeToDelete.color;
-    let replacementNode;
-    if (!this.isRealNode(nodeToDelete.left)) {
-      if (nodeToDelete.right !== null) replacementNode = nodeToDelete.right;
-      if (ignoreCount || nodeToDelete.count <= 1) {
-        if (nodeToDelete.right !== null) {
-          this._transplant(nodeToDelete, nodeToDelete.right);
-          this._count -= nodeToDelete.count;
-        }
-      } else {
-        nodeToDelete.count--;
-        this._count--;
-        results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-        return results;
-      }
-    } else if (!this.isRealNode(nodeToDelete.right)) {
-      replacementNode = nodeToDelete.left;
-      if (ignoreCount || nodeToDelete.count <= 1) {
-        this._transplant(nodeToDelete, nodeToDelete.left);
-        this._count -= nodeToDelete.count;
-      } else {
-        nodeToDelete.count--;
-        this._count--;
-        results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-        return results;
-      }
-    } else {
-      const successor = this.getLeftMost((node) => node, nodeToDelete.right);
-      if (successor) {
-        originalColor = successor.color;
-        if (successor.right !== null) replacementNode = successor.right;
-        if (successor.parent === nodeToDelete) {
-          if (this.isRealNode(replacementNode)) {
-            replacementNode.parent = successor;
-          }
-        } else {
-          if (ignoreCount || nodeToDelete.count <= 1) {
-            if (successor.right !== null) {
-              this._transplant(successor, successor.right);
-              this._count -= nodeToDelete.count;
-            }
-          } else {
-            nodeToDelete.count--;
-            this._count--;
-            results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-            return results;
-          }
-          successor.right = nodeToDelete.right;
-          if (this.isRealNode(successor.right)) {
-            successor.right.parent = successor;
-          }
-        }
-        if (ignoreCount || nodeToDelete.count <= 1) {
-          this._transplant(nodeToDelete, successor);
-          this._count -= nodeToDelete.count;
-        } else {
-          nodeToDelete.count--;
-          this._count--;
-          results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-          return results;
-        }
-        successor.left = nodeToDelete.left;
-        if (this.isRealNode(successor.left)) {
-          successor.left.parent = successor;
-        }
-        successor.color = nodeToDelete.color;
-      }
-    }
-    this._size--;
-    if (originalColor === "BLACK") {
-      this._deleteFixup(replacementNode);
-    }
-    results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-    return results;
-  }
-  clear() {
-    super.clear();
-    this._count = 0;
-  }
-  perfectlyBalance(iterationType = this.iterationType) {
-    const nodes = this.dfs((node) => node, "IN", false, this._root, iterationType);
-    const n = nodes.length;
-    if (n < 1) return false;
-    let total = 0;
-    for (const nd of nodes) total += nd ? nd.count : 0;
-    this._clearNodes();
-    const build =  __name((l, r, parent) => {
-      if (l > r) return void 0;
-      const m = l + (r - l >> 1);
-      const root = nodes[m];
-      const leftChild = build(l, m - 1, root);
-      const rightChild = build(m + 1, r, root);
-      root.left = leftChild;
-      root.right = rightChild;
-      root.parent = parent;
-      return root;
-    }, "build");
-    const newRoot = build(0, n - 1, void 0);
-    this._setRoot(newRoot);
-    this._size = n;
-    this._count = total;
-    return true;
-  }
-  map(callback, options, thisArg) {
-    const out = this._createLike([], options);
-    let index = 0;
-    for (const [key, value] of this) {
-      out.set(callback.call(thisArg, value, key, index++, this));
-    }
-    return out;
-  }
-  clone() {
-    const out = this._createInstance();
-    this._clone(out);
-    out._count = this._count;
-    return out;
-  }
-  _createInstance(options) {
-    const Ctor = this.constructor;
-    return new Ctor([], { ...this._snapshotOptions(), ...options ?? {} });
-  }
-  _createLike(iter = [], options) {
-    const Ctor = this.constructor;
-    return new Ctor(iter, {
-      ...this._snapshotOptions(),
-      ...options ?? {}
-    });
-  }
-  _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count = 1) {
-    if (keyNodeOrEntry === void 0 || keyNodeOrEntry === null) return [void 0, void 0];
-    if (this.isNode(keyNodeOrEntry)) return [keyNodeOrEntry, value];
-    if (this.isEntry(keyNodeOrEntry)) {
-      const [key, entryValue] = keyNodeOrEntry;
-      if (key === void 0 || key === null) return [void 0, void 0];
-      const finalValue = value ?? entryValue;
-      return [this.createNode(key, finalValue, "BLACK", count), finalValue];
-    }
-    return [this.createNode(keyNodeOrEntry, value, "BLACK", count), value];
-  }
-  _swapProperties(srcNode, destNode) {
-    srcNode = this.ensureNode(srcNode);
-    destNode = this.ensureNode(destNode);
-    if (srcNode && destNode) {
-      const { key, value, count, color } = destNode;
-      const tempNode = this.createNode(key, value, color, count);
-      if (tempNode) {
-        tempNode.color = color;
-        destNode.key = srcNode.key;
-        if (!this._isMapMode) destNode.value = srcNode.value;
-        destNode.count = srcNode.count;
-        destNode.color = srcNode.color;
-        srcNode.key = tempNode.key;
-        if (!this._isMapMode) srcNode.value = tempNode.value;
-        srcNode.count = tempNode.count;
-        srcNode.color = tempNode.color;
-      }
-      return destNode;
-    }
-    return void 0;
-  }
-  _replaceNode(oldNode, newNode) {
-    newNode.count = oldNode.count + newNode.count;
-    return super._replaceNode(oldNode, newNode);
-  }
-};
-export {
-  TreeCounter,
-  TreeCounterNode
-};