bst-typed 2.4.4 → 2.5.0

package/dist/esm/index.mjs

@@ -473,6 +473,237 @@ var LinearBase = class _LinearBase extends IterableElementBase {
   }
 };
 
+// src/common/error.ts
+var ERR = {
+  // Range / index
+  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
+  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
+  // Type / argument
+  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
+  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
+  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
+  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
+  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
+  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
+  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
+  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
+  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
+  // State / operation
+  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
+  // Matrix
+  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
+  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
+  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
+  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
+  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch")
+};
+
+// 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;
+  }
+  static {
+    __name(this, "Range");
+  }
+  // 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/base/iterable-entry-base.ts
+var IterableEntryBase = class {
+  static {
+    __name(this, "IterableEntryBase");
+  }
+  /**
+   * 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[1], item[0], 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[1], item[0], 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, value, key, 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, value, key, 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;
+  }
+  /**
+   * Converts data structure to `[key, value]` pairs.
+   * @returns Array of entries.
+   * @remarks Time O(n), Space O(n)
+   */
+  toArray() {
+    return [...this];
+  }
+  /**
+   * 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/data-structures/queue/queue.ts
 var Queue = class _Queue extends LinearBase {
   static {
@@ -530,18 +761,52 @@ var Queue = class _Queue extends LinearBase {
     this._autoCompactRatio = value;
   }
   /**
-   * Get the number of elements currently in the queue.
-   * @remarks Time O(1), Space O(1)
-   * @returns Current length.
-   */
+    * Get the number of elements currently in the queue.
+    * @remarks Time O(1), Space O(1)
+    * @returns Current length.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Track queue length
+  *  const q = new Queue<number>();
+  *     console.log(q.length); // 0;
+  *     q.push(1);
+  *     q.push(2);
+  *     console.log(q.length); // 2;
+    */
   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 the first element (front) without removing it.
+    * @remarks Time O(1), Space O(1)
+    * @returns Front element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // View the front element
+  *  const q = new Queue<string>(['first', 'second', 'third']);
+  *     console.log(q.first); // 'first';
+  *     console.log(q.length); // 3;
+    */
   get first() {
     return this.length > 0 ? this.elements[this._offset] : void 0;
   }
@@ -564,19 +829,69 @@ var Queue = class _Queue extends LinearBase {
     return new _Queue(elements);
   }
   /**
-   * Check whether the queue is empty.
-   * @remarks Time O(1), Space O(1)
-   * @returns True if length is 0.
-   */
+    * Check whether the queue is empty.
+    * @remarks Time O(1), Space O(1)
+    * @returns True if length is 0.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Queue for...of iteration and isEmpty check
+  *  const queue = new Queue<string>(['A', 'B', 'C', 'D']);
+  *
+  *     const elements: string[] = [];
+  *     for (const item of queue) {
+  *       elements.push(item);
+  *     }
+  *
+  *     // Verify all elements are iterated in order
+  *     console.log(elements); // ['A', 'B', 'C', 'D'];
+  *
+  *     // Process all elements
+  *     while (queue.length > 0) {
+  *       queue.shift();
+  *     }
+  *
+  *     console.log(queue.length); // 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.
-   */
+    * Enqueue one element at the back.
+    * @remarks Time O(1), Space O(1)
+    * @param element - Element to enqueue.
+    * @returns True on success.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // basic Queue creation and push operation
+  *  // Create a simple Queue with initial values
+  *     const queue = new Queue([1, 2, 3, 4, 5]);
+  *
+  *     // Verify the queue maintains insertion order
+  *     console.log([...queue]); // [1, 2, 3, 4, 5];
+  *
+  *     // Check length
+  *     console.log(queue.length); // 5;
+    */
   push(element) {
     this.elements.push(element);
     if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
@@ -597,10 +912,35 @@ var Queue = class _Queue extends LinearBase {
     return ans;
   }
   /**
-   * Dequeue one element from the front (amortized via offset).
-   * @remarks Time O(1) amortized, Space O(1)
-   * @returns Removed element or undefined.
-   */
+    * Dequeue one element from the front (amortized via offset).
+    * @remarks Time O(1) amortized, Space O(1)
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Queue shift and peek operations
+  *  const queue = new Queue<number>([10, 20, 30, 40]);
+  *
+  *     // Peek at the front element without removing it
+  *     console.log(queue.first); // 10;
+  *
+  *     // Remove and get the first element (FIFO)
+  *     const first = queue.shift();
+  *     console.log(first); // 10;
+  *
+  *     // Verify remaining elements and length decreased
+  *     console.log([...queue]); // [20, 30, 40];
+  *     console.log(queue.length); // 3;
+    */
   shift() {
     if (this.length === 0) return void 0;
     const first = this.first;
@@ -609,11 +949,24 @@ var Queue = class _Queue extends LinearBase {
     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 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.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove specific element
+  *  const q = new Queue<number>([1, 2, 3, 2]);
+  *     q.delete(2);
+  *     console.log(q.length); // 3;
+    */
   delete(element) {
     for (let i = this._offset; i < this.elements.length; i++) {
       if (Object.is(this.elements[i], element)) {
@@ -624,11 +977,24 @@ var Queue = class _Queue extends LinearBase {
     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.
-   */
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Access element by index
+  *  const q = new Queue<string>(['a', 'b', 'c']);
+  *     console.log(q.at(0)); // 'a';
+  *     console.log(q.at(2)); // 'c';
+    */
   at(index) {
     if (index < 0 || index >= this.length) return void 0;
     return this._elements[this._offset + index];
@@ -680,19 +1046,48 @@ var Queue = class _Queue extends LinearBase {
     return this;
   }
   /**
-   * Remove all elements and reset offset.
-   * @remarks Time O(1), Space O(1)
-   * @returns void
-   */
+    * Remove all elements and reset offset.
+    * @remarks Time O(1), Space O(1)
+    * @returns void
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove all elements
+  *  const q = new Queue<number>([1, 2, 3]);
+  *     q.clear();
+  *     console.log(q.length); // 0;
+    */
   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 storage by discarding consumed head elements.
+    * @remarks Time O(N), Space O(N)
+    * @returns True when compaction performed.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Reclaim unused memory
+  *  const q = new Queue<number>([1, 2, 3, 4, 5]);
+  *     q.shift();
+  *     q.shift();
+  *     q.compact();
+  *     console.log(q.length); // 3;
+    */
   compact() {
     this._elements = this.elements.slice(this._offset);
     this._offset = 0;
@@ -718,332 +1113,169 @@ var Queue = class _Queue extends LinearBase {
     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.
-   */
+    * Deep clone this queue and its parameters.
+    * @remarks Time O(N), Space O(N)
+    * @returns A new queue with the same content and options.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Create independent copy
+  *  const q = new Queue<number>([1, 2, 3]);
+  *     const copy = q.clone();
+  *     copy.shift();
+  *     console.log(q.length); // 3;
+  *     console.log(copy.length); // 2;
+    */
   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) {
-    const out = new this.constructor([], {
-      toElementFn: options?.toElementFn,
-      maxLen: options?.maxLen ?? this._maxLen,
-      autoCompactRatio: options?.autoCompactRatio ?? this._autoCompactRatio
-    });
-    let index = 0;
-    for (const v of this)
-      out.push(thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this));
-    return out;
-  }
-  /**
-   * 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) {
-    const Ctor = this.constructor;
-    const out = new Ctor([], {
-      toElementFn: this.toElementFn,
-      maxLen: this._maxLen,
-      autoCompactRatio: this._autoCompactRatio
-    });
-    out._setAutoCompactRatio?.(this._autoCompactRatio);
-    let index = 0;
-    for (const v of this) {
-      const mv = thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this);
-      out.push(mv);
-    }
-    return out;
-  }
-  /**
-   * (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 {
-  static {
-    __name(this, "IterableEntryBase");
-  }
-  /**
-   * 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[1], item[0], 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[1], item[0], 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, value, key, index++, this);
-    }
+    return out;
   }
   /**
-   * 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) {
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Filter elements
+  *  const q = new Queue<number>([1, 2, 3, 4, 5]);
+  *     const evens = q.filter(x => x % 2 === 0);
+  *     console.log(evens.length); // 2;
+    */
+  filter(predicate, thisArg) {
+    const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
+    out._setAutoCompactRatio(this._autoCompactRatio);
     let index = 0;
-    for (const item of this) {
-      const [key, value] = item;
-      if (callbackfn.call(thisArg, value, key, index++, this)) return item;
+    for (const v of this) {
+      if (predicate.call(thisArg, v, index, this)) out.push(v);
+      index++;
     }
-    return;
+    return out;
   }
   /**
-   * 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;
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Transform elements
+  *  const q = new Queue<number>([1, 2, 3]);
+  *     const doubled = q.map(x => x * 2);
+  *     console.log(doubled.toArray()); // [2, 4, 6];
+    */
+  map(callback, options, thisArg) {
+    const out = new this.constructor([], {
+      toElementFn: options?.toElementFn,
+      maxLen: options?.maxLen ?? this._maxLen,
+      autoCompactRatio: options?.autoCompactRatio ?? this._autoCompactRatio
+    });
+    let index = 0;
+    for (const v of this)
+      out.push(thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this));
+    return out;
   }
   /**
-   * 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)
+   * 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).
    */
-  hasValue(value) {
-    for (const [, elementValue] of this) {
-      if (elementValue === value) return true;
+  mapSame(callback, thisArg) {
+    const Ctor = this.constructor;
+    const out = new Ctor([], {
+      toElementFn: this.toElementFn,
+      maxLen: this._maxLen,
+      autoCompactRatio: this._autoCompactRatio
+    });
+    out._setAutoCompactRatio?.(this._autoCompactRatio);
+    let index = 0;
+    for (const v of this) {
+      const mv = thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this);
+      out.push(mv);
     }
-    return false;
+    return out;
   }
   /**
-   * Get the value under a key.
-   * @param key - Key to look up.
-   * @returns Value or `undefined`.
-   * @remarks Time O(n) generic, Space O(1)
+   * (Protected) Set the internal auto-compaction ratio.
+   * @remarks Time O(1), Space O(1)
+   * @param value - New ratio to assign.
+   * @returns void
    */
-  get(key) {
-    for (const item of this) {
-      const [itemKey, value] = item;
-      if (itemKey === key) return value;
-    }
-    return;
+  _setAutoCompactRatio(value) {
+    this._autoCompactRatio = value;
   }
   /**
-   * 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)
+   * (Protected) Iterate elements from front to back.
+   * @remarks Time O(N), Space O(1)
+   * @returns Iterator of E.
    */
-  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;
+  *_getIterator() {
+    for (let i = this._offset; i < this.elements.length; i++) yield this.elements[i];
   }
   /**
-   * Converts data structure to `[key, value]` pairs.
-   * @returns Array of entries.
-   * @remarks Time O(n), Space O(n)
+   * (Protected) Iterate elements from back to front.
+   * @remarks Time O(N), Space O(1)
+   * @returns Iterator of E.
    */
-  toArray() {
-    return [...this];
+  *_getReverseIterator() {
+    for (let i = this.length - 1; i >= 0; i--) {
+      const cur = this.at(i);
+      if (cur !== void 0) yield cur;
+    }
   }
   /**
-   * 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)
+   * (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.
    */
-  toVisual() {
-    return [...this];
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    return new Ctor([], options);
   }
   /**
-   * Print a human-friendly representation to the console.
-   * @remarks Time O(n), Space O(n)
+   * (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.
    */
-  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;
-  }
-  static {
-    __name(this, "Range");
-  }
-  // 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;
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
   }
 };
 
@@ -1185,7 +1417,7 @@ var BinaryTreeNode = class {
     return "MAL_NODE";
   }
 };
-var BinaryTree = class extends IterableEntryBase {
+var BinaryTree = class _BinaryTree extends IterableEntryBase {
   static {
     __name(this, "BinaryTree");
   }
@@ -1205,7 +1437,7 @@ var BinaryTree = class extends IterableEntryBase {
       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");
+      else if (toEntryFn) throw new TypeError(ERR.notAFunction("toEntryFn", "BinaryTree"));
     }
     if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
@@ -1420,30 +1652,78 @@ var BinaryTree = class extends IterableEntryBase {
     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.
-   * @returns True if the addition was successful, false otherwise.
-   */
+    * 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.
+    * @returns True if the addition was successful, false otherwise.
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Add a single node
+  *  const tree = new BinaryTree<number>();
+  *     tree.add(1);
+  *     tree.add(2);
+  *     tree.add(3);
+  *     console.log(tree.size); // 3;
+  *     console.log(tree.has(1)); // true;
+    */
   add(keyNodeOrEntry) {
     return this.set(keyNodeOrEntry);
   }
   /**
-   * Adds or updates 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 sets 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 set or update.
-   * @param [value] - The value, if providing just a key.
-   * @returns True if the addition was successful, false otherwise.
-   */
+    * Adds or updates 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 sets 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 set or update.
+    * @param [value] - The value, if providing just a key.
+    * @returns True if the addition was successful, false otherwise.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // basic BinaryTree creation and insertion
+  *  // Create a BinaryTree with entries
+  *     const entries: [number, string][] = [
+  *       [6, 'six'],
+  *       [1, 'one'],
+  *       [2, 'two'],
+  *       [7, 'seven'],
+  *       [5, 'five'],
+  *       [3, 'three'],
+  *       [4, 'four'],
+  *       [9, 'nine'],
+  *       [8, 'eight']
+  *     ];
+  *
+  *     const tree = new BinaryTree(entries);
+  *
+  *     // Verify size
+  *     console.log(tree.size); // 9;
+  *
+  *     // Add new element
+  *     tree.set(10, 'ten');
+  *     console.log(tree.size); // 10;
+    */
   set(keyNodeOrEntry, value) {
     const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === void 0) return false;
     if (!this._root) {
       this._setRoot(newNode);
       if (this._isMapMode && newNode !== null && newNode !== void 0) this._store.set(newNode.key, newNode);
-      this._size = 1;
+      if (newNode !== null) this._size = 1;
       return true;
     }
     const queue = new Queue([this._root]);
@@ -1475,29 +1755,50 @@ var BinaryTree = class extends IterableEntryBase {
         potentialParent.right = newNode;
       }
       if (this._isMapMode && newNode !== null && newNode !== void 0) this._store.set(newNode.key, newNode);
-      this._size++;
+      if (newNode !== null) 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 set and M is the size of the tree at insertion (due to O(M) `set` operation). Space O(M) (from `set`) + O(N) (for the `inserted` array).
-   *
-   * @param keysNodesEntriesOrRaws - An iterable of items to set.
-   * @returns An array of booleans indicating the success of each individual `set` operation.
-   */
+    * Adds multiple items to the tree.
+    * @remarks Time O(N * M), where N is the number of items to set and M is the size of the tree at insertion (due to O(M) `set` operation). Space O(M) (from `set`) + O(N) (for the `inserted` array).
+    *
+    * @param keysNodesEntriesOrRaws - An iterable of items to set.
+    * @returns An array of booleans indicating the success of each individual `set` operation.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Bulk add
+  *  const tree = new BinaryTree<number>();
+  *     tree.addMany([1, 2, 3, 4, 5]);
+  *     console.log(tree.size); // 5;
+    */
   addMany(keysNodesEntriesOrRaws) {
     return this.setMany(keysNodesEntriesOrRaws);
   }
   /**
-   * Adds or updates multiple items to the tree.
-   * @remarks Time O(N * M), where N is the number of items to set and M is the size of the tree at insertion (due to O(M) `set` operation). Space O(M) (from `set`) + O(N) (for the `inserted` array).
-   *
-   * @param keysNodesEntriesOrRaws - An iterable of items to set or update.
-   * @param [values] - An optional parallel iterable of values.
-   * @returns An array of booleans indicating the success of each individual `set` operation.
-   */
+    * Adds or updates multiple items to the tree.
+    * @remarks Time O(N * M), where N is the number of items to set and M is the size of the tree at insertion (due to O(M) `set` operation). Space O(M) (from `set`) + O(N) (for the `inserted` array).
+    *
+    * @param keysNodesEntriesOrRaws - An iterable of items to set or update.
+    * @param [values] - An optional parallel iterable of values.
+    * @returns An array of booleans indicating the success of each individual `set` operation.
+    
+    
+     * @example
+  * // Set multiple entries
+  *  const tree = new BinaryTree<number, string>();
+  *     tree.setMany([[1, 'a'], [2, 'b'], [3, 'c']]);
+  *     console.log(tree.size); // 3;
+    */
   setMany(keysNodesEntriesOrRaws, values) {
     const inserted = [];
     let valuesIterator;
@@ -1518,11 +1819,26 @@ var BinaryTree = class extends IterableEntryBase {
     return inserted;
   }
   /**
-   * Merges another tree into this one by seting all its nodes.
-   * @remarks Time O(N * M), same as `setMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `set`).
-   *
-   * @param anotherTree - The tree to merge.
-   */
+    * Merges another tree into this one by seting all its nodes.
+    * @remarks Time O(N * M), same as `setMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `set`).
+    *
+    * @param anotherTree - The tree to merge.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Combine trees
+  *  const t1 = new BinaryTree<number>([1, 2]);
+  *     const t2 = new BinaryTree<number>([3, 4]);
+  *     t1.merge(t2);
+  *     console.log(t1.size); // 4;
+    */
   merge(anotherTree) {
     this.setMany(anotherTree, []);
   }
@@ -1538,12 +1854,29 @@ var BinaryTree = class extends IterableEntryBase {
     this.setMany(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 keyNodeEntryRawOrPredicate - The node to delete.
-   * @returns An array containing deletion results (for compatibility with self-balancing trees).
-   */
+    * 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 keyNodeEntryRawOrPredicate - The node to delete.
+    * @returns An array containing deletion results (for compatibility with self-balancing trees).
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove a node
+  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+  *     tree.delete(3);
+  *     console.log(tree.has(3)); // false;
+  *     console.log(tree.size); // 4;
+    */
   delete(keyNodeEntryRawOrPredicate) {
     const deletedResult = [];
     if (!this._root) return deletedResult;
@@ -1637,14 +1970,27 @@ var BinaryTree = class extends IterableEntryBase {
     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.
-   */
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Get node by key
+  *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'child']]);
+  *     console.log(tree.getNode(2)?.value); // 'child';
+    */
   getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
     if (this._isMapMode && keyNodeEntryOrPredicate !== null && keyNodeEntryOrPredicate !== void 0) {
       if (!this._isPredicate(keyNodeEntryOrPredicate)) {
@@ -1656,14 +2002,30 @@ var BinaryTree = class extends IterableEntryBase {
     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.
-   */
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Retrieve value by key
+  *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'left'], [3, 'right']]);
+  *     console.log(tree.get(2)); // 'left';
+  *     console.log(tree.get(99)); // undefined;
+    */
   get(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
     if (this._isMapMode) {
       const key = this._extractKey(keyNodeEntryOrPredicate);
@@ -1683,19 +2045,45 @@ var BinaryTree = class extends IterableEntryBase {
     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)
-   */
+    * 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)
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove all nodes
+  *  const tree = new BinaryTree<number>([1, 2, 3]);
+  *     tree.clear();
+  *     console.log(tree.isEmpty()); // true;
+    */
   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.
-   */
+    * Checks if the tree is empty.
+    * @remarks Time O(1), Space O(1)
+    *
+    * @returns True if the tree has no nodes, false otherwise.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check empty
+  *  console.log(new BinaryTree().isEmpty()); // true;
+    */
   isEmpty() {
     return this._size === 0;
   }
@@ -1710,13 +2098,27 @@ var BinaryTree = class extends IterableEntryBase {
     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.
-   */
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check BST property
+  *  const tree = new BinaryTree<number>([1, 2, 3]);
+  *     // BinaryTree doesn't guarantee BST order
+  *     console.log(typeof tree.isBST()); // 'boolean';
+    */
   isBST(startNode = this._root, iterationType = this.iterationType) {
     const startNodeSired = this.ensureNode(startNode);
     if (!startNodeSired) return true;
@@ -1754,13 +2156,29 @@ var BinaryTree = class extends IterableEntryBase {
     }
   }
   /**
-   * 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`).
-   */
+    * 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`).
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Get depth of a node
+  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+  *     const node = tree.getNode(4);
+  *     console.log(tree.getDepth(node!)); // 2;
+    */
   getDepth(dist, startNode = this._root) {
     let distEnsured = this.ensureNode(dist);
     const beginRootEnsured = this.ensureNode(startNode);
@@ -1775,13 +2193,28 @@ var BinaryTree = class extends IterableEntryBase {
     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).
-   */
+    * 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).
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Get tree height
+  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+  *     console.log(tree.getHeight()); // 2;
+    */
   getHeight(startNode = this._root, iterationType = this.iterationType) {
     startNode = this.ensureNode(startNode);
     if (!this.isRealNode(startNode)) return -1;
@@ -2043,7 +2476,7 @@ var BinaryTree = class extends IterableEntryBase {
   }
   /**
    * 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.
+   * @remarks Time O(N), visits every node. Space O(H) for recursive or iterative stack.
    *
    * @template C - The type of the callback function.
    * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each leaf node.
@@ -2066,15 +2499,15 @@ var BinaryTree = class extends IterableEntryBase {
       }, "dfs");
       dfs(startNode);
     } else {
-      const queue = new Queue([startNode]);
-      while (queue.length > 0) {
-        const cur = queue.shift();
+      const stack = [startNode];
+      while (stack.length > 0) {
+        const cur = stack.pop();
         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);
+          if (this.isRealNode(cur.right)) stack.push(cur.right);
+          if (this.isRealNode(cur.left)) stack.push(cur.left);
         }
       }
     }
@@ -2217,24 +2650,53 @@ var BinaryTree = class extends IterableEntryBase {
     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` + `set`, and `set` is O(M)). Space O(N) for the new tree and the BFS queue.
-   *
-   * @returns A new, cloned instance of the tree.
-   */
+    * 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` + `set`, and `set` is O(M)). Space O(N) for the new tree and the BFS queue.
+    *
+    * @returns A new, cloned instance of the tree.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Deep copy
+  *  const tree = new BinaryTree<number>([1, 2, 3]);
+  *     const copy = tree.clone();
+  *     copy.delete(1);
+  *     console.log(tree.has(1)); // true;
+    */
   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) `set` 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.
-   */
+    * 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) `set` 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.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Filter nodes by condition
+  *  const tree = new BinaryTree<number>([1, 2, 3, 4]);
+  *     const result = tree.filter((_, key) => key > 2);
+  *     console.log(result.size); // 2;
+    */
   filter(predicate, thisArg) {
     const out = this._createInstance();
     let i = 0;
@@ -2242,17 +2704,31 @@ var BinaryTree = class extends IterableEntryBase {
     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.
-   */
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Transform to new tree
+  *  const tree = new BinaryTree<number, number>([[1, 10], [2, 20]]);
+  *     const mapped = tree.map((v, key) => [key, (v ?? 0) + 1] as [number, number]);
+  *     console.log([...mapped.values()]); // contains 11;
+    */
   map(cb, options, thisArg) {
     const out = this._createLike([], options);
     let i = 0;
@@ -2290,12 +2766,25 @@ var BinaryTree = class extends IterableEntryBase {
     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.
-   */
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Display tree
+  *  const tree = new BinaryTree<number>([1, 2, 3]);
+  *     expect(() => tree.print()).not.toThrow();
+    */
   print(options, startNode = this._root) {
     console.log(this.toVisual(startNode, options));
   }
@@ -2534,44 +3023,99 @@ var BinaryTree = class extends IterableEntryBase {
    * @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);
+    const newFrame = /* @__PURE__ */ __name((n) => ({
+      node: n,
+      stage: 0,
+      leftLayout: emptyDisplayLayout,
+      rightLayout: emptyDisplayLayout
+    }), "newFrame");
+    const stack = [newFrame(node)];
+    let result = emptyDisplayLayout;
+    const setChildResult = /* @__PURE__ */ __name((layout) => {
+      if (stack.length === 0) {
+        result = layout;
+        return;
+      }
+      const parent = stack[stack.length - 1];
+      if (parent.stage === 1) parent.leftLayout = layout;
+      else parent.rightLayout = layout;
+    }, "setChildResult");
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const cur = frame.node;
+      if (frame.stage === 0) {
+        if (this._isDisplayLeaf(cur, options)) {
+          stack.pop();
+          const layout = this._resolveDisplayLeaf(cur, options, emptyDisplayLayout);
+          setChildResult(layout);
+          continue;
+        }
+        frame.stage = 1;
+        stack.push(newFrame(cur.left));
+      } else if (frame.stage === 1) {
+        frame.stage = 2;
+        stack.push(newFrame(cur.right));
+      } else {
+        stack.pop();
+        const line = this.isNIL(cur) ? "S" : String(cur.key);
+        const layout = _BinaryTree._buildNodeDisplay(line, line.length, frame.leftLayout, frame.rightLayout);
+        setChildResult(layout);
       }
-      return [
-        mergedLines,
-        leftWidth + width + rightWidth,
-        Math.max(leftHeight, rightHeight) + 2,
-        leftWidth + Math.floor(width / 2)
-      ];
     }
+    return result;
+  }
+  static _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)
+    ];
+  }
+  /**
+   * Check if a node is a display leaf (empty, null, undefined, NIL, or real leaf).
+   */
+  _isDisplayLeaf(node, options) {
+    const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
+    if (node === null && !isShowNull) return true;
+    if (node === void 0 && !isShowUndefined) return true;
+    if (this.isNIL(node) && !isShowRedBlackNIL) return true;
+    if (node === null || node === void 0) return true;
+    const hasDisplayableLeft = this._hasDisplayableChild(node.left, options);
+    const hasDisplayableRight = this._hasDisplayableChild(node.right, options);
+    return !hasDisplayableLeft && !hasDisplayableRight;
+  }
+  _hasDisplayableChild(child, options) {
+    if (child === null) return !!options.isShowNull;
+    if (child === void 0) return !!options.isShowUndefined;
+    if (this.isNIL(child)) return !!options.isShowRedBlackNIL;
+    return true;
+  }
+  /**
+   * Resolve a display leaf node to its layout.
+   */
+  _resolveDisplayLeaf(node, options, emptyDisplayLayout) {
+    const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
+    if (node === null && !isShowNull) return emptyDisplayLayout;
+    if (node === void 0 && !isShowUndefined) return emptyDisplayLayout;
+    if (this.isNIL(node) && !isShowRedBlackNIL) return emptyDisplayLayout;
+    if (node !== null && node !== void 0) {
+      const line2 = this.isNIL(node) ? "S" : String(node.key);
+      return _BinaryTree._buildNodeDisplay(line2, line2.length, emptyDisplayLayout, emptyDisplayLayout);
+    }
+    const line = node === void 0 ? "U" : "N";
+    return _BinaryTree._buildNodeDisplay(line, line.length, [[""], 1, 0, 0], [[""], 1, 0, 0]);
   }
   /**
    * (Protected) Swaps the key/value properties of two nodes.
@@ -2774,6 +3318,7 @@ var BSTNode = class {
    *
    * @returns The height.
    */
+  /* istanbul ignore next -- covered by AVLTree/RedBlackTree tests (subclass uses height) */
   get height() {
     return this._height;
   }
@@ -2783,6 +3328,7 @@ var BSTNode = class {
    *
    * @param value - The new height.
    */
+  /* istanbul ignore next -- covered by AVLTree/RedBlackTree tests (subclass uses height) */
   set height(value) {
     this._height = value;
   }
@@ -2793,6 +3339,7 @@ var BSTNode = class {
    *
    * @returns The node's color.
    */
+  /* istanbul ignore next -- covered by RedBlackTree tests (subclass uses color) */
   get color() {
     return this._color;
   }
@@ -2802,6 +3349,7 @@ var BSTNode = class {
    *
    * @param value - The new color.
    */
+  /* istanbul ignore next -- covered by RedBlackTree tests (subclass uses color) */
   set color(value) {
     this._color = value;
   }
@@ -2812,6 +3360,7 @@ var BSTNode = class {
    *
    * @returns The subtree node count.
    */
+  /* istanbul ignore next -- internal field used by subclasses */
   get count() {
     return this._count;
   }
@@ -2821,6 +3370,7 @@ var BSTNode = class {
    *
    * @param value - The new count.
    */
+  /* istanbul ignore next -- internal field used by subclasses */
   set count(value) {
     this._count = value;
   }
@@ -2975,14 +3525,39 @@ var BST = class extends BinaryTree {
     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.
-   */
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Get node object by key
+  *  const bst = new BST<number, string>([[5, 'root'], [3, 'left'], [7, 'right']]);
+  *     const node = bst.getNode(3);
+  *     console.log(node?.key); // 3;
+  *     console.log(node?.value); // 'left';
+    */
   getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
     if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) return void 0;
     if (this._isPredicate(keyNodeEntryOrPredicate)) {
@@ -3131,13 +3706,44 @@ var BST = class extends BinaryTree {
     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 set.
-   * @param [value] - The value, if providing just a key.
-   * @returns True if the addition was successful, false otherwise.
-   */
+    * 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 set.
+    * @param [value] - The value, if providing just a key.
+    * @returns True if the addition was successful, false otherwise.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Set a key-value pair
+  *  const bst = new BST<number, string>();
+  *     bst.set(1, 'one');
+  *     bst.set(2, 'two');
+  *     console.log(bst.get(1)); // 'one';
+    */
   set(keyNodeOrEntry, value) {
     const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === void 0) return false;
@@ -3174,17 +3780,34 @@ var BST = class extends BinaryTree {
     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 set).
-   * 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 set.
-   * @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 set (recursive or iterative).
-   * @returns An array of booleans indicating the success of each individual `set` operation.
-   */
+    * 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 set).
+    * 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 set.
+    * @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 set (recursive or iterative).
+    * @returns An array of booleans indicating the success of each individual `set` operation.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Set multiple key-value pairs
+  *  const bst = new BST<number, string>();
+  *     bst.setMany([[1, 'a'], [2, 'b'], [3, 'c']]);
+  *     console.log(bst.size); // 3;
+  *     console.log(bst.get(2)); // 'b';
+    */
   setMany(keysNodesEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
     const inserted = [];
     const valuesIterator = values?.[Symbol.iterator]();
@@ -3427,12 +4050,29 @@ var BST = class extends BinaryTree {
     }
   }
   /**
-   * 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.
-   */
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Rebalance the tree
+  *  const bst = new BST<number>();
+  *     // Insert in sorted order (worst case for BST)
+  *     for (let i = 1; i <= 7; i++) bst.add(i);
+  *     console.log(bst.isAVLBalanced()); // false;
+  *     bst.perfectlyBalance();
+  *     console.log(bst.isAVLBalanced()); // true;
+    */
   perfectlyBalance(iterationType = this.iterationType) {
     const nodes = this.dfs((node) => node, "IN", false, this._root, iterationType);
     const n = nodes.length;
@@ -3455,12 +4095,25 @@ var BST = class extends BinaryTree {
     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.
-   */
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check if tree is height-balanced
+  *  const bst = new BST<number>([3, 1, 5, 2, 4]);
+  *     console.log(bst.isAVLBalanced()); // true;
+    */
   isAVLBalanced(iterationType = this.iterationType) {
     if (!this._root) return true;
     let balanced = true;
@@ -3500,18 +4153,42 @@ var BST = class extends BinaryTree {
     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.
-   */
+    * 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.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Transform to new tree
+  *  const bst = new BST<number, number>([[1, 10], [2, 20], [3, 30]]);
+  *     const doubled = bst.map((value, key) => [key, (value ?? 0) * 2] as [number, number]);
+  *     console.log([...doubled.values()]); // [20, 40, 60];
+    */
   map(callback, options, thisArg) {
     const out = this._createLike([], options);
     let index = 0;
@@ -3577,9 +4254,15 @@ var BST = class extends BinaryTree {
         if (a < b) return -1;
         return 0;
       }
+      if (a instanceof Date && b instanceof Date) {
+        const ta = a.getTime();
+        const tb = b.getTime();
+        if (Number.isNaN(ta) || Number.isNaN(tb)) throw new TypeError(ERR.invalidDate("BST"));
+        return ta > tb ? 1 : ta < tb ? -1 : 0;
+      }
       if (typeof a === "object" || typeof b === "object") {
-        throw TypeError(
-          `When comparing object type keys, a custom comparator must be provided in the constructor's options!`
+        throw new TypeError(
+          ERR.comparatorRequired("BST")
         );
       }
       return 0;
@@ -3994,6 +4677,6 @@ var BST = class extends BinaryTree {
  * @license MIT License
  */
 
-export { BST, BSTNode, BinaryTree, BinaryTreeNode, DFSOperation, Range };
+export { BST, BSTNode, BinaryTree, BinaryTreeNode, DFSOperation, ERR, Range };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map