bst-typed 2.1.0 → 2.1.2

package/dist/umd/bst-typed.js

@@ -0,0 +1,3410 @@
+"use strict";
+var bstTyped = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    BST: () => BST,
+    BSTNode: () => BSTNode,
+    BinaryTree: () => BinaryTree,
+    BinaryTreeNode: () => BinaryTreeNode,
+    DFSOperation: () => DFSOperation,
+    Range: () => Range
+  });
+
+  // src/utils/utils.ts
+  function isPrimitiveComparable(value) {
+    const valueType = typeof value;
+    if (valueType === "number") return true;
+    return valueType === "bigint" || valueType === "string" || valueType === "boolean";
+  }
+  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;
+  }
+  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);
+  }
+  var makeTrampolineThunk = (computation) => ({
+    isThunk: true,
+    // Marker indicating this is a thunk
+    fn: computation
+    // The deferred computation function
+  });
+  var isTrampolineThunk = (value) => typeof value === "object" && // Must be an object
+  value !== null && // Must not be null
+  "isThunk" in value && // Must have the 'isThunk' property
+  value.isThunk;
+  function trampoline(initial) {
+    let current = initial;
+    while (isTrampolineThunk(current)) {
+      current = current.fn();
+    }
+    return current;
+  }
+  function makeTrampoline(fn) {
+    return (...args) => trampoline(fn(...args));
+  }
+
+  // src/data-structures/base/iterable-element-base.ts
+  var IterableElementBase = class {
+    /**
+     * Create a new iterable base.
+     *
+     * @param options Optional behavior overrides. When provided, a `toElementFn`
+     * is used to convert a raw element (`R`) into a public element (`E`).
+     *
+     * @remarks
+     * Time O(1), Space O(1).
+     */
+    constructor(options) {
+      /**
+       * The converter used to transform a raw element (`R`) into a public element (`E`).
+       *
+       * @remarks
+       * Time O(1), Space O(1).
+       */
+      __publicField(this, "_toElementFn");
+      if (options) {
+        const { toElementFn } = options;
+        if (typeof toElementFn === "function") this._toElementFn = toElementFn;
+        else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+      }
+    }
+    /**
+     * Exposes the current `toElementFn`, if configured.
+     *
+     * @returns The converter function or `undefined` when not set.
+     * @remarks
+     * Time O(1), Space O(1).
+     */
+    get toElementFn() {
+      return this._toElementFn;
+    }
+    /**
+     * Returns an iterator over the structure's elements.
+     *
+     * @param args Optional iterator arguments forwarded to the internal iterator.
+     * @returns An `IterableIterator<E>` that yields the elements in traversal order.
+     *
+     * @remarks
+     * Producing the iterator is O(1); consuming the entire iterator is Time O(n) with O(1) extra space.
+     */
+    *[Symbol.iterator](...args) {
+      yield* this._getIterator(...args);
+    }
+    /**
+     * Returns an iterator over the values (alias of the default iterator).
+     *
+     * @returns An `IterableIterator<E>` over all elements.
+     * @remarks
+     * Creating the iterator is O(1); full iteration is Time O(n), Space O(1).
+     */
+    *values() {
+      for (const item of this) yield item;
+    }
+    /**
+     * Tests whether all elements satisfy the predicate.
+     *
+     * @template TReturn
+     * @param predicate Function invoked for each element with signature `(value, index, self)`.
+     * @param thisArg Optional `this` binding for the predicate.
+     * @returns `true` if every element passes; otherwise `false`.
+     *
+     * @remarks
+     * Time O(n) in the worst case; may exit early when the first failure is found. Space O(1).
+     */
+    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;
+    }
+    /**
+     * Tests whether at least one element satisfies the predicate.
+     *
+     * @param predicate Function invoked for each element with signature `(value, index, self)`.
+     * @param thisArg Optional `this` binding for the predicate.
+     * @returns `true` if any element passes; otherwise `false`.
+     *
+     * @remarks
+     * Time O(n) in the worst case; may exit early on first success. Space O(1).
+     */
+    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;
+    }
+    /**
+     * Invokes a callback for each element in iteration order.
+     *
+     * @param callbackfn Function invoked per element with signature `(value, index, self)`.
+     * @param thisArg Optional `this` binding for the callback.
+     * @returns `void`.
+     *
+     * @remarks
+     * Time O(n), Space O(1).
+     */
+    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);
+        }
+      }
+    }
+    // Implementation signature
+    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;
+    }
+    /**
+     * Checks whether a strictly-equal element exists in the structure.
+     *
+     * @param element The element to test with `===` equality.
+     * @returns `true` if an equal element is found; otherwise `false`.
+     *
+     * @remarks
+     * Time O(n) in the worst case. Space O(1).
+     */
+    has(element) {
+      for (const ele of this) if (ele === element) return true;
+      return false;
+    }
+    /**
+     * Reduces all elements to a single accumulated value.
+     *
+     * @overload
+     * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`. The first element is used as the initial accumulator.
+     * @returns The final accumulated value typed as `E`.
+     *
+     * @overload
+     * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`.
+     * @param initialValue The initial accumulator value of type `E`.
+     * @returns The final accumulated value typed as `E`.
+     *
+     * @overload
+     * @template U The accumulator type when it differs from `E`.
+     * @param callbackfn Reducer of signature `(acc: U, value, index, self) => U`.
+     * @param initialValue The initial accumulator value of type `U`.
+     * @returns The final accumulated value typed as `U`.
+     *
+     * @remarks
+     * Time O(n), Space O(1). Throws if called on an empty structure without `initialValue`.
+     */
+    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;
+    }
+    /**
+     * Materializes the elements into a new array.
+     *
+     * @returns A shallow array copy of the iteration order.
+     * @remarks
+     * Time O(n), Space O(n).
+     */
+    toArray() {
+      return [...this];
+    }
+    /**
+     * Returns a representation of the structure suitable for quick visualization.
+     * Defaults to an array of elements; subclasses may override to provide richer visuals.
+     *
+     * @returns A visual representation (array by default).
+     * @remarks
+     * Time O(n), Space O(n).
+     */
+    toVisual() {
+      return [...this];
+    }
+    /**
+     * Prints `toVisual()` to the console. Intended for quick debugging.
+     *
+     * @returns `void`.
+     * @remarks
+     * Time O(n) due to materialization, Space O(n) for the intermediate representation.
+     */
+    print() {
+      console.log(this.toVisual());
+    }
+  };
+
+  // src/data-structures/base/linear-base.ts
+  var LinearBase = class _LinearBase extends IterableElementBase {
+    /**
+     * Construct a linear container with runtime options.
+     * @param options - `{ maxLen?, ... }` bounds/behavior options.
+     * @remarks Time O(1), Space O(1)
+     */
+    constructor(options) {
+      super(options);
+      __publicField(this, "_maxLen", -1);
+      if (options) {
+        const { maxLen } = options;
+        if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+      }
+    }
+    /**
+     * Upper bound for length (if positive), or `-1` when unbounded.
+     * @returns Maximum allowed length.
+     * @remarks Time O(1), Space O(1)
+     */
+    get maxLen() {
+      return this._maxLen;
+    }
+    /**
+     * First index of a value from the left.
+     * @param searchElement - Value to match.
+     * @param fromIndex - Start position (supports negative index).
+     * @returns Index or `-1` if not found.
+     * @remarks Time O(n), Space O(1)
+     */
+    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;
+    }
+    /**
+     * Last index of a value from the right.
+     * @param searchElement - Value to match.
+     * @param fromIndex - Start position (supports negative index).
+     * @returns Index or `-1` if not found.
+     * @remarks Time O(n), Space O(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;
+    }
+    /**
+     * Find the first index matching a predicate.
+     * @param predicate - `(element, index, self) => boolean`.
+     * @param thisArg - Optional `this` for callback.
+     * @returns Index or `-1`.
+     * @remarks Time O(n), Space O(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;
+    }
+    /**
+     * Concatenate elements and/or containers.
+     * @param items - Elements or other containers.
+     * @returns New container with combined elements (`this` type).
+     * @remarks Time O(sum(length)), Space O(sum(length))
+     */
+    concat(...items) {
+      const newList = this.clone();
+      for (const item of items) {
+        if (item instanceof _LinearBase) {
+          newList.pushMany(item);
+        } else {
+          newList.push(item);
+        }
+      }
+      return newList;
+    }
+    /**
+     * In-place stable order via array sort semantics.
+     * @param compareFn - Comparator `(a, b) => number`.
+     * @returns This container.
+     * @remarks Time O(n log n), Space O(n) (materializes to array temporarily)
+     */
+    sort(compareFn) {
+      const arr = this.toArray();
+      arr.sort(compareFn);
+      this.clear();
+      for (const item of arr) this.push(item);
+      return this;
+    }
+    /**
+     * Remove and/or insert elements at a position (array-compatible).
+     * @param start - Start index (supports negative index).
+     * @param deleteCount - How many to remove.
+     * @param items - Elements to insert.
+     * @returns Removed elements as a new list (`this` type).
+     * @remarks Time O(n + m), Space O(min(n, m)) where `m = items.length`
+     */
+    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 all elements into a string.
+     * @param separator - Separator string.
+     * @returns Concatenated string.
+     * @remarks Time O(n), Space O(n)
+     */
+    join(separator = ",") {
+      return this.toArray().join(separator);
+    }
+    /**
+     * Snapshot elements into a reversed array.
+     * @returns New reversed array.
+     * @remarks Time O(n), Space O(n)
+     */
+    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 != null ? initialValue : 0;
+      for (let i = this.length - 1; i >= 0; i--) {
+        accumulator = callbackfn(accumulator, this.at(i), i, this);
+      }
+      return accumulator;
+    }
+    /**
+     * Create a shallow copy of a subrange.
+     * @param start - Inclusive start (supports negative index).
+     * @param end - Exclusive end (supports negative index).
+     * @returns New list with the range (`this` type).
+     * @remarks Time O(n), Space O(n)
+     */
+    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 a range with a value.
+     * @param value - Value to set.
+     * @param start - Inclusive start.
+     * @param end - Exclusive end.
+     * @returns This list.
+     * @remarks Time O(n), Space O(1)
+     */
+    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;
+    }
+  };
+
+  // src/data-structures/queue/queue.ts
+  var Queue = class _Queue extends LinearBase {
+    /**
+     * Create a Queue and optionally bulk-insert elements.
+     * @remarks Time O(N), Space O(N)
+     * @param [elements] - Iterable of elements (or raw records if toElementFn is set).
+     * @param [options] - Options such as toElementFn, maxLen, and autoCompactRatio.
+     * @returns New Queue instance.
+     */
+    constructor(elements = [], options) {
+      super(options);
+      __publicField(this, "_elements", []);
+      __publicField(this, "_offset", 0);
+      __publicField(this, "_autoCompactRatio", 0.5);
+      if (options) {
+        const { autoCompactRatio = 0.5 } = options;
+        this._autoCompactRatio = autoCompactRatio;
+      }
+      this.pushMany(elements);
+    }
+    /**
+     * Get the underlying array buffer.
+     * @remarks Time O(1), Space O(1)
+     * @returns Backing array of elements.
+     */
+    get elements() {
+      return this._elements;
+    }
+    /**
+     * Get the current start offset into the array.
+     * @remarks Time O(1), Space O(1)
+     * @returns Zero-based offset.
+     */
+    get offset() {
+      return this._offset;
+    }
+    /**
+     * Get the compaction threshold (offset/size).
+     * @remarks Time O(1), Space O(1)
+     * @returns Auto-compaction ratio in (0,1].
+     */
+    get autoCompactRatio() {
+      return this._autoCompactRatio;
+    }
+    /**
+     * Set the compaction threshold.
+     * @remarks Time O(1), Space O(1)
+     * @param value - New ratio; compacts when offset/size exceeds this value.
+     * @returns void
+     */
+    set autoCompactRatio(value) {
+      this._autoCompactRatio = value;
+    }
+    /**
+     * Get the number of elements currently in the queue.
+     * @remarks Time O(1), Space O(1)
+     * @returns Current length.
+     */
+    get length() {
+      return this.elements.length - this._offset;
+    }
+    /**
+     * Get the first element (front) without removing it.
+     * @remarks Time O(1), Space O(1)
+     * @returns Front element or undefined.
+     */
+    get first() {
+      return this.length > 0 ? this.elements[this._offset] : void 0;
+    }
+    /**
+     * Get the last element (back) without removing it.
+     * @remarks Time O(1), Space O(1)
+     * @returns Back element or undefined.
+     */
+    get last() {
+      return this.length > 0 ? this.elements[this.elements.length - 1] : void 0;
+    }
+    /**
+     * Create a queue from an array of elements.
+     * @remarks Time O(N), Space O(N)
+     * @template E
+     * @param elements - Array of elements to enqueue in order.
+     * @returns A new queue populated from the array.
+     */
+    static fromArray(elements) {
+      return new _Queue(elements);
+    }
+    /**
+     * Check whether the queue is empty.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if length is 0.
+     */
+    isEmpty() {
+      return this.length === 0;
+    }
+    /**
+     * Enqueue one element at the back.
+     * @remarks Time O(1), Space O(1)
+     * @param element - Element to enqueue.
+     * @returns True on success.
+     */
+    push(element) {
+      this.elements.push(element);
+      if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
+      return true;
+    }
+    /**
+     * Enqueue many elements from an iterable.
+     * @remarks Time O(N), Space O(1)
+     * @param elements - Iterable of elements (or raw records if toElementFn is set).
+     * @returns Array of per-element success flags.
+     */
+    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;
+    }
+    /**
+     * Dequeue one element from the front (amortized via offset).
+     * @remarks Time O(1) amortized, Space O(1)
+     * @returns Removed element or undefined.
+     */
+    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 the first occurrence of a specific element.
+     * @remarks Time O(N), Space O(1)
+     * @param element - Element to remove (strict equality via Object.is).
+     * @returns True if an element was removed.
+     */
+    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;
+    }
+    /**
+     * Get the element at a given logical index.
+     * @remarks Time O(1), Space O(1)
+     * @param index - Zero-based index from the front.
+     * @returns Element or undefined.
+     */
+    at(index) {
+      if (index < 0 || index >= this.length) return void 0;
+      return this._elements[this._offset + index];
+    }
+    /**
+     * Delete the element at a given index.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index from the front.
+     * @returns Removed element or undefined.
+     */
+    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;
+    }
+    /**
+     * Insert a new element at a given index.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index from the front.
+     * @param newElement - Element to insert.
+     * @returns True if inserted.
+     */
+    addAt(index, newElement) {
+      if (index < 0 || index > this.length) return false;
+      this._elements.splice(this._offset + index, 0, newElement);
+      return true;
+    }
+    /**
+     * Replace the element at a given index.
+     * @remarks Time O(1), Space O(1)
+     * @param index - Zero-based index from the front.
+     * @param newElement - New element to set.
+     * @returns True if updated.
+     */
+    setAt(index, newElement) {
+      if (index < 0 || index >= this.length) return false;
+      this._elements[this._offset + index] = newElement;
+      return true;
+    }
+    /**
+     * Reverse the queue in-place by compacting then reversing.
+     * @remarks Time O(N), Space O(N)
+     * @returns This queue.
+     */
+    reverse() {
+      this._elements = this.elements.slice(this._offset).reverse();
+      this._offset = 0;
+      return this;
+    }
+    /**
+     * Remove all elements and reset offset.
+     * @remarks Time O(1), Space O(1)
+     * @returns void
+     */
+    clear() {
+      this._elements = [];
+      this._offset = 0;
+    }
+    /**
+     * Compact storage by discarding consumed head elements.
+     * @remarks Time O(N), Space O(N)
+     * @returns True when compaction performed.
+     */
+    compact() {
+      this._elements = this.elements.slice(this._offset);
+      this._offset = 0;
+      return true;
+    }
+    /**
+     * Remove and/or insert elements at a position (array-like).
+     * @remarks Time O(N + M), Space O(M)
+     * @param start - Start index (clamped to [0, length]).
+     * @param [deleteCount] - Number of elements to remove (default 0).
+     * @param [items] - Elements to insert after `start`.
+     * @returns A new queue containing the removed elements (typed as `this`).
+     */
+    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;
+    }
+    /**
+     * Deep clone this queue and its parameters.
+     * @remarks Time O(N), Space O(N)
+     * @returns A new queue with the same content and options.
+     */
+    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 elements into a new queue of the same class.
+     * @remarks Time O(N), Space O(N)
+     * @param predicate - Predicate (element, index, queue) → boolean to keep element.
+     * @param [thisArg] - Value for `this` inside the predicate.
+     * @returns A new queue with kept elements.
+     */
+    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 each element to a new element in a possibly different-typed queue.
+     * @remarks Time O(N), Space O(N)
+     * @template EM
+     * @template RM
+     * @param callback - Mapping function (element, index, queue) → newElement.
+     * @param [options] - Options for the output queue (e.g., toElementFn, maxLen, autoCompactRatio).
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new Queue with mapped elements.
+     */
+    map(callback, options, thisArg) {
+      var _a, _b;
+      const out = new this.constructor([], {
+        toElementFn: options == null ? void 0 : options.toElementFn,
+        maxLen: (_a = options == null ? void 0 : options.maxLen) != null ? _a : this._maxLen,
+        autoCompactRatio: (_b = options == null ? void 0 : options.autoCompactRatio) != null ? _b : 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;
+    }
+    /**
+     * Map each element to a new value of the same type.
+     * @remarks Time O(N), Space O(N)
+     * @param callback - Mapping function (element, index, queue) → element.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new queue with mapped elements (same element type).
+     */
+    mapSame(callback, thisArg) {
+      var _a;
+      const Ctor = this.constructor;
+      const out = new Ctor([], {
+        toElementFn: this.toElementFn,
+        maxLen: this._maxLen,
+        autoCompactRatio: this._autoCompactRatio
+      });
+      (_a = out._setAutoCompactRatio) == null ? void 0 : _a.call(out, 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;
+    }
+    /**
+     * (Protected) Set the internal auto-compaction ratio.
+     * @remarks Time O(1), Space O(1)
+     * @param value - New ratio to assign.
+     * @returns void
+     */
+    _setAutoCompactRatio(value) {
+      this._autoCompactRatio = value;
+    }
+    /**
+     * (Protected) Iterate elements from front to back.
+     * @remarks Time O(N), Space O(1)
+     * @returns Iterator of E.
+     */
+    *_getIterator() {
+      for (let i = this._offset; i < this.elements.length; i++) yield this.elements[i];
+    }
+    /**
+     * (Protected) Iterate elements from back to front.
+     * @remarks Time O(N), Space O(1)
+     * @returns Iterator of E.
+     */
+    *_getReverseIterator() {
+      for (let i = this.length - 1; i >= 0; i--) {
+        const cur = this.at(i);
+        if (cur !== void 0) yield cur;
+      }
+    }
+    /**
+     * (Protected) Create an empty instance of the same concrete class.
+     * @remarks Time O(1), Space O(1)
+     * @param [options] - Options forwarded to the constructor.
+     * @returns An empty like-kind queue instance.
+     */
+    _createInstance(options) {
+      const Ctor = this.constructor;
+      return new Ctor([], options);
+    }
+    /**
+     * (Protected) Create a like-kind queue and seed it from an iterable.
+     * @remarks Time O(N), Space O(N)
+     * @template EM
+     * @template RM
+     * @param [elements] - Iterable used to seed the new queue.
+     * @param [options] - Options forwarded to the constructor.
+     * @returns A like-kind Queue instance.
+     */
+    _createLike(elements = [], options) {
+      const Ctor = this.constructor;
+      return new Ctor(elements, options);
+    }
+  };
+
+  // src/data-structures/base/iterable-entry-base.ts
+  var IterableEntryBase = class {
+    /**
+     * Default iterator yielding `[key, value]` entries.
+     * @returns Iterator of `[K, V]`.
+     * @remarks Time O(n) to iterate, Space O(1)
+     */
+    *[Symbol.iterator](...args) {
+      yield* this._getIterator(...args);
+    }
+    /**
+     * Iterate over `[key, value]` pairs (may yield `undefined` values).
+     * @returns Iterator of `[K, V | undefined]`.
+     * @remarks Time O(n), Space O(1)
+     */
+    *entries() {
+      for (const item of this) {
+        yield item;
+      }
+    }
+    /**
+     * Iterate over keys only.
+     * @returns Iterator of keys.
+     * @remarks Time O(n), Space O(1)
+     */
+    *keys() {
+      for (const item of this) {
+        yield item[0];
+      }
+    }
+    /**
+     * Iterate over values only.
+     * @returns Iterator of values.
+     * @remarks Time O(n), Space O(1)
+     */
+    *values() {
+      for (const item of this) {
+        yield item[1];
+      }
+    }
+    /**
+     * Test whether all entries satisfy the predicate.
+     * @param predicate - `(key, value, index, self) => boolean`.
+     * @param thisArg - Optional `this` for callback.
+     * @returns `true` if all pass; otherwise `false`.
+     * @remarks Time O(n), Space O(1)
+     */
+    every(predicate, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        if (!predicate.call(thisArg, item[0], item[1], index++, this)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    /**
+     * Test whether any entry satisfies the predicate.
+     * @param predicate - `(key, value, index, self) => boolean`.
+     * @param thisArg - Optional `this` for callback.
+     * @returns `true` if any passes; otherwise `false`.
+     * @remarks Time O(n), Space O(1)
+     */
+    some(predicate, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        if (predicate.call(thisArg, item[0], item[1], index++, this)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    /**
+     * Visit each entry, left-to-right.
+     * @param callbackfn - `(key, value, index, self) => void`.
+     * @param thisArg - Optional `this` for callback.
+     * @remarks Time O(n), Space O(1)
+     */
+    forEach(callbackfn, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        const [key, value] = item;
+        callbackfn.call(thisArg, key, value, index++, this);
+      }
+    }
+    /**
+     * Find the first entry that matches a predicate.
+     * @param callbackfn - `(key, value, index, self) => boolean`.
+     * @param thisArg - Optional `this` for callback.
+     * @returns Matching `[key, value]` or `undefined`.
+     * @remarks Time O(n), Space O(1)
+     */
+    find(callbackfn, thisArg) {
+      let index = 0;
+      for (const item of this) {
+        const [key, value] = item;
+        if (callbackfn.call(thisArg, key, value, index++, this)) return item;
+      }
+      return;
+    }
+    /**
+     * Whether the given key exists.
+     * @param key - Key to test.
+     * @returns `true` if found; otherwise `false`.
+     * @remarks Time O(n) generic, Space O(1)
+     */
+    has(key) {
+      for (const item of this) {
+        const [itemKey] = item;
+        if (itemKey === key) return true;
+      }
+      return false;
+    }
+    /**
+     * Whether there exists an entry with the given value.
+     * @param value - Value to test.
+     * @returns `true` if found; otherwise `false`.
+     * @remarks Time O(n), Space O(1)
+     */
+    hasValue(value) {
+      for (const [, elementValue] of this) {
+        if (elementValue === value) return true;
+      }
+      return false;
+    }
+    /**
+     * Get the value under a key.
+     * @param key - Key to look up.
+     * @returns Value or `undefined`.
+     * @remarks Time O(n) generic, Space O(1)
+     */
+    get(key) {
+      for (const item of this) {
+        const [itemKey, value] = item;
+        if (itemKey === key) return value;
+      }
+      return;
+    }
+    /**
+     * Reduce entries into a single accumulator.
+     * @param callbackfn - `(acc, value, key, index, self) => acc`.
+     * @param initialValue - Initial accumulator.
+     * @returns Final accumulator.
+     * @remarks Time O(n), Space O(1)
+     */
+    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;
+    }
+    /**
+     * Visualize the iterable as an array of `[key, value]` pairs (or a custom string).
+     * @returns Array of entries (default) or a string.
+     * @remarks Time O(n), Space O(n)
+     */
+    toVisual() {
+      return [...this];
+    }
+    /**
+     * Print a human-friendly representation to the console.
+     * @remarks Time O(n), Space O(n)
+     */
+    print() {
+      console.log(this.toVisual());
+    }
+  };
+
+  // src/common/index.ts
+  var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
+    DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
+    DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
+    return DFSOperation2;
+  })(DFSOperation || {});
+  var Range = class {
+    constructor(low, high, includeLow = true, includeHigh = true) {
+      this.low = low;
+      this.high = high;
+      this.includeLow = includeLow;
+      this.includeHigh = includeHigh;
+      if (!(isComparable(low) && isComparable(high))) throw new RangeError("low or high is not comparable");
+      if (low > high) throw new RangeError("low must be less than or equal to high");
+    }
+    // Determine whether a key is within the 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;
+    }
+  };
+
+  // src/data-structures/binary-tree/binary-tree.ts
+  var BinaryTreeNode = class {
+    /**
+     * Creates an instance of BinaryTreeNode.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param key - The key of the node.
+     * @param [value] - The value associated with the key.
+     */
+    constructor(key, value) {
+      __publicField(this, "key");
+      __publicField(this, "value");
+      __publicField(this, "parent");
+      __publicField(this, "_left");
+      __publicField(this, "_right");
+      __publicField(this, "_height", 0);
+      __publicField(this, "_color", "BLACK");
+      __publicField(this, "_count", 1);
+      this.key = key;
+      this.value = value;
+    }
+    /**
+     * Gets the left child of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The left child.
+     */
+    get left() {
+      return this._left;
+    }
+    /**
+     * Sets the left child of the node and updates its parent reference.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param v - The node to set as the left child.
+     */
+    set left(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._left = v;
+    }
+    /**
+     * Gets the right child of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The right child.
+     */
+    get right() {
+      return this._right;
+    }
+    /**
+     * Sets the right child of the node and updates its parent reference.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param v - The node to set as the right child.
+     */
+    set right(v) {
+      if (v) {
+        v.parent = this;
+      }
+      this._right = v;
+    }
+    /**
+     * Gets the height of the node (used in self-balancing trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The height.
+     */
+    get height() {
+      return this._height;
+    }
+    /**
+     * Sets the height of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new height.
+     */
+    set height(value) {
+      this._height = value;
+    }
+    /**
+     * Gets the color of the node (used in Red-Black trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The node's color.
+     */
+    get color() {
+      return this._color;
+    }
+    /**
+     * Sets the color of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new color.
+     */
+    set color(value) {
+      this._color = value;
+    }
+    /**
+     * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The subtree node count.
+     */
+    get count() {
+      return this._count;
+    }
+    /**
+     * Sets the count of nodes in the subtree.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new count.
+     */
+    set count(value) {
+      this._count = value;
+    }
+    /**
+     * Gets the position of the node relative to its parent.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+     */
+    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 {
+    /**
+     * Creates an instance of BinaryTree.
+     * @remarks Time O(N * M), where N is the number of items in `keysNodesEntriesOrRaws` and M is the tree size at insertion time (due to O(M) `add` operation). Space O(N) for storing the nodes.
+     *
+     * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+     * @param [options] - Configuration options for the tree.
+     */
+    constructor(keysNodesEntriesOrRaws = [], options) {
+      super();
+      __publicField(this, "iterationType", "ITERATIVE");
+      __publicField(this, "_isMapMode", true);
+      __publicField(this, "_isDuplicate", false);
+      __publicField(this, "_store", /* @__PURE__ */ new Map());
+      __publicField(this, "_root");
+      __publicField(this, "_size", 0);
+      __publicField(this, "_NIL", new BinaryTreeNode(NaN));
+      __publicField(this, "_toEntryFn");
+      /**
+       * (Protected) Default callback function, returns the node's key.
+       * @remarks Time O(1)
+       *
+       * @param node - The node.
+       * @returns The node's key or undefined.
+       */
+      __publicField(this, "_DEFAULT_NODE_CALLBACK", (node) => node ? node.key : void 0);
+      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.addMany(keysNodesEntriesOrRaws);
+    }
+    /**
+     * Gets whether the tree is in Map mode.
+     * @remarks In Map mode (default), values are stored in an external Map, and nodes only hold keys. If false, values are stored directly on the nodes. Time O(1)
+     *
+     * @returns True if in Map mode, false otherwise.
+     */
+    get isMapMode() {
+      return this._isMapMode;
+    }
+    /**
+     * Gets whether the tree allows duplicate keys.
+     * @remarks Time O(1)
+     *
+     * @returns True if duplicates are allowed, false otherwise.
+     */
+    get isDuplicate() {
+      return this._isDuplicate;
+    }
+    /**
+     * Gets the external value store (used in Map mode).
+     * @remarks Time O(1)
+     *
+     * @returns The map storing key-value pairs.
+     */
+    get store() {
+      return this._store;
+    }
+    /**
+     * Gets the root node of the tree.
+     * @remarks Time O(1)
+     *
+     * @returns The root node.
+     */
+    get root() {
+      return this._root;
+    }
+    /**
+     * Gets the number of nodes in the tree.
+     * @remarks Time O(1)
+     *
+     * @returns The size of the tree.
+     */
+    get size() {
+      return this._size;
+    }
+    /**
+     * Gets the sentinel NIL node (used in self-balancing trees like Red-Black Tree).
+     * @remarks Time O(1)
+     *
+     * @returns The NIL node.
+     */
+    get NIL() {
+      return this._NIL;
+    }
+    /**
+     * Gets the function used to convert raw data objects (R) into [key, value] entries.
+     * @remarks Time O(1)
+     *
+     * @returns The conversion function.
+     */
+    get toEntryFn() {
+      return this._toEntryFn;
+    }
+    /**
+     * (Protected) Creates a new node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param key - The key for the new node.
+     * @param [value] - The value for the new node (used if not in Map mode).
+     * @returns The newly created node.
+     */
+    createNode(key, value) {
+      return new BinaryTreeNode(key, this._isMapMode ? void 0 : value);
+    }
+    /**
+     * Creates a new, empty tree of the same type and configuration.
+     * @remarks Time O(1) (excluding options cloning), Space O(1)
+     *
+     * @param [options] - Optional overrides for the new tree's options.
+     * @returns A new, empty tree instance.
+     */
+    createTree(options) {
+      return this._createInstance(options);
+    }
+    /**
+     * Ensures the input is a node. If it's a key or entry, it searches for the node.
+     * @remarks Time O(1) if a node is passed. O(N) if a key or entry is passed (due to `getNode` performing a full search). Space O(1) if iterative search, O(H) if recursive (where H is height, O(N) worst-case).
+     *
+     * @param keyNodeOrEntry - The item to resolve to a node.
+     * @param [iterationType=this.iterationType] - The traversal method to use if searching.
+     * @returns The resolved node, or null/undefined if not found or input is null/undefined.
+     */
+    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);
+    }
+    /**
+     * Checks if the given item is a `BinaryTreeNode` instance.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param keyNodeOrEntry - The item to check.
+     * @returns True if it's a node, false otherwise.
+     */
+    isNode(keyNodeOrEntry) {
+      return keyNodeOrEntry instanceof BinaryTreeNode;
+    }
+    /**
+     * Checks if the given item is a raw data object (R) that needs conversion via `toEntryFn`.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param keyNodeEntryOrRaw - The item to check.
+     * @returns True if it's a raw object, false otherwise.
+     */
+    isRaw(keyNodeEntryOrRaw) {
+      return this._toEntryFn !== void 0 && typeof keyNodeEntryOrRaw === "object";
+    }
+    /**
+     * Checks if the given item is a "real" node (i.e., not null, undefined, or NIL).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param keyNodeOrEntry - The item to check.
+     * @returns True if it's a real node, false otherwise.
+     */
+    isRealNode(keyNodeOrEntry) {
+      if (keyNodeOrEntry === this._NIL || keyNodeOrEntry === null || keyNodeOrEntry === void 0) return false;
+      return this.isNode(keyNodeOrEntry);
+    }
+    /**
+     * Checks if the given item is either a "real" node or null.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param keyNodeOrEntry - The item to check.
+     * @returns True if it's a real node or null, false otherwise.
+     */
+    isRealNodeOrNull(keyNodeOrEntry) {
+      return keyNodeOrEntry === null || this.isRealNode(keyNodeOrEntry);
+    }
+    /**
+     * Checks if the given item is the sentinel NIL node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param keyNodeOrEntry - The item to check.
+     * @returns True if it's the NIL node, false otherwise.
+     */
+    isNIL(keyNodeOrEntry) {
+      return keyNodeOrEntry === this._NIL;
+    }
+    /**
+     * Checks if the given item is a `Range` object.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param keyNodeEntryOrPredicate - The item to check.
+     * @returns True if it's a Range, false otherwise.
+     */
+    isRange(keyNodeEntryOrPredicate) {
+      return keyNodeEntryOrPredicate instanceof Range;
+    }
+    /**
+     * Checks if a node is a leaf (has no real children).
+     * @remarks Time O(N) if a key/entry is passed (due to `ensureNode`). O(1) if a node is passed. Space O(1) or O(H) (from `ensureNode`).
+     *
+     * @param keyNodeOrEntry - The node to check.
+     * @returns True if the node is a leaf, false otherwise.
+     */
+    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);
+    }
+    /**
+     * Checks if the given item is a [key, value] entry pair.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param keyNodeOrEntry - The item to check.
+     * @returns True if it's an entry, false otherwise.
+     */
+    isEntry(keyNodeOrEntry) {
+      return Array.isArray(keyNodeOrEntry) && keyNodeOrEntry.length === 2;
+    }
+    /**
+     * Checks if the given key is valid (comparable or null).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param key - The key to validate.
+     * @returns True if the key is valid, false otherwise.
+     */
+    isValidKey(key) {
+      if (key === null) return true;
+      return isComparable(key);
+    }
+    /**
+     * Adds a new node to the tree.
+     * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation adds the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
+     *
+     * @param keyNodeOrEntry - The key, node, or entry to add.
+     * @param [value] - The value, if providing just a key.
+     * @returns True if the addition was successful, false otherwise.
+     */
+    add(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 == null ? void 0 : 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 == null ? void 0 : newNode.key, newValue);
+        this._size++;
+        return true;
+      }
+      return false;
+    }
+    /**
+     * Adds multiple items to the tree.
+     * @remarks Time O(N * M), where N is the number of items to add and M is the size of the tree at insertion (due to O(M) `add` operation). Space O(M) (from `add`) + O(N) (for the `inserted` array).
+     *
+     * @param keysNodesEntriesOrRaws - An iterable of items to add.
+     * @param [values] - An optional parallel iterable of values.
+     * @returns An array of booleans indicating the success of each individual `add` operation.
+     */
+    addMany(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.add(keyNodeEntryOrRaw, value));
+      }
+      return inserted;
+    }
+    /**
+     * Merges another tree into this one by adding all its nodes.
+     * @remarks Time O(N * M), same as `addMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `add`).
+     *
+     * @param anotherTree - The tree to merge.
+     */
+    merge(anotherTree) {
+      this.addMany(anotherTree, []);
+    }
+    /**
+     * Clears the tree and refills it with new items.
+     * @remarks Time O(N) (for `clear`) + O(N * M) (for `addMany`) = O(N * M). Space O(M) (from `addMany`).
+     *
+     * @param keysNodesEntriesOrRaws - An iterable of items to add.
+     * @param [values] - An optional parallel iterable of values.
+     */
+    refill(keysNodesEntriesOrRaws, values) {
+      this.clear();
+      this.addMany(keysNodesEntriesOrRaws, values);
+    }
+    /**
+     * Deletes a node from the tree.
+     * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation finds the node, and if it has two children, swaps it with the rightmost node of its left subtree (in-order predecessor) before deleting. Time O(N) in the worst case. O(N) to find the node (`getNode`) and O(H) (which is O(N) worst-case) to find the rightmost node. Space O(1) (if `getNode` is iterative, which it is).
+     *
+     * @param keyNodeOrEntry - The node to delete.
+     * @returns An array containing deletion results (for compatibility with self-balancing trees).
+     */
+    delete(keyNodeOrEntry) {
+      const deletedResult = [];
+      if (!this._root) return deletedResult;
+      const curr = this.getNode(keyNodeOrEntry);
+      if (!curr) return deletedResult;
+      const parent = curr == null ? void 0 : 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;
+    }
+    /**
+     * Searches the tree for nodes matching a predicate.
+     * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). Performs a full DFS (pre-order) scan of the tree. Time O(N), as it may visit every node. Space O(H) for the call stack (recursive) or explicit stack (iterative), where H is the tree height (O(N) worst-case).
+     *
+     * @template C - The type of the callback function.
+     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
+     * @param [onlyOne=false] - If true, stops after finding the first match.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on matching nodes.
+     * @param [startNode=this._root] - The node to start the search from.
+     * @param [iterationType=this.iterationType] - Whether to use 'RECURSIVE' or 'ITERATIVE' search.
+     * @returns An array of results from the callback function for each matching node.
+     */
+    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 = (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(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);
+    }
+    /**
+     * Gets the first node matching a predicate.
+     * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). Time O(N) in the worst case (via `search`). Space O(H) or O(N) (via `search`).
+     *
+     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
+     * @param [startNode=this._root] - The node to start the search from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns The first matching node, or undefined if not found.
+     */
+    getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+      return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType)[0];
+    }
+    /**
+     * Gets the value associated with a key.
+     * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). Time O(1) if in Map mode. O(N) if not in Map mode (uses `getNode`). Space O(1) if in Map mode. O(H) or O(N) otherwise.
+     *
+     * @param keyNodeEntryOrPredicate - The key, node, or entry to get the value for.
+     * @param [startNode=this._root] - The node to start searching from (if not in Map mode).
+     * @param [iterationType=this.iterationType] - The traversal method (if not in Map mode).
+     * @returns The associated value, or undefined.
+     */
+    get(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+      var _a;
+      if (this._isMapMode) {
+        const key = this._extractKey(keyNodeEntryOrPredicate);
+        if (key === null || key === void 0) return;
+        return this._store.get(key);
+      }
+      return (_a = this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)) == null ? void 0 : _a.value;
+    }
+    has(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+      return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType).length > 0;
+    }
+    /**
+     * Clears the tree of all nodes and values.
+     * @remarks Time O(N) if in Map mode (due to `_store.clear()`), O(1) otherwise. Space O(1)
+     */
+    clear() {
+      this._clearNodes();
+      if (this._isMapMode) this._clearValues();
+    }
+    /**
+     * Checks if the tree is empty.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns True if the tree has no nodes, false otherwise.
+     */
+    isEmpty() {
+      return this._size === 0;
+    }
+    /**
+     * Checks if the tree is perfectly balanced.
+     * @remarks A tree is perfectly balanced if the difference between min and max height is at most 1. Time O(N), as it requires two full traversals (`getMinHeight` and `getHeight`). Space O(H) or O(N) (from height calculation).
+     *
+     * @param [startNode=this._root] - The node to start checking from.
+     * @returns True if perfectly balanced, false otherwise.
+     */
+    isPerfectlyBalanced(startNode = this._root) {
+      return this.getMinHeight(startNode) + 1 >= this.getHeight(startNode);
+    }
+    /**
+     * Checks if the tree is a valid Binary Search Tree (BST).
+     * @remarks Time O(N), as it must visit every node. Space O(H) for the call stack (recursive) or explicit stack (iterative), where H is the tree height (O(N) worst-case).
+     *
+     * @param [startNode=this._root] - The node to start checking from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns True if it's a valid BST, false otherwise.
+     */
+    isBST(startNode = this._root, iterationType = this.iterationType) {
+      const startNodeSired = this.ensureNode(startNode);
+      if (!startNodeSired) return true;
+      if (iterationType === "RECURSIVE") {
+        const dfs = (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);
+        };
+        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 = (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;
+        };
+        const isStandardBST = checkBST(false);
+        const isInverseBST = checkBST(true);
+        return isStandardBST || isInverseBST;
+      }
+    }
+    /**
+     * Gets the depth of a node (distance from `startNode`).
+     * @remarks Time O(H), where H is the depth of the `dist` node relative to `startNode`. O(N) worst-case. Space O(1).
+     *
+     * @param dist - The node to find the depth of.
+     * @param [startNode=this._root] - The node to measure depth from (defaults to root).
+     * @returns The depth (0 if `dist` is `startNode`).
+     */
+    getDepth(dist, startNode = this._root) {
+      let distEnsured = this.ensureNode(dist);
+      const beginRootEnsured = this.ensureNode(startNode);
+      let depth = 0;
+      while (distEnsured == null ? void 0 : distEnsured.parent) {
+        if (distEnsured === beginRootEnsured) {
+          return depth;
+        }
+        depth++;
+        distEnsured = distEnsured.parent;
+      }
+      return depth;
+    }
+    /**
+     * Gets the maximum height of the tree (longest path from startNode to a leaf).
+     * @remarks Time O(N), as it must visit every node. Space O(H) for recursive stack (O(N) worst-case) or O(N) for iterative stack (storing node + depth).
+     *
+     * @param [startNode=this._root] - The node to start measuring from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns The height ( -1 for an empty tree, 0 for a single-node tree).
+     */
+    getHeight(startNode = this._root, iterationType = this.iterationType) {
+      startNode = this.ensureNode(startNode);
+      if (!this.isRealNode(startNode)) return -1;
+      if (iterationType === "RECURSIVE") {
+        const _getMaxHeight = (cur) => {
+          if (!this.isRealNode(cur)) return -1;
+          const leftHeight = _getMaxHeight(cur.left);
+          const rightHeight = _getMaxHeight(cur.right);
+          return Math.max(leftHeight, rightHeight) + 1;
+        };
+        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;
+      }
+    }
+    /**
+     * Gets the minimum height of the tree (shortest path from startNode to a leaf).
+     * @remarks Time O(N), as it must visit every node. Space O(H) for recursive stack (O(N) worst-case) or O(N) for iterative (due to `depths` Map).
+     *
+     * @param [startNode=this._root] - The node to start measuring from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns The minimum height (-1 for empty, 0 for single node).
+     */
+    getMinHeight(startNode = this._root, iterationType = this.iterationType) {
+      startNode = this.ensureNode(startNode);
+      if (!startNode) return -1;
+      if (iterationType === "RECURSIVE") {
+        const _getMinHeight = (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;
+        };
+        return _getMinHeight(startNode);
+      } else {
+        const stack = [];
+        let node = startNode, last = null;
+        const depths = /* @__PURE__ */ 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);
+      }
+    }
+    /**
+     * Gets the path from a given node up to the root.
+     * @remarks Time O(H), where H is the depth of the `beginNode`. O(N) worst-case. Space O(H) for the result array.
+     *
+     * @template C - The type of the callback function.
+     * @param beginNode - The node to start the path from.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on each node in the path.
+     * @param [isReverse=false] - If true, returns the path from root-to-node.
+     * @returns An array of callback results.
+     */
+    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;
+    }
+    /**
+     * Finds the leftmost node in a subtree (the node with the smallest key in a BST).
+     * @remarks Time O(H), where H is the height of the left spine. O(N) worst-case. Space O(H) for recursive/trampoline stack.
+     *
+     * @template C - The type of the callback function.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on the leftmost node.
+     * @param [startNode=this._root] - The subtree root to search from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns The callback result for the leftmost node.
+     */
+    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 = (cur) => {
+          const { left } = cur;
+          if (!this.isRealNode(left)) return cur;
+          return dfs(left);
+        };
+        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));
+      }
+    }
+    /**
+     * Finds the rightmost node in a subtree (the node with the largest key in a BST).
+     * @remarks Time O(H), where H is the height of the right spine. O(N) worst-case. Space O(H) for recursive/trampoline stack.
+     *
+     * @template C - The type of the callback function.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on the rightmost node.
+     * @param [startNode=this._root] - The subtree root to search from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns The callback result for the rightmost node.
+     */
+    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 = (cur) => {
+          const { right } = cur;
+          if (!this.isRealNode(right)) return cur;
+          return dfs(right);
+        };
+        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));
+      }
+    }
+    /**
+     * Gets the Morris traversal predecessor (rightmost node in the left subtree, or node itself).
+     * @remarks This is primarily a helper for Morris traversal. Time O(H), where H is the height of the left subtree. O(N) worst-case. Space O(1).
+     *
+     * @param node - The node to find the predecessor for.
+     * @returns The Morris predecessor.
+     */
+    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;
+      }
+    }
+    /**
+     * Gets the in-order successor of a node in a BST.
+     * @remarks Time O(H), where H is the tree height. O(N) worst-case. Space O(H) (due to `getLeftMost` stack).
+     *
+     * @param [x] - The node to find the successor of.
+     * @returns The successor node, or null/undefined if none exists.
+     */
+    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;
+    }
+    /**
+     * Performs a Depth-First Search (DFS) traversal.
+     * @remarks Time O(N), visits every node. Space O(H) for the call/explicit stack. O(N) worst-case.
+     *
+     * @template C - The type of the callback function.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each node.
+     * @param [pattern='IN'] - The traversal order ('IN', 'PRE', 'POST').
+     * @param [onlyOne=false] - If true, stops after the first callback.
+     * @param [startNode=this._root] - The node to start from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @param [includeNull=false] - If true, includes null nodes in the traversal.
+     * @returns An array of callback results.
+     */
+    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);
+    }
+    /**
+     * Performs a Breadth-First Search (BFS) or Level-Order traversal.
+     * @remarks Time O(N), visits every node. Space O(N) in the worst case for the queue (e.g., a full last level).
+     *
+     * @template C - The type of the callback function.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each node.
+     * @param [startNode=this._root] - The node to start from.
+     * @param [iterationType=this.iterationType] - The traversal method ('RECURSIVE' BFS is less common but supported here).
+     * @param [includeNull=false] - If true, includes null nodes in the traversal.
+     * @returns An array of callback results.
+     */
+    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 = (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(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;
+    }
+    /**
+     * Finds all leaf nodes in the tree.
+     * @remarks Time O(N), visits every node. Space O(H) for recursive stack or O(N) for iterative queue.
+     *
+     * @template C - The type of the callback function.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each leaf node.
+     * @param [startNode=this._root] - The node to start from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns An array of callback results.
+     */
+    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 = (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(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;
+    }
+    /**
+     * Returns a 2D array of nodes, grouped by level.
+     * @remarks Time O(N), visits every node. Space O(N) for the result array and the queue/stack.
+     *
+     * @template C - The type of the callback function.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each node.
+     * @param [startNode=this._root] - The node to start from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @param [includeNull=false] - If true, includes null nodes.
+     * @returns A 2D array of callback results.
+     */
+    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 = (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(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;
+    }
+    /**
+     * Performs a Morris (threaded) traversal.
+     * @remarks This traversal uses O(1) extra space (excluding the result array) by temporarily modifying the tree's right child pointers. Time O(N), as each node is visited a constant number of times. Space O(1) (excluding the `ans` array).
+     *
+     * @template C - The type of the callback function.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each node.
+     * @param [pattern='IN'] - The traversal order ('IN', 'PRE', 'POST').
+     * @param [startNode=this._root] - The node to start from.
+     * @returns An array of callback results.
+     */
+    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 = (node) => {
+        let pre = null;
+        let next = null;
+        while (node) {
+          next = node.right;
+          node.right = pre;
+          pre = node;
+          node = next;
+        }
+        return pre;
+      };
+      const _printEdge = (node) => {
+        const tail = _reverseEdge(node);
+        let cur2 = tail;
+        while (cur2) {
+          ans.push(callback(cur2));
+          cur2 = cur2.right;
+        }
+        _reverseEdge(tail);
+      };
+      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;
+    }
+    /**
+     * Clones the tree.
+     * @remarks Time O(N * M), where N is the number of nodes and M is the tree size during insertion (due to `bfs` + `add`, and `add` is O(M)). Space O(N) for the new tree and the BFS queue.
+     *
+     * @returns A new, cloned instance of the tree.
+     */
+    clone() {
+      const out = this._createInstance();
+      this._clone(out);
+      return out;
+    }
+    /**
+     * Creates a new tree containing only the entries that satisfy the predicate.
+     * @remarks Time O(N * M), where N is nodes in this tree, and M is size of the new tree during insertion (O(N) iteration + O(M) `add` for each item). Space O(N) for the new tree.
+     *
+     * @param predicate - A function to test each [key, value] pair.
+     * @param [thisArg] - `this` context for the predicate.
+     * @returns A new, filtered tree.
+     */
+    filter(predicate, thisArg) {
+      const out = this._createInstance();
+      let i = 0;
+      for (const [k, v] of this) if (predicate.call(thisArg, k, v, i++, this)) out.add([k, v]);
+      return out;
+    }
+    /**
+     * Creates a new tree by mapping each [key, value] pair to a new entry.
+     * @remarks Time O(N * M), where N is nodes in this tree, and M is size of the new tree during insertion. Space O(N) for the new tree.
+     *
+     * @template MK - New key type.
+     * @template MV - New value type.
+     * @template MR - New raw type.
+     * @param cb - A function to map each [key, value] pair.
+     * @param [options] - Options for the new tree.
+     * @param [thisArg] - `this` context for the callback.
+     * @returns A new, mapped tree.
+     */
+    map(cb, options, thisArg) {
+      const out = this._createLike([], options);
+      let i = 0;
+      for (const [k, v] of this) out.add(cb.call(thisArg, k, v, i++, this));
+      return out;
+    }
+    /**
+     * Generates a string representation of the tree for visualization.
+     * @remarks Time O(N), visits every node. Space O(N*H) or O(N^2) in the worst case, as the string width can grow significantly.
+     *
+     * @param [startNode=this._root] - The node to start printing from.
+     * @param [options] - Options to control the output (e.g., show nulls).
+     * @returns The string representation of the tree.
+     */
+    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 = (root) => {
+        const [lines] = this._displayAux(root, opts);
+        let paragraph = "";
+        for (const line of lines) {
+          paragraph += line + "\n";
+        }
+        output += paragraph;
+      };
+      display(startNode);
+      return output;
+    }
+    /**
+     * Prints a visual representation of the tree to the console.
+     * @remarks Time O(N) (via `toVisual`). Space O(N*H) or O(N^2) (via `toVisual`).
+     *
+     * @param [options] - Options to control the output.
+     * @param [startNode=this._root] - The node to start printing from.
+     */
+    print(options, startNode = this._root) {
+      console.log(this.toVisual(startNode, options));
+    }
+    /**
+     * (Protected) Core DFS implementation.
+     * @remarks Time O(N), visits every node satisfying predicates. Space O(H) for call/explicit stack. O(N) worst-case.
+     *
+     * @template C - Callback type.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on nodes.
+     * @param [pattern='IN'] - Traversal order.
+     * @param [onlyOne=false] - Stop after first match.
+     * @param [startNode=this._root] - Starting node.
+     * @param [iterationType=this.iterationType] - Traversal method.
+     * @param [includeNull=false] - Include nulls.
+     * @param [shouldVisitLeft] - Predicate to traverse left.
+     * @param [shouldVisitRight] - Predicate to traverse right.
+     * @param [shouldVisitRoot] - Predicate to visit root.
+     * @param [shouldProcessRoot] - Predicate to process root.
+     * @returns Array of callback results.
+     */
+    _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 = (node) => {
+          if (!shouldVisitRoot(node)) return;
+          const visitLeft = () => {
+            if (shouldVisitLeft(node) && (node == null ? void 0 : node.left) !== void 0) dfs(node == null ? void 0 : node.left);
+          };
+          const visitRight = () => {
+            if (shouldVisitRight(node) && (node == null ? void 0 : node.right) !== void 0) dfs(node == null ? void 0 : node.right);
+          };
+          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(startNode);
+      } else {
+        const stack = [{ opt: 0 /* VISIT */, node: startNode }];
+        const pushLeft = (cur) => {
+          var _a;
+          if (shouldVisitLeft(cur.node)) stack.push({ opt: 0 /* VISIT */, node: (_a = cur.node) == null ? void 0 : _a.left });
+        };
+        const pushRight = (cur) => {
+          var _a;
+          if (shouldVisitRight(cur.node)) stack.push({ opt: 0 /* VISIT */, node: (_a = cur.node) == null ? void 0 : _a.right });
+        };
+        const pushRoot = (cur) => {
+          if (shouldVisitRoot(cur.node)) stack.push({ opt: 1 /* PROCESS */, node: cur.node });
+        };
+        while (stack.length > 0) {
+          const cur = stack.pop();
+          if (cur === void 0) continue;
+          if (!shouldVisitRoot(cur.node)) continue;
+          if (cur.opt === 1 /* PROCESS */) {
+            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;
+    }
+    /**
+     * (Protected) Gets the iterator for the tree (default in-order).
+     * @remarks Time O(N) for full iteration. O(H) to get the first element. Space O(H) for the iterative stack. O(H) for recursive stack.
+     *
+     * @param [node=this._root] - The node to start iteration from.
+     * @returns An iterator for [key, value] pairs.
+     */
+    *_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);
+        }
+      }
+    }
+    /**
+     * (Protected) Snapshots the current tree's configuration options.
+     * @remarks Time O(1)
+     *
+     * @template TK, TV, TR - Generic types for the options.
+     * @returns The options object.
+     */
+    _snapshotOptions() {
+      return {
+        iterationType: this.iterationType,
+        toEntryFn: this.toEntryFn,
+        isMapMode: this.isMapMode,
+        isDuplicate: this.isDuplicate
+      };
+    }
+    /**
+     * (Protected) Creates a new, empty instance of the same tree constructor.
+     * @remarks Time O(1)
+     *
+     * @template TK, TV, TR - Generic types for the new instance.
+     * @param [options] - Options for the new tree.
+     * @returns A new, empty tree.
+     */
+    _createInstance(options) {
+      const Ctor = this.constructor;
+      return new Ctor([], { ...this._snapshotOptions(), ...options != null ? options : {} });
+    }
+    /**
+     * (Protected) Creates a new instance of the same tree constructor, potentially with different generic types.
+     * @remarks Time O(N) (or as per constructor) due to processing the iterable.
+     *
+     * @template TK, TV, TR - Generic types for the new instance.
+     * @param [iter=[]] - An iterable to populate the new tree.
+     * @param [options] - Options for the new tree.
+     * @returns A new tree.
+     */
+    _createLike(iter = [], options) {
+      const Ctor = this.constructor;
+      return new Ctor(iter, { ...this._snapshotOptions(), ...options != null ? options : {} });
+    }
+    /**
+     * (Protected) Converts a key, node, or entry into a standardized [node, value] tuple.
+     * @remarks Time O(1)
+     *
+     * @param keyNodeOrEntry - The input item.
+     * @param [value] - An optional value (used if input is just a key).
+     * @returns A tuple of [node, value].
+     */
+    _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 != null ? value : entryValue;
+        return [this.createNode(key, finalValue), finalValue];
+      }
+      return [this.createNode(keyNodeOrEntry, value), value];
+    }
+    /**
+     * (Protected) Helper for cloning. Performs a BFS and adds all nodes to the new tree.
+     * @remarks Time O(N * M) (O(N) BFS + O(M) `add` for each node).
+     *
+     * @param cloned - The new, empty tree instance to populate.
+     */
+    _clone(cloned) {
+      this.bfs(
+        (node) => {
+          if (node === null) cloned.add(null);
+          else {
+            if (this._isMapMode) cloned.add([node.key, this._store.get(node.key)]);
+            else cloned.add([node.key, node.value]);
+          }
+        },
+        this._root,
+        this.iterationType,
+        true
+        // Include nulls
+      );
+      if (this._isMapMode) cloned._store = this._store;
+    }
+    /**
+     * (Protected) Recursive helper for `toVisual`.
+     * @remarks Time O(N), Space O(N*H) or O(N^2)
+     *
+     * @param node - The current node.
+     * @param options - Print options.
+     * @returns Layout information for this subtree.
+     */
+    _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)
+        ];
+      }
+    }
+    /**
+     * (Protected) Swaps the key/value properties of two nodes.
+     * @remarks Time O(1)
+     *
+     * @param srcNode - The source node.
+     * @param destNode - The destination node.
+     * @returns The `destNode` (now holding `srcNode`'s properties).
+     */
+    _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;
+    }
+    /**
+     * (Protected) Replaces a node in the tree with a new node, maintaining children and parent links.
+     * @remarks Time O(1)
+     *
+     * @param oldNode - The node to be replaced.
+     * @param newNode - The node to insert.
+     * @returns The `newNode`.
+     */
+    _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;
+    }
+    /**
+     * (Protected) Sets the root node and clears its parent reference.
+     * @remarks Time O(1)
+     *
+     * @param v - The node to set as root.
+     */
+    _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;
+      };
+    }
+    /**
+     * (Protected) Checks if an item is a predicate function.
+     * @remarks Time O(1)
+     *
+     * @param p - The item to check.
+     * @returns True if it's a function.
+     */
+    _isPredicate(p) {
+      return typeof p === "function";
+    }
+    /**
+     * (Protected) Extracts the key from a key, node, or entry.
+     * @remarks Time O(1)
+     *
+     * @param keyNodeOrEntry - The item.
+     * @returns The extracted key.
+     */
+    _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;
+    }
+    /**
+     * (Protected) Sets a value in the external store (Map mode).
+     * @remarks Time O(1) (average for Map.set).
+     *
+     * @param key - The key.
+     * @param value - The value.
+     * @returns True if successful.
+     */
+    _setValue(key, value) {
+      if (key === null || key === void 0) return false;
+      if (value === void 0) return false;
+      return this._store.set(key, value);
+    }
+    /**
+     * (Protected) Clears all nodes from the tree.
+     * @remarks Time O(1)
+     */
+    _clearNodes() {
+      this._setRoot(void 0);
+      this._size = 0;
+    }
+    /**
+     * (Protected) Clears all values from the external store.
+     * @remarks Time O(N)
+     */
+    _clearValues() {
+      this._store.clear();
+    }
+  };
+
+  // src/data-structures/binary-tree/bst.ts
+  var BSTNode = class extends BinaryTreeNode {
+    /**
+     * Creates an instance of BSTNode.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param key - The key of the node.
+     * @param [value] - The value associated with the key.
+     */
+    constructor(key, value) {
+      super(key, value);
+      __publicField(this, "parent");
+      __publicField(this, "_left");
+      __publicField(this, "_right");
+    }
+    /**
+     * Gets the left child of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The left child.
+     */
+    get left() {
+      return this._left;
+    }
+    /**
+     * Sets the left child of the node and updates its parent reference.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param v - The node to set as the left child.
+     */
+    set left(v) {
+      if (v) v.parent = this;
+      this._left = v;
+    }
+    /**
+     * Gets the right child of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The right child.
+     */
+    get right() {
+      return this._right;
+    }
+    /**
+     * Sets the right child of the node and updates its parent reference.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param v - The node to set as the right child.
+     */
+    set right(v) {
+      if (v) v.parent = this;
+      this._right = v;
+    }
+  };
+  var BST = class extends BinaryTree {
+    /**
+     * Creates an instance of BST.
+     * @remarks Time O(N log N) or O(N^2) depending on `isBalanceAdd` in `addMany` and input order. Space O(N).
+     *
+     * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+     * @param [options] - Configuration options for the BST, including comparator.
+     */
+    constructor(keysNodesEntriesOrRaws = [], options) {
+      super([], options);
+      __publicField(this, "_root");
+      __publicField(this, "_isReverse", false);
+      /**
+       * The default comparator function.
+       * @remarks Time O(1) (or O(C) if `specifyComparable` is used, C is complexity of that function).
+       */
+      __publicField(this, "_comparator", (a, b) => {
+        if (isComparable(a) && isComparable(b)) {
+          if (a > b) return 1;
+          if (a < b) return -1;
+          return 0;
+        }
+        if (this._specifyComparable) {
+          const va = this._specifyComparable(a);
+          const vb = this._specifyComparable(b);
+          if (va > vb) return 1;
+          if (va < vb) return -1;
+          return 0;
+        }
+        if (typeof a === "object" || typeof b === "object") {
+          throw TypeError(
+            `When comparing object types, a custom specifyComparable must be defined in the constructor's options.`
+          );
+        }
+        return 0;
+      });
+      __publicField(this, "_specifyComparable");
+      if (options) {
+        const { specifyComparable, isReverse } = options;
+        if (typeof specifyComparable === "function") this._specifyComparable = specifyComparable;
+        if (isReverse !== void 0) this._isReverse = isReverse;
+      }
+      if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    }
+    /**
+     * Gets the root node of the tree.
+     * @remarks Time O(1)
+     *
+     * @returns The root node.
+     */
+    get root() {
+      return this._root;
+    }
+    /**
+     * Gets whether the tree's comparison logic is reversed.
+     * @remarks Time O(1)
+     *
+     * @returns True if the tree is reversed (e.g., a max-heap logic).
+     */
+    get isReverse() {
+      return this._isReverse;
+    }
+    /**
+     * Gets the comparator function used by the tree.
+     * @remarks Time O(1)
+     *
+     * @returns The comparator function.
+     */
+    get comparator() {
+      return this._comparator;
+    }
+    /**
+     * Gets the function used to extract a comparable value from a complex key.
+     * @remarks Time O(1)
+     *
+     * @returns The key-to-comparable conversion function.
+     */
+    get specifyComparable() {
+      return this._specifyComparable;
+    }
+    /**
+     * (Protected) Creates a new BST node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param key - The key for the new node.
+     * @param [value] - The value for the new node (used if not in Map mode).
+     * @returns The newly created BSTNode.
+     */
+    createNode(key, value) {
+      return new BSTNode(key, this._isMapMode ? void 0 : value);
+    }
+    /**
+     * Ensures the input is a node. If it's a key or entry, it searches for the node.
+     * @remarks Time O(log N) (height of the tree), O(N) worst-case.
+     *
+     * @param keyNodeOrEntry - The item to resolve to a node.
+     * @param [iterationType=this.iterationType] - The traversal method to use if searching.
+     * @returns The resolved node, or undefined if not found.
+     */
+    ensureNode(keyNodeOrEntry, iterationType = this.iterationType) {
+      var _a;
+      return (_a = super.ensureNode(keyNodeOrEntry, iterationType)) != null ? _a : void 0;
+    }
+    /**
+     * Checks if the given item is a `BSTNode` instance.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param keyNodeOrEntry - The item to check.
+     * @returns True if it's a BSTNode, false otherwise.
+     */
+    isNode(keyNodeOrEntry) {
+      return keyNodeOrEntry instanceof BSTNode;
+    }
+    /**
+     * Checks if the given key is valid (comparable).
+     * @remarks Time O(1)
+     *
+     * @param key - The key to validate.
+     * @returns True if the key is valid, false otherwise.
+     */
+    isValidKey(key) {
+      return isComparable(key, this._specifyComparable !== void 0);
+    }
+    /**
+     * Performs a Depth-First Search (DFS) traversal.
+     * @remarks Time O(N), visits every node. Space O(log N) for the call/explicit stack. O(N) worst-case.
+     *
+     * @template C - The type of the callback function.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each node.
+     * @param [pattern='IN'] - The traversal order ('IN', 'PRE', 'POST').
+     * @param [onlyOne=false] - If true, stops after the first callback.
+     * @param [startNode=this._root] - The node to start from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns An array of callback results.
+     */
+    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+      return super.dfs(callback, pattern, onlyOne, startNode, iterationType);
+    }
+    /**
+     * Performs a Breadth-First Search (BFS) or Level-Order traversal.
+     * @remarks Time O(N), visits every node. Space O(N) in the worst case for the queue.
+     *
+     * @template C - The type of the callback function.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each node.
+     * @param [startNode=this._root] - The node to start from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns An array of callback results.
+     */
+    bfs(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+      return super.bfs(callback, startNode, iterationType, false);
+    }
+    /**
+     * Returns a 2D array of nodes, grouped by level.
+     * @remarks Time O(N), visits every node. Space O(N) for the result array and the queue/stack.
+     *
+     * @template C - The type of the callback function.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each node.
+     * @param [startNode=this._root] - The node to start from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns A 2D array of callback results.
+     */
+    listLevels(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+      return super.listLevels(callback, startNode, iterationType, false);
+    }
+    /**
+     * Gets the first node matching a predicate.
+     * @remarks Time O(log N) if searching by key, O(N) if searching by predicate. Space O(log N) or O(N).
+     *
+     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
+     * @param [startNode=this._root] - The node to start the search from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns The first matching node, or undefined if not found.
+     */
+    getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+      var _a;
+      return (_a = this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0]) != null ? _a : void 0;
+    }
+    /**
+     * Searches the tree for nodes matching a predicate, key, or range.
+     * @remarks This is an optimized search for a BST. If searching by key or range, it prunes branches.
+     * Time O(H + M) for key/range search (H=height, M=matches). O(N) for predicate search.
+     * Space O(log N) for the stack.
+     *
+     * @template C - The type of the callback function.
+     * @param keyNodeEntryOrPredicate - The key, node, entry, predicate, or range to search for.
+     * @param [onlyOne=false] - If true, stops after finding the first match.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on matching nodes.
+     * @param [startNode=this._root] - The node to start the search from.
+     * @param [iterationType=this.iterationType] - Whether to use 'RECURSIVE' or 'ITERATIVE' search.
+     * @returns An array of results from the callback function for each matching node.
+     */
+    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 = (node) => {
+          if (!node) return false;
+          return keyNodeEntryOrPredicate.isInRange(node.key, this._comparator);
+        };
+      } else {
+        predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
+      }
+      const shouldVisitLeft = (cur) => {
+        if (!cur) return false;
+        if (!this.isRealNode(cur.left)) return false;
+        if (isRange) {
+          const range = keyNodeEntryOrPredicate;
+          const leftS = this.isReverse ? range.high : range.low;
+          const leftI = this.isReverse ? range.includeHigh : 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;
+      };
+      const shouldVisitRight = (cur) => {
+        if (!cur) return false;
+        if (!this.isRealNode(cur.right)) return false;
+        if (isRange) {
+          const range = keyNodeEntryOrPredicate;
+          const rightS = this.isReverse ? range.low : range.high;
+          const rightI = this.isReverse ? range.includeLow : 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;
+      };
+      return super._dfs(
+        callback,
+        "IN",
+        // In-order is efficient for range/key search
+        onlyOne,
+        startNode,
+        iterationType,
+        false,
+        shouldVisitLeft,
+        shouldVisitRight,
+        () => true,
+        // shouldVisitRoot (always visit)
+        (cur) => !!cur && predicate(cur)
+        // shouldProcessRoot (only process if predicate matches)
+      );
+    }
+    /**
+     * Performs an optimized search for nodes within a given key range.
+     * @remarks Time O(H + M), where H is tree height and M is the number of matches.
+     *
+     * @template C - The type of the callback function.
+     * @param range - A `Range` object or a `[low, high]` tuple.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on matching nodes.
+     * @param [startNode=this._root] - The node to start the search from.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns An array of callback results.
+     */
+    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);
+    }
+    /**
+     * Adds a new node to the BST based on key comparison.
+     * @remarks Time O(log N), where H is tree height. O(N) worst-case (unbalanced tree), O(log N) average. Space O(1).
+     *
+     * @param keyNodeOrEntry - The key, node, or entry to add.
+     * @param [value] - The value, if providing just a key.
+     * @returns True if the addition was successful, false otherwise.
+     */
+    add(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 == null ? void 0 : 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 == null ? void 0 : 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 == null ? void 0 : newNode.key, newValue);
+            this._size++;
+            return true;
+          }
+          if (current.right !== null) current = current.right;
+        }
+      }
+      return false;
+    }
+    /**
+     * Adds multiple items to the tree.
+     * @remarks If `isBalanceAdd` is true, sorts the input and builds a balanced tree. Time O(N log N) (due to sort and balanced add).
+     * If false, adds items one by one. Time O(N * H), which is O(N^2) worst-case.
+     * Space O(N) for sorting and recursion/iteration stack.
+     *
+     * @param keysNodesEntriesOrRaws - An iterable of items to add.
+     * @param [values] - An optional parallel iterable of values.
+     * @param [isBalanceAdd=true] - If true, builds a balanced tree from the items.
+     * @param [iterationType=this.iterationType] - The traversal method for balanced add (recursive or iterative).
+     * @returns An array of booleans indicating the success of each individual `add` operation.
+     */
+    addMany(keysNodesEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
+      const inserted = [];
+      const valuesIterator = values == null ? void 0 : values[Symbol.iterator]();
+      if (!isBalanceAdd) {
+        for (let kve of keysNodesEntriesOrRaws) {
+          const val = valuesIterator == null ? void 0 : valuesIterator.next().value;
+          if (this.isRaw(kve)) kve = this._toEntryFn(kve);
+          inserted.push(this.add(kve, val));
+        }
+        return inserted;
+      }
+      const realBTNExemplars = [];
+      let i = 0;
+      for (const kve of keysNodesEntriesOrRaws) {
+        realBTNExemplars.push({ key: kve, value: valuesIterator == null ? void 0 : 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 = (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.add(entry);
+        } else {
+          inserted[orgIndex] = this.add(key, value);
+        }
+        _dfs(arr.slice(0, mid));
+        _dfs(arr.slice(mid + 1));
+      };
+      const _iterate = () => {
+        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.add(entry);
+          } else {
+            inserted[orgIndex] = this.add(key, value);
+          }
+          stack.push([m + 1, r]);
+          stack.push([l, m - 1]);
+        }
+      };
+      if (iterationType === "RECURSIVE") _dfs(sorted);
+      else _iterate();
+      return inserted;
+    }
+    /**
+     * Traverses the tree and returns nodes that are lesser or greater than a target node.
+     * @remarks Time O(N), as it performs a full traversal. Space O(log N) or O(N).
+     *
+     * @template C - The type of the callback function.
+     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on matching nodes.
+     * @param [lesserOrGreater=-1] - -1 for lesser, 1 for greater, 0 for equal.
+     * @param [targetNode=this._root] - The node to compare against.
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns An array of callback results.
+     */
+    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 = (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(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;
+      }
+    }
+    /**
+     * Rebuilds the tree to be perfectly balanced.
+     * @remarks Time O(N) (O(N) for DFS, O(N) for sorted build). Space O(N) for node array and recursion stack.
+     *
+     * @param [iterationType=this.iterationType] - The traversal method for the initial node export.
+     * @returns True if successful, false if the tree was empty.
+     */
+    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 = (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;
+      };
+      const newRoot = build(0, n - 1, void 0);
+      this._setRoot(newRoot);
+      this._size = n;
+      return true;
+    }
+    /**
+     * Checks if the tree meets the AVL balance condition (height difference <= 1).
+     * @remarks Time O(N), as it must visit every node to compute height. Space O(log N) for recursion or O(N) for iterative map.
+     *
+     * @param [iterationType=this.iterationType] - The traversal method.
+     * @returns True if the tree is AVL balanced, false otherwise.
+     */
+    isAVLBalanced(iterationType = this.iterationType) {
+      if (!this._root) return true;
+      let balanced = true;
+      if (iterationType === "RECURSIVE") {
+        const _height = (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(this._root);
+      } else {
+        const stack = [];
+        let node = this._root, last = void 0;
+        const depths = /* @__PURE__ */ 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;
+    }
+    /**
+     * Creates a new BST by mapping each [key, value] pair to a new entry.
+     * @remarks Time O(N * H), where N is nodes in this tree, and H is height of the new tree during insertion.
+     * Space O(N) for the new tree.
+     *
+     * @template MK - New key type.
+     * @template MV - New value type.
+     * @template MR - New raw type.
+     * @param callback - A function to map each [key, value] pair.
+     * @param [options] - Options for the new BST.
+     * @param [thisArg] - `this` context for the callback.
+     * @returns A new, mapped BST.
+     */
+    map(callback, options, thisArg) {
+      const out = this._createLike([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        out.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return out;
+    }
+    /**
+     * Deletes the first node found that satisfies the predicate.
+     * @remarks Performs an in-order traversal. Time O(N) worst-case (O(log N) to find + O(log N) to delete). Space O(log N) for stack.
+     *
+     * @param predicate - A function to test each [key, value] pair.
+     * @returns True if a node was deleted, false otherwise.
+     */
+    deleteWhere(predicate) {
+      const stack = [];
+      let cur = this._root;
+      let index = 0;
+      while (stack.length > 0 || cur !== void 0) {
+        while (cur !== void 0 && cur !== null) {
+          stack.push(cur);
+          cur = cur.left;
+        }
+        const node = stack.pop();
+        if (!node) break;
+        const key = node.key;
+        const val = node.value;
+        if (predicate(key, val, index++, this)) {
+          return this._deleteByKey(key);
+        }
+        cur = node.right;
+      }
+      return false;
+    }
+    /**
+     * (Protected) Creates a new, empty instance of the same BST constructor.
+     * @remarks Time O(1)
+     *
+     * @template TK, TV, TR - Generic types for the new instance.
+     * @param [options] - Options for the new BST.
+     * @returns A new, empty BST.
+     */
+    _createInstance(options) {
+      const Ctor = this.constructor;
+      return new Ctor([], { ...this._snapshotOptions(), ...options != null ? options : {} });
+    }
+    /**
+     * (Protected) Creates a new instance of the same BST constructor, potentially with different generic types.
+     * @remarks Time O(N log N) or O(N^2) (from constructor) due to processing the iterable.
+     *
+     * @template TK, TV, TR - Generic types for the new instance.
+     * @param [iter=[]] - An iterable to populate the new BST.
+     * @param [options] - Options for the new BST.
+     * @returns A new BST.
+     */
+    _createLike(iter = [], options) {
+      const Ctor = this.constructor;
+      return new Ctor(iter, { ...this._snapshotOptions(), ...options != null ? options : {} });
+    }
+    /**
+     * (Protected) Snapshots the current BST's configuration options.
+     * @remarks Time O(1)
+     *
+     * @template TK, TV, TR - Generic types for the options.
+     * @returns The options object.
+     */
+    _snapshotOptions() {
+      return {
+        ...super._snapshotOptions(),
+        specifyComparable: this.specifyComparable,
+        isReverse: this.isReverse
+      };
+    }
+    /**
+     * (Protected) Converts a key, node, or entry into a standardized [node, value] tuple.
+     * @remarks Time O(1)
+     *
+     * @param keyNodeOrEntry - The input item.
+     * @param [value] - An optional value (used if input is just a key).
+     * @returns A tuple of [node, value].
+     */
+    _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value) {
+      const [node, entryValue] = super._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
+      if (node === null) return [void 0, void 0];
+      return [node, value != null ? value : entryValue];
+    }
+    /**
+     * (Protected) Sets the root node and clears its parent reference.
+     * @remarks Time O(1)
+     *
+     * @param v - The node to set as root.
+     */
+    _setRoot(v) {
+      if (v) v.parent = void 0;
+      this._root = v;
+    }
+    /**
+     * (Protected) Compares two keys using the tree's comparator and reverse setting.
+     * @remarks Time O(1) (or O(C) if `specifyComparable` is used).
+     *
+     * @param a - The first key.
+     * @param b - The second key.
+     * @returns A number (1, -1, or 0) representing the comparison.
+     */
+    _compare(a, b) {
+      return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
+    }
+    /**
+     * (Private) Deletes a node by its key.
+     * @remarks Standard BST deletion algorithm. Time O(log N), O(N) worst-case. Space O(1).
+     *
+     * @param key - The key of the node to delete.
+     * @returns True if the node was found and deleted, false otherwise.
+     */
+    _deleteByKey(key) {
+      var _a;
+      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 = (u, v) => {
+        const p = u == null ? void 0 : u.parent;
+        if (!p) {
+          this._setRoot(v);
+        } else if (p.left === u) {
+          p.left = v;
+        } else {
+          p.right = v;
+        }
+        if (v) v.parent = p;
+      };
+      const minNode = (x) => {
+        if (!x) return void 0;
+        while (x.left !== void 0 && x.left !== null) x = x.left;
+        return x;
+      };
+      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, ((_a = this._size) != null ? _a : 0) - 1);
+      return true;
+    }
+  };
+  return __toCommonJS(src_exports);
+})();
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+//# sourceMappingURL=bst-typed.js.map