binary-tree-typed 2.4.4 → 2.5.0

package/dist/umd/binary-tree-typed.js

@@ -26,6 +26,7 @@ var binaryTreeTyped = (() => {
     BinaryTree: () => BinaryTree,
     BinaryTreeNode: () => BinaryTreeNode,
     DFSOperation: () => DFSOperation,
+    ERR: () => ERR,
     Range: () => Range
   });
 
@@ -490,6 +491,231 @@ var binaryTreeTyped = (() => {
     }
   };
 
+  // src/common/error.ts
+  var ERR = {
+    // Range / index
+    indexOutOfRange: (index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`,
+    invalidIndex: (ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`,
+    // Type / argument
+    invalidArgument: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    comparatorRequired: (ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`,
+    invalidKey: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    notAFunction: (name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`,
+    invalidEntry: (ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`,
+    invalidNaN: (ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`,
+    invalidDate: (ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`,
+    reduceEmpty: (ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`,
+    callbackReturnType: (expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`,
+    // State / operation
+    invalidOperation: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    // Matrix
+    matrixDimensionMismatch: (op) => `Matrix: Dimensions must be compatible for ${op}.`,
+    matrixSingular: () => "Matrix: Singular matrix, inverse does not exist.",
+    matrixNotSquare: () => "Matrix: Must be square for inversion.",
+    matrixNotRectangular: () => "Matrix: Must be rectangular for transposition.",
+    matrixRowMismatch: (expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`
+  };
+
+  // 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;
+    }
+    // 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 {
+    /**
+     * 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 {
     /**
@@ -544,18 +770,52 @@ var binaryTreeTyped = (() => {
       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;
     }
@@ -578,19 +838,69 @@ var binaryTreeTyped = (() => {
       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();
@@ -611,10 +921,35 @@ var binaryTreeTyped = (() => {
       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;
@@ -623,11 +958,24 @@ var binaryTreeTyped = (() => {
       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)) {
@@ -638,11 +986,24 @@ var binaryTreeTyped = (() => {
       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];
@@ -694,19 +1055,48 @@ var binaryTreeTyped = (() => {
       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;
@@ -732,10 +1122,26 @@ var binaryTreeTyped = (() => {
       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);
@@ -743,12 +1149,26 @@ var binaryTreeTyped = (() => {
       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 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);
@@ -760,15 +1180,28 @@ var binaryTreeTyped = (() => {
       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 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) {
       var _a, _b;
       const out = new this.constructor([], {
@@ -857,206 +1290,6 @@ var binaryTreeTyped = (() => {
     }
   };
 
-  // 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[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/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;
-    }
-    // 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 {
     /**
@@ -1192,7 +1425,7 @@ var binaryTreeTyped = (() => {
       return "MAL_NODE";
     }
   };
-  var BinaryTree = class extends IterableEntryBase {
+  var BinaryTree = class _BinaryTree 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) `set` operation). Space O(N) for storing the nodes.
@@ -1227,7 +1460,7 @@ var binaryTreeTyped = (() => {
         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);
     }
@@ -1432,30 +1665,78 @@ var binaryTreeTyped = (() => {
       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]);
@@ -1487,29 +1768,50 @@ var binaryTreeTyped = (() => {
           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;
@@ -1530,11 +1832,26 @@ var binaryTreeTyped = (() => {
       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, []);
     }
@@ -1550,12 +1867,29 @@ var binaryTreeTyped = (() => {
       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;
@@ -1649,14 +1983,27 @@ var binaryTreeTyped = (() => {
       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)) {
@@ -1668,14 +2015,30 @@ var binaryTreeTyped = (() => {
       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) {
       var _a, _b;
       if (this._isMapMode) {
@@ -1696,19 +2059,45 @@ var binaryTreeTyped = (() => {
       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;
     }
@@ -1723,13 +2112,27 @@ var binaryTreeTyped = (() => {
       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;
@@ -1767,13 +2170,29 @@ var binaryTreeTyped = (() => {
       }
     }
     /**
-     * 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);
@@ -1788,13 +2207,28 @@ var binaryTreeTyped = (() => {
       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;
@@ -2056,7 +2490,7 @@ var binaryTreeTyped = (() => {
     }
     /**
      * 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.
@@ -2079,15 +2513,15 @@ var binaryTreeTyped = (() => {
         };
         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);
           }
         }
       }
@@ -2230,24 +2664,53 @@ var binaryTreeTyped = (() => {
       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;
@@ -2255,17 +2718,31 @@ var binaryTreeTyped = (() => {
       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;
@@ -2303,12 +2780,25 @@ var binaryTreeTyped = (() => {
       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));
     }
@@ -2541,44 +3031,99 @@ var binaryTreeTyped = (() => {
      * @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 = (n) => ({
+        node: n,
+        stage: 0,
+        leftLayout: emptyDisplayLayout,
+        rightLayout: emptyDisplayLayout
+      });
+      const stack = [newFrame(node)];
+      let result = emptyDisplayLayout;
+      const setChildResult = (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;
+      };
+      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.