data-structure-typed 2.2.7 → 2.2.8

package/dist/leetcode/avl-tree-multi-map.mjs

@@ -0,0 +1,2889 @@
+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 AVLTreeNode = class {
+  static {
+    __name(this, "AVLTreeNode");
+  }
+  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 AVLTree = class extends BST {
+  static {
+    __name(this, "AVLTree");
+  }
+  constructor(keysNodesEntriesOrRaws = [], options) {
+    super([], options);
+    if (keysNodesEntriesOrRaws) super.setMany(keysNodesEntriesOrRaws);
+  }
+  createNode(key, value) {
+    return new AVLTreeNode(key, this._isMapMode ? void 0 : value);
+  }
+  isNode(keyNodeOrEntry) {
+    return keyNodeOrEntry instanceof AVLTreeNode;
+  }
+  set(keyNodeOrEntry, value) {
+    if (keyNodeOrEntry === null) return false;
+    const inserted = super.set(keyNodeOrEntry, value);
+    if (inserted) this._balancePath(keyNodeOrEntry);
+    return inserted;
+  }
+  delete(keyNodeOrEntry) {
+    const deletedResults = super.delete(keyNodeOrEntry);
+    for (const { needBalanced } of deletedResults) {
+      if (needBalanced) {
+        this._balancePath(needBalanced);
+      }
+    }
+    return deletedResults;
+  }
+  perfectlyBalance(iterationType = this.iterationType) {
+    const nodes = this.dfs((node) => node, "IN", false, this._root, iterationType);
+    const n = nodes.length;
+    if (n === 0) return false;
+    this._clearNodes();
+    const build =  __name((l, r, parent) => {
+      if (l > r) return void 0;
+      const m = l + (r - l >> 1);
+      const root = nodes[m];
+      root.left = build(l, m - 1, root);
+      root.right = build(m + 1, r, root);
+      root.parent = parent;
+      const lh = root.left ? root.left.height : -1;
+      const rh = root.right ? root.right.height : -1;
+      root.height = Math.max(lh, rh) + 1;
+      return root;
+    }, "build");
+    const newRoot = build(0, n - 1, void 0);
+    this._setRoot(newRoot);
+    this._size = n;
+    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;
+  }
+  _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 ?? {} });
+  }
+  _swapProperties(srcNode, destNode) {
+    const srcNodeEnsured = this.ensureNode(srcNode);
+    const destNodeEnsured = this.ensureNode(destNode);
+    if (srcNodeEnsured && destNodeEnsured) {
+      const { key, value, height } = destNodeEnsured;
+      const tempNode = this.createNode(key, value);
+      if (tempNode) {
+        tempNode.height = height;
+        destNodeEnsured.key = srcNodeEnsured.key;
+        if (!this._isMapMode) destNodeEnsured.value = srcNodeEnsured.value;
+        destNodeEnsured.height = srcNodeEnsured.height;
+        srcNodeEnsured.key = tempNode.key;
+        if (!this._isMapMode) srcNodeEnsured.value = tempNode.value;
+        srcNodeEnsured.height = tempNode.height;
+      }
+      return destNodeEnsured;
+    }
+    return void 0;
+  }
+  _balanceFactor(node) {
+    const left = node.left ? node.left.height : -1;
+    const right = node.right ? node.right.height : -1;
+    return right - left;
+  }
+  _updateHeight(node) {
+    const leftHeight = node.left ? node.left.height : -1;
+    const rightHeight = node.right ? node.right.height : -1;
+    node.height = 1 + Math.max(leftHeight, rightHeight);
+  }
+  _balanceLL(A) {
+    const parentOfA = A.parent;
+    const B = A.left;
+    if (B !== null) A.parent = B;
+    if (B && B.right) {
+      B.right.parent = A;
+    }
+    if (B) B.parent = parentOfA;
+    if (A === this.root) {
+      if (B) this._setRoot(B);
+    } else {
+      if (parentOfA?.left === A) {
+        parentOfA.left = B;
+      } else {
+        if (parentOfA) parentOfA.right = B;
+      }
+    }
+    if (B) {
+      A.left = B.right;
+      B.right = A;
+    }
+    this._updateHeight(A);
+    if (B) this._updateHeight(B);
+  }
+  _balanceLR(A) {
+    const parentOfA = A.parent;
+    const B = A.left;
+    let C = void 0;
+    if (B) {
+      C = B.right;
+    }
+    if (A && C !== null) A.parent = C;
+    if (B && C !== null) B.parent = C;
+    if (C) {
+      if (C.left) {
+        if (B !== null) C.left.parent = B;
+      }
+      if (C.right) {
+        C.right.parent = A;
+      }
+      C.parent = parentOfA;
+    }
+    if (A === this.root) {
+      if (C) this._setRoot(C);
+    } else {
+      if (parentOfA) {
+        if (parentOfA.left === A) {
+          parentOfA.left = C;
+        } else {
+          parentOfA.right = C;
+        }
+      }
+    }
+    if (C) {
+      A.left = C.right;
+      if (B) B.right = C.left;
+      C.left = B;
+      C.right = A;
+    }
+    this._updateHeight(A);
+    if (B) this._updateHeight(B);
+    if (C) this._updateHeight(C);
+  }
+  _balanceRR(A) {
+    const parentOfA = A.parent;
+    const B = A.right;
+    if (B !== null) A.parent = B;
+    if (B) {
+      if (B.left) {
+        B.left.parent = A;
+      }
+      B.parent = parentOfA;
+    }
+    if (A === this.root) {
+      if (B) this._setRoot(B);
+    } else {
+      if (parentOfA) {
+        if (parentOfA.left === A) {
+          parentOfA.left = B;
+        } else {
+          parentOfA.right = B;
+        }
+      }
+    }
+    if (B) {
+      A.right = B.left;
+      B.left = A;
+    }
+    this._updateHeight(A);
+    if (B) this._updateHeight(B);
+  }
+  _balanceRL(A) {
+    const parentOfA = A.parent;
+    const B = A.right;
+    let C = void 0;
+    if (B) {
+      C = B.left;
+    }
+    if (C !== null) A.parent = C;
+    if (B && C !== null) B.parent = C;
+    if (C) {
+      if (C.left) {
+        C.left.parent = A;
+      }
+      if (C.right) {
+        if (B !== null) C.right.parent = B;
+      }
+      C.parent = parentOfA;
+    }
+    if (A === this.root) {
+      if (C) this._setRoot(C);
+    } else {
+      if (parentOfA) {
+        if (parentOfA.left === A) {
+          parentOfA.left = C;
+        } else {
+          parentOfA.right = C;
+        }
+      }
+    }
+    if (C) A.right = C.left;
+    if (B && C) B.left = C.right;
+    if (C) C.left = A;
+    if (C) C.right = B;
+    this._updateHeight(A);
+    if (B) this._updateHeight(B);
+    if (C) this._updateHeight(C);
+  }
+  _balancePath(node) {
+    node = this.ensureNode(node);
+    const path = this.getPathToRoot(node, (node2) => node2, false);
+    for (let i = 0; i < path.length; i++) {
+      const A = path[i];
+      if (A) {
+        this._updateHeight(A);
+        switch (this._balanceFactor(A)) {
+          case -2:
+            if (A && A.left) {
+              if (this._balanceFactor(A.left) <= 0) {
+                this._balanceLL(A);
+              } else {
+                this._balanceLR(A);
+              }
+            }
+            break;
+          case 2:
+            if (A && A.right) {
+              if (this._balanceFactor(A.right) >= 0) {
+                this._balanceRR(A);
+              } else {
+                this._balanceRL(A);
+              }
+            }
+        }
+      }
+    }
+  }
+  _replaceNode(oldNode, newNode) {
+    newNode.height = oldNode.height;
+    return super._replaceNode(oldNode, newNode);
+  }
+};
+var AVLTreeMultiMapNode = class {
+  static {
+    __name(this, "AVLTreeMultiMapNode");
+  }
+  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 AVLTreeMultiMap = class extends AVLTree {
+  static {
+    __name(this, "AVLTreeMultiMap");
+  }
+  constructor(keysNodesEntriesOrRaws = [], options) {
+    super([], { ...options, isMapMode: true });
+    if (keysNodesEntriesOrRaws) {
+      this.setMany(keysNodesEntriesOrRaws);
+    }
+  }
+  createNode(key, value = []) {
+    return new AVLTreeMultiMapNode(key, this._isMapMode ? [] : value);
+  }
+  isNode(keyNodeOrEntry) {
+    return keyNodeOrEntry instanceof AVLTreeMultiMapNode;
+  }
+  set(keyNodeOrEntry, value) {
+    if (this.isRealNode(keyNodeOrEntry)) return super.set(keyNodeOrEntry);
+    const _commonAdd =  __name((key, values) => {
+      if (key === void 0 || key === null) return false;
+      const _setToValues =  __name(() => {
+        const existingValues = this.get(key);
+        if (existingValues !== void 0 && values !== void 0) {
+          for (const value2 of values) existingValues.push(value2);
+          return true;
+        }
+        return false;
+      }, "_setToValues");
+      const _setByNode =  __name(() => {
+        const existingNode = this.getNode(key);
+        if (this.isRealNode(existingNode)) {
+          const existingValues = this.get(existingNode);
+          if (existingValues === void 0) {
+            super.set(key, values);
+            return true;
+          }
+          if (values !== void 0) {
+            for (const value2 of values) existingValues.push(value2);
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return super.set(key, values);
+        }
+      }, "_setByNode");
+      if (this._isMapMode) {
+        return _setByNode() || _setToValues();
+      }
+      return _setToValues() || _setByNode();
+    }, "_commonAdd");
+    if (this.isEntry(keyNodeOrEntry)) {
+      const [key, values] = keyNodeOrEntry;
+      return _commonAdd(key, value !== void 0 ? [value] : values);
+    }
+    return _commonAdd(keyNodeOrEntry, value !== void 0 ? [value] : void 0);
+  }
+  deleteValue(keyNodeOrEntry, value) {
+    const values = this.get(keyNodeOrEntry);
+    if (Array.isArray(values)) {
+      const index = values.indexOf(value);
+      if (index === -1) return false;
+      values.splice(index, 1);
+      if (values.length === 0) this.delete(keyNodeOrEntry);
+      return true;
+    }
+    return false;
+  }
+  perfectlyBalance(iterationType = this.iterationType) {
+    const nodes = this.dfs((node) => node, "IN", false, this._root, iterationType);
+    const n = nodes.length;
+    if (n === 0) return false;
+    this._clearNodes();
+    const build =  __name((l, r, parent) => {
+      if (l > r) return void 0;
+      const m = l + (r - l >> 1);
+      const root = nodes[m];
+      root.left = build(l, m - 1, root);
+      root.right = build(m + 1, r, root);
+      root.parent = parent;
+      const lh = root.left ? root.left.height : -1;
+      const rh = root.right ? root.right.height : -1;
+      root.height = Math.max(lh, rh) + 1;
+      return root;
+    }, "build");
+    const newRoot = build(0, n - 1, void 0);
+    this._setRoot(newRoot);
+    this._size = n;
+    return true;
+  }
+  map(callback, options, thisArg) {
+    const out = this._createLike([], options);
+    let i = 0;
+    for (const [k, v] of this) out.set(callback.call(thisArg, v, k, i++, 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 ?? {} });
+  }
+};
+export {
+  AVLTreeMultiMap,
+  AVLTreeMultiMapNode
+};