data-structure-typed 2.6.0 → 2.6.1

package/src/data-structures/binary-tree/bst.ts

@@ -25,7 +25,7 @@ import { BinaryTree } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
 import { isComparable } from '../../utils';
-import { ERR, Range, raise } from '../../common';
+import { ERR, raise, Range } from '../../common';
 
 /**
  * Represents a Node in a Binary Search Tree.
@@ -104,6 +104,7 @@ export class BSTNode<K = any, V = any> {
    *
    * @returns The height.
    */
+
   /* istanbul ignore next -- covered by AVLTree/RedBlackTree tests (subclass uses height) */
   get height(): number {
     return this._height;
@@ -115,6 +116,7 @@ export class BSTNode<K = any, V = any> {
    *
    * @param value - The new height.
    */
+
   /* istanbul ignore next -- covered by AVLTree/RedBlackTree tests (subclass uses height) */
   set height(value: number) {
     this._height = value;
@@ -128,6 +130,7 @@ export class BSTNode<K = any, V = any> {
    *
    * @returns The node's color.
    */
+
   /* istanbul ignore next -- covered by RedBlackTree tests (subclass uses color) */
   get color(): RBTNColor {
     return this._color;
@@ -139,6 +142,7 @@ export class BSTNode<K = any, V = any> {
    *
    * @param value - The new color.
    */
+
   /* istanbul ignore next -- covered by RedBlackTree tests (subclass uses color) */
   set color(value: RBTNColor) {
     this._color = value;
@@ -152,6 +156,7 @@ export class BSTNode<K = any, V = any> {
    *
    * @returns The subtree node count.
    */
+
   /* istanbul ignore next -- internal field used by subclasses */
   get count(): number {
     return this._count;
@@ -163,6 +168,7 @@ export class BSTNode<K = any, V = any> {
    *
    * @param value - The new count.
    */
+
   /* istanbul ignore next -- internal field used by subclasses */
   set count(value: number) {
     this._count = value;
@@ -324,6 +330,15 @@ export class BSTNode<K = any, V = any> {
  *     console.log(findLCA(20, 30)); // 25;
  */
 export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implements IBinaryTree<K, V, R> {
+  protected _enableOrderStatistic: boolean = false;
+
+  /**
+   * The comparator function used to determine the order of keys in the tree.
+
+   * @remarks Time O(1) Space O(1)
+   */
+  protected readonly _comparator: Comparator<K>;
+
   /**
    * Creates an instance of BST.
    * @remarks Time O(N log N) or O(N^2) depending on `isBalanceAdd` in `addMany` and input order. Space O(N).
@@ -356,8 +371,6 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
 
   protected override _root?: BSTNode<K, V> = undefined;
 
-  protected _enableOrderStatistic: boolean = false;
-
   /**
    * Gets the root node of the tree.
    * @remarks Time O(1)
@@ -368,13 +381,6 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     return this._root;
   }
 
-  /**
-   * The comparator function used to determine the order of keys in the tree.
-
-   * @remarks Time O(1) Space O(1)
-   */
-  protected readonly _comparator: Comparator<K>;
-
   /**
    * Gets the comparator function used by the tree.
    * @remarks Time O(1)
@@ -436,97 +442,13 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     return isComparable(key);
   }
 
-    /**
+  /**
    * Depth-first search traversal
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Depth-first traversal
- *  const bst = new BST<number>([5, 3, 7, 1, 4]);
- *     const inOrder = bst.dfs(node => node.key, 'IN');
- *     console.log(inOrder); // [1, 3, 4, 5, 7];
+   * @example
+   * // Depth-first traversal
+   *  const bst = new BST<number>([5, 3, 7, 1, 4]);
+   *     const inOrder = bst.dfs(node => node.key, 'IN');
+   *     console.log(inOrder); // [1, 3, 4, 5, 7];
    */
   override dfs(): (K | undefined)[];
 
@@ -560,89 +482,13 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     return super.dfs(callback, pattern, onlyOne, startNode, iterationType);
   }
 
-    /**
+  /**
    * BinaryTree level-order traversal
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Breadth-first traversal
- *  const bst = new BST<number>([5, 3, 7]);
- *     const result = bst.bfs(node => node.key);
- *     console.log(result.length); // 3;
+   * @example
+   * // Breadth-first traversal
+   *  const bst = new BST<number>([5, 3, 7]);
+   *     const result = bst.bfs(node => node.key);
+   *     console.log(result.length); // 3;
    */
   override bfs(): (K | undefined)[];
   override bfs<C extends NodeCallback<BSTNode<K, V>>>(
@@ -669,95 +515,16 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     return super.bfs(callback, startNode, iterationType, false);
   }
 
-    /**
+  /**
    * Level-order grouping
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Level-order grouping
- *  const bst = new BST<number>([5, 3, 7, 1, 4]);
- *     const levels = bst.listLevels(node => node.key);
- *     console.log(levels); // toBeInstanceOf;
- *     console.log(levels[0].length); // 1; // root level has 1 node
- *     const allKeys = levels.flat().sort((a, b) => a - b);
- *     console.log(allKeys); // [1, 3, 4, 5, 7];
+   * @example
+   * // Level-order grouping
+   *  const bst = new BST<number>([5, 3, 7, 1, 4]);
+   *     const levels = bst.listLevels(node => node.key);
+   *     console.log(levels); // toBeInstanceOf;
+   *     console.log(levels[0].length); // 1; // root level has 1 node
+   *     const allKeys = levels.flat().sort((a, b) => a - b);
+   *     console.log(allKeys); // [1, 3, 4, 5, 7];
    */
   override listLevels(): (K | undefined)[][];
 
@@ -793,93 +560,16 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * @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';
+   * @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';
    */
   override getNode(
     keyNodeEntryOrPredicate:
@@ -940,88 +630,18 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     return undefined;
   }
 
-
-    /**
+  /**
    * Search nodes by predicate
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Search nodes by predicate
- *  const bst = new BST<number, string>([[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd']]);
- *     const found = bst.search(node => node.key > 2, true);
- *     console.log(found.length); // >= 1;
+   * @example
+   * // Search nodes by predicate
+   *  const bst = new BST<number, string>([
+   *       [1, 'a'],
+   *       [2, 'b'],
+   *       [3, 'c'],
+   *       [4, 'd']
+   *     ]);
+   *     const found = bst.search(node => node.key > 2, true);
+   *     console.log(found.length); // >= 1;
    */
   override search(
     keyNodeEntryOrPredicate:
@@ -1118,7 +738,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       predicate = node => {
         /* istanbul ignore next -- node is always defined in iteration callbacks */
         if (!node) return false;
-        return (keyNodeEntryOrPredicate).isInRange(node.key, this._comparator);
+        return keyNodeEntryOrPredicate.isInRange(node.key, this._comparator);
       };
     } else {
       predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
@@ -1126,7 +746,8 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
 
     // Optimization: Pruning logic
     const shouldVisitLeft = (cur: BSTNode<K, V> | null | undefined) => {
-      /* istanbul ignore next -- defensive: cur is always defined when called from iteration */ if (!cur) return false;
+      /* istanbul ignore next -- defensive: cur is always defined when called from iteration */
+      if (!cur) return false;
       if (!this.isRealNode(cur.left)) return false;
       if (isRange) {
         // Range search: Only go left if the current key is >= the lower bound
@@ -1144,7 +765,8 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     };
 
     const shouldVisitRight = (cur: BSTNode<K, V> | null | undefined) => {
-      /* istanbul ignore next -- defensive */ if (!cur) return false;
+      /* istanbul ignore next -- defensive */
+      if (!cur) return false;
       if (!this.isRealNode(cur.right)) return false;
       if (isRange) {
         // Range search: Only go right if current key <= upper bound
@@ -1175,54 +797,12 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     );
   }
 
-    /**
+  /**
    * Find all keys in a range
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Find all keys in a range
- *  const bst = new BST<number>([10, 20, 30, 40, 50]);
- *     console.log(bst.rangeSearch([15, 35])); // [20, 30];
+   * @example
+   * // Find all keys in a range
+   *  const bst = new BST<number>([10, 20, 30, 40, 50]);
+   *     console.log(bst.rangeSearch([15, 35])); // [20, 30];
    */
   rangeSearch(range: Range<K> | [K, K]): (K | undefined)[];
 
@@ -1263,12 +843,12 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    *
    * @param k - The 0-based position in tree order (0 = first element).
    * @returns The key at position k, or `undefined` if out of bounds.
-    * @example
- * // Order-statistic on BST
- *  const tree = new BST<number>([30, 10, 50, 20, 40], { enableOrderStatistic: true });
- *       console.log(tree.getByRank(0)); // 10;
- *       console.log(tree.getByRank(4)); // 50;
- *       console.log(tree.getRank(30)); // 2;
+   * @example
+   * // Order-statistic on BST
+   *  const tree = new BST<number>([30, 10, 50, 20, 40], { enableOrderStatistic: true });
+   *       console.log(tree.getByRank(0)); // 10;
+   *       console.log(tree.getByRank(4)); // 50;
+   *       console.log(tree.getRank(30)); // 2;
    */
   getByRank(k: number): K | undefined;
 
@@ -1309,9 +889,10 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       }
     }
 
-    const node = actualIterationType === 'RECURSIVE'
-      ? this._getByRankRecursive(this._root, k)
-      : this._getByRankIterative(this._root, k);
+    const node =
+      actualIterationType === 'RECURSIVE'
+        ? this._getByRankRecursive(this._root, k)
+        : this._getByRankIterative(this._root, k);
 
     if (!node) return undefined;
     return actualCallback ? actualCallback(node) : node.key;
@@ -1456,15 +1037,16 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     const count = hi - lo + 1;
 
     // Find the lo-th node, then in-order traverse count nodes
-    const startNode = actualIterationType === 'RECURSIVE'
-      ? this._getByRankRecursive(this._root, lo)
-      : this._getByRankIterative(this._root, lo);
+    const startNode =
+      actualIterationType === 'RECURSIVE'
+        ? this._getByRankRecursive(this._root, lo)
+        : this._getByRankIterative(this._root, lo);
 
     if (!startNode) return [];
 
     // In-order traversal from startNode collecting count elements
     let collected = 0;
-    const cb = actualCallback ?? this._DEFAULT_NODE_CALLBACK as C;
+    const cb = actualCallback ?? (this._DEFAULT_NODE_CALLBACK as C);
 
     // Use higher() to iterate — it's already O(log n) amortized per step
     let current: BSTNode<K, V> | undefined = startNode;
@@ -1487,130 +1069,12 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * @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';
+   * @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';
    */
   override set(
     keyNodeOrEntry: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
@@ -1671,85 +1135,16 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * @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';
+   * @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';
    */
   override setMany(
     keysNodesEntriesOrRaws: Iterable<R | BTNRep<K, V, BSTNode<K, V>>>,
@@ -1848,54 +1243,12 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * Equivalent to Java TreeMap.ceiling.
    * Time Complexity: O(log n) average, O(h) worst case.
    * Space Complexity: O(h) for recursion, O(1) for iteration.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Find the least key ≥ target
- *  const bst = new BST<number>([10, 20, 30, 40, 50]);
- *     console.log(bst.ceiling(25)); // 30;
- *     console.log(bst.ceiling(30)); // 30;
- *     console.log(bst.ceiling(55)); // undefined;
+   * @example
+   * // Find the least key ≥ target
+   *  const bst = new BST<number>([10, 20, 30, 40, 50]);
+   *     console.log(bst.ceiling(25)); // 30;
+   *     console.log(bst.ceiling(30)); // 30;
+   *     console.log(bst.ceiling(55)); // undefined;
    */
   ceiling(
     keyNodeEntryOrPredicate:
@@ -1961,53 +1314,11 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * Equivalent to Java TreeMap.higher.
    * Time Complexity: O(log n) average, O(h) worst case.
    * Space Complexity: O(h) for recursion, O(1) for iteration.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Find the least key strictly > target
- *  const bst = new BST<number>([10, 20, 30, 40]);
- *     console.log(bst.higher(20)); // 30;
- *     console.log(bst.higher(40)); // undefined;
+   * @example
+   * // Find the least key strictly > target
+   *  const bst = new BST<number>([10, 20, 30, 40]);
+   *     console.log(bst.higher(20)); // 30;
+   *     console.log(bst.higher(40)); // undefined;
    */
   higher(
     keyNodeEntryOrPredicate:
@@ -2073,54 +1384,12 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * Equivalent to Java TreeMap.floor.
    * Time Complexity: O(log n) average, O(h) worst case.
    * Space Complexity: O(h) for recursion, O(1) for iteration.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Find the greatest key ≤ target
- *  const bst = new BST<number>([10, 20, 30, 40, 50]);
- *     console.log(bst.floor(25)); // 20;
- *     console.log(bst.floor(10)); // 10;
- *     console.log(bst.floor(5)); // undefined;
+   * @example
+   * // Find the greatest key ≤ target
+   *  const bst = new BST<number>([10, 20, 30, 40, 50]);
+   *     console.log(bst.floor(25)); // 20;
+   *     console.log(bst.floor(10)); // 10;
+   *     console.log(bst.floor(5)); // undefined;
    */
   floor(
     keyNodeEntryOrPredicate:
@@ -2161,7 +1430,8 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     iterationType?: IterationType
   ): K | undefined | ReturnType<C> {
     if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === undefined) {
-      /* istanbul ignore next */ if (typeof callback === 'string' || !callback) {
+      /* istanbul ignore next */
+      if (typeof callback === 'string' || !callback) {
         return undefined;
       }
       return undefined;
@@ -2195,7 +1465,8 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     } else if (this.isEntry(keyNodeEntryOrPredicate)) {
       const key = keyNodeEntryOrPredicate[0];
       if (key === null || key === undefined) {
-        /* istanbul ignore next */ if (typeof callback === 'string' || !callback) {
+        /* istanbul ignore next */
+        if (typeof callback === 'string' || !callback) {
           return undefined;
         }
         return undefined;
@@ -2229,53 +1500,11 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * Equivalent to Java TreeMap.lower.
    * Time Complexity: O(log n) average, O(h) worst case.
    * Space Complexity: O(h) for recursion, O(1) for iteration.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Find the greatest key strictly < target
- *  const bst = new BST<number>([10, 20, 30, 40]);
- *     console.log(bst.lower(30)); // 20;
- *     console.log(bst.lower(10)); // undefined;
+   * @example
+   * // Find the greatest key strictly < target
+   *  const bst = new BST<number>([10, 20, 30, 40]);
+   *     console.log(bst.lower(30)); // 20;
+   *     console.log(bst.lower(10)); // undefined;
    */
   lower(
     keyNodeEntryOrPredicate:
@@ -2316,7 +1545,8 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     iterationType?: IterationType
   ): K | undefined | ReturnType<C> {
     if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === undefined) {
-      /* istanbul ignore next */ if (typeof callback === 'string' || !callback) {
+      /* istanbul ignore next */
+      if (typeof callback === 'string' || !callback) {
         return undefined;
       }
       /* istanbul ignore next */
@@ -2351,10 +1581,11 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     } else if (this.isEntry(keyNodeEntryOrPredicate)) {
       const key = keyNodeEntryOrPredicate[0];
       if (key === null || key === undefined) {
-        /* istanbul ignore next */ if (typeof callback === 'string' || !callback) {
+        /* istanbul ignore next */
+        if (typeof callback === 'string' || !callback) {
           return undefined;
         }
-      /* istanbul ignore next */
+        /* istanbul ignore next */
         return undefined;
       }
       targetKey = key;
@@ -2443,54 +1674,14 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    *
    * @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;
+   * @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: IterationType = this.iterationType): boolean {
     const nodes = this.dfs(node => node, 'IN', false, this._root, iterationType);
@@ -2523,50 +1714,10 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    *
    * @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;
+   * @example
+   * // Check if tree is height-balanced
+   *  const bst = new BST<number>([3, 1, 5, 2, 4]);
+   *     console.log(bst.isAVLBalanced()); // true;
    */
   isAVLBalanced(iterationType: IterationType = this.iterationType): boolean {
     if (!this._root) return true;
@@ -2624,92 +1775,15 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * @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];
+   * @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];
    */
   override map<MK = K, MV = V, MR = any>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
@@ -3308,9 +2382,8 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    */
   protected _updateCount(node: BSTNode<K, V>): void {
     if (!this._enableOrderStatistic) return;
-    node._count = 1
-      + (this.isRealNode(node.left) ? node.left._count : 0)
-      + (this.isRealNode(node.right) ? node.right._count : 0);
+    node._count =
+      1 + (this.isRealNode(node.left) ? node.left._count : 0) + (this.isRealNode(node.right) ? node.right._count : 0);
   }
 
   /**
@@ -3395,8 +2468,11 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     if (cmp > 0) {
       return this._getRankRecursive(node.left as BSTNode<K, V> | undefined, key);
     } else if (cmp < 0) {
-      return (this.isRealNode(node.left) ? node.left._count : 0) + 1
-        + this._getRankRecursive(node.right as BSTNode<K, V> | undefined, key);
+      return (
+        (this.isRealNode(node.left) ? node.left._count : 0) +
+        1 +
+        this._getRankRecursive(node.right as BSTNode<K, V> | undefined, key)
+      );
     } else {
       return this.isRealNode(node.left) ? node.left._count : 0;
     }