binary-tree-typed 2.4.4 → 2.4.5

package/dist/types/common/error.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Centralized error message templates.
+ * Keep using native Error/TypeError/RangeError — this only standardizes messages.
+ */
+export declare const ERR: {
+    readonly indexOutOfRange: (index: number, min: number, max: number, ctx?: string) => string;
+    readonly invalidIndex: (ctx?: string) => string;
+    readonly invalidArgument: (reason: string, ctx?: string) => string;
+    readonly comparatorRequired: (ctx?: string) => string;
+    readonly invalidKey: (reason: string, ctx?: string) => string;
+    readonly notAFunction: (name: string, ctx?: string) => string;
+    readonly invalidEntry: (ctx?: string) => string;
+    readonly invalidNaN: (ctx?: string) => string;
+    readonly invalidDate: (ctx?: string) => string;
+    readonly reduceEmpty: (ctx?: string) => string;
+    readonly callbackReturnType: (expected: string, got: string, ctx?: string) => string;
+    readonly invalidOperation: (reason: string, ctx?: string) => string;
+    readonly matrixDimensionMismatch: (op: string) => string;
+    readonly matrixSingular: () => string;
+    readonly matrixNotSquare: () => string;
+    readonly matrixNotRectangular: () => string;
+    readonly matrixRowMismatch: (expected: number, got: number) => string;
+};

package/dist/types/common/index.d.ts

@@ -1,3 +1,4 @@
+export { ERR } from './error';
 export declare enum DFSOperation {
     VISIT = 0,
     PROCESS = 1

package/dist/types/data-structures/binary-tree/binary-tree.d.ts

@@ -735,6 +735,16 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @returns Layout information for this subtree.
      */
     protected _displayAux(node: BinaryTreeNode<K, V> | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
+    protected static _buildNodeDisplay(line: string, width: number, left: NodeDisplayLayout, right: NodeDisplayLayout): NodeDisplayLayout;
+    /**
+     * Check if a node is a display leaf (empty, null, undefined, NIL, or real leaf).
+     */
+    protected _isDisplayLeaf(node: BinaryTreeNode<K, V> | null | undefined, options: BinaryTreePrintOptions): boolean;
+    protected _hasDisplayableChild(child: BinaryTreeNode<K, V> | null | undefined, options: BinaryTreePrintOptions): boolean;
+    /**
+     * Resolve a display leaf node to its layout.
+     */
+    protected _resolveDisplayLeaf(node: BinaryTreeNode<K, V> | null | undefined, options: BinaryTreePrintOptions, emptyDisplayLayout: NodeDisplayLayout): NodeDisplayLayout;
     /**
      * (Protected) Swaps the key/value properties of two nodes.
      * @remarks Time O(1)

package/dist/types/data-structures/binary-tree/red-black-tree.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BTNRep, CRUD, EntryCallback, FamilyPosition, NodePredicate, RBTNColor, RedBlackTreeOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BTNRep, CRUD, EntryCallback, FamilyPosition, NodePredicate, RBTNColor, IterationType, RedBlackTreeOptions } from '../../types';
 import { BST } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any> {
@@ -375,6 +375,12 @@ export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R
      * @param [thisArg] - See parameter type for details.
      * @returns A new RedBlackTree with mapped entries.
      */
+    /**
+     * Red-Black trees are self-balancing — `perfectlyBalance` rebuilds via
+     * sorted bulk insert, which naturally produces a balanced RBT.
+     * @remarks Time O(N), Space O(N)
+     */
+    perfectlyBalance(iterationType?: IterationType): boolean;
     map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<RedBlackTreeOptions<MK, MV, MR>>, thisArg?: unknown): RedBlackTree<MK, MV, MR>;
     /**
      * (Internal) Create an empty instance of the same concrete tree type.

package/dist/types/data-structures/graph/abstract-graph.d.ts

@@ -337,4 +337,48 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @remarks Time O(1), Space O(1)
      */
     protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey;
+    /**
+     * The edge connector string used in visual output.
+     * Override in subclasses (e.g., '--' for undirected, '->' for directed).
+     */
+    protected get _edgeConnector(): string;
+    /**
+     * Generate a text-based visual representation of the graph.
+     *
+     * **Adjacency list format:**
+     * ```
+     * Graph (5 vertices, 6 edges):
+     * A -> B (1), C (2)
+     * B -> D (3)
+     * C -> (no outgoing edges)
+     * D -> A (1)
+     * E (isolated)
+     * ```
+     *
+     * @param options - Optional display settings.
+     * @param options.showWeight - Whether to show edge weights (default: true).
+     * @returns The visual string.
+     */
+    toVisual(options?: {
+        showWeight?: boolean;
+    }): string;
+    /**
+     * Generate DOT language representation for Graphviz.
+     *
+     * @param options - Optional display settings.
+     * @param options.name - Graph name (default: 'G').
+     * @param options.showWeight - Whether to label edges with weight (default: true).
+     * @returns DOT format string.
+     */
+    toDot(options?: {
+        name?: string;
+        showWeight?: boolean;
+    }): string;
+    /**
+     * Print the graph to console.
+     * @param options - Display settings passed to `toVisual`.
+     */
+    print(options?: {
+        showWeight?: boolean;
+    }): void;
 }

package/dist/types/data-structures/graph/directed-graph.d.ts

@@ -157,6 +157,7 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * @remarks Time O(1), Space O(1)
      */
     constructor(options?: Partial<GraphOptions<V>>);
+    protected get _edgeConnector(): string;
     protected _outEdgeMap: Map<VO, EO[]>;
     get outEdgeMap(): Map<VO, EO[]>;
     set outEdgeMap(v: Map<VO, EO[]>);

