data-structure-typed 2.5.0 → 2.5.2

package/dist/leetcode/binary-tree.mjs

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