package/dist/types/data-structures/graph/undirected-graph.d.ts

@@ -313,6 +313,20 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
         bridges: EO[];
         cutVertices: VO[];
     };
+    /**
+     * Find biconnected components using edge-stack Tarjan variant.
+     * A biconnected component is a maximal biconnected subgraph.
+     * @returns Array of edge arrays, each representing a biconnected component.
+     * @remarks Time O(V + E), Space O(V + E)
+     */
+    getBiconnectedComponents(): EO[][];
+    /**
+     * Detect whether the graph contains a cycle.
+     * Uses DFS with parent tracking.
+     * @returns `true` if a cycle exists, `false` otherwise.
+     * @remarks Time O(V + E), Space O(V)
+     */
+    hasCycle(): boolean;
     /**
      * Get bridges discovered by `tarjan()`.
      * @returns Array of edges that are bridges.

package/dist/types/data-structures/queue/deque.d.ts

@@ -143,7 +143,10 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      * @param [options] - Options such as bucketSize, toElementFn, and maxLen.
      * @returns New Deque instance.
      */
-    constructor(elements?: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>, options?: DequeOptions<E, R>);
+    constructor(elements?: IterableWithSizeOrLength<E>, options?: DequeOptions<E, R>);
+    constructor(elements: IterableWithSizeOrLength<R>, options: DequeOptions<E, R> & {
+        toElementFn: (rawElement: R) => E;
+    });
     protected _bucketSize: number;
     /**
      * Get the current bucket size.
@@ -151,6 +154,26 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      * @returns Bucket capacity per bucket.
      */
     get bucketSize(): number;
+    protected _autoCompactRatio: number;
+    /**
+     * Get the auto-compaction ratio.
+     * When `elements / (bucketCount * bucketSize)` drops below this ratio after
+     * enough shift/pop operations, the deque auto-compacts.
+     * @remarks Time O(1), Space O(1)
+     * @returns Current ratio threshold. 0 means auto-compact is disabled.
+     */
+    get autoCompactRatio(): number;
+    /**
+     * Set the auto-compaction ratio.
+     * @remarks Time O(1), Space O(1)
+     * @param value - Ratio in [0,1]. 0 disables auto-compact.
+     */
+    set autoCompactRatio(value: number);
+    /**
+     * Counter for shift/pop operations since last compaction check.
+     * Only checks ratio every `_bucketSize` operations to minimize overhead.
+     */
+    protected _compactCounter: number;
     protected _bucketFirst: number;
     /**
      * Get the index of the first bucket in use.
@@ -369,6 +392,23 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      * @remarks Time O(N), Space O(1)
      * @returns void
      */
+    /**
+     * (Protected) Trigger auto-compaction if space utilization drops below threshold.
+     * Only checks every `_bucketSize` operations to minimize hot-path overhead.
+     * Uses element-based ratio: `elements / (bucketCount * bucketSize)`.
+     */
+    protected _autoCompact(): void;
+    /**
+     * Compact the deque by removing unused buckets.
+     * @remarks Time O(N), Space O(1)
+     * @returns True if compaction was performed (bucket count reduced).
+     */
+    /**
+     * Compact the deque by removing unused buckets.
+     * @remarks Time O(N), Space O(1)
+     * @returns True if compaction was performed (bucket count reduced).
+     */
+    compact(): boolean;
     shrinkToFit(): void;
     /**
      * Deep clone this deque, preserving options.

package/dist/types/types/data-structures/queue/deque.d.ts

@@ -1,4 +1,10 @@
 import { LinearBaseOptions } from '../base';
 export type DequeOptions<E, R> = {
     bucketSize?: number;
+    /**
+     * When the ratio of used buckets to total buckets falls below this threshold
+     * after a shift/pop, auto-compact is triggered. Set to 0 to disable.
+     * Default: 0.5 (compact when less than half the buckets are in use).
+     */
+    autoCompactRatio?: number;
 } & LinearBaseOptions<E, R>;

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

@@ -26,6 +26,7 @@ var binaryTreeTyped = (() => {
     BinaryTree: () => BinaryTree,
     BinaryTreeNode: () => BinaryTreeNode,
     DFSOperation: () => DFSOperation,
+    ERR: () => ERR,
     Range: () => Range
   });
 
@@ -80,6 +81,52 @@ var binaryTreeTyped = (() => {
     return (...args) => trampoline(fn(...args));
   }
 
+  // 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-element-base.ts
   var IterableElementBase = class {
     /**
@@ -102,7 +149,7 @@ var binaryTreeTyped = (() => {
       if (options) {
         const { toElementFn } = options;
         if (typeof toElementFn === "function") this._toElementFn = toElementFn;
-        else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+        else if (toElementFn) throw new TypeError(ERR.notAFunction("toElementFn"));
       }
     }
     /**
@@ -258,7 +305,7 @@ var binaryTreeTyped = (() => {
         acc = initialValue;
       } else {
         const first = iter.next();
-        if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+        if (first.done) throw new TypeError(ERR.reduceEmpty());
         acc = first.value;
         index = 1;
       }
@@ -1036,27 +1083,6 @@ var binaryTreeTyped = (() => {
     }
   };
 
-  // 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 +1218,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 +1253,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);
     }
@@ -1455,7 +1481,7 @@ var binaryTreeTyped = (() => {
       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,7 +1513,7 @@ 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;
@@ -2056,7 +2082,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 +2105,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);
           }
         }
       }
@@ -2543,42 +2569,98 @@ var binaryTreeTyped = (() => {
     _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;
         }
-        return [
-          mergedLines,
-          leftWidth + width + rightWidth,
-          Math.max(leftHeight, rightHeight) + 2,
-          leftWidth + Math.floor(width / 2)
-        ];
+        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 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.