avl-tree-typed 2.5.1 → 2.5.2

package/dist/esm/index.mjs

@@ -57,6 +57,56 @@ function makeTrampoline(fn) {
 }
 __name(makeTrampoline, "makeTrampoline");
 
+// src/common/error.ts
+function raise(ErrorClass, message) {
+  throw new ErrorClass(message);
+}
+__name(raise, "raise");
+var ERR = {
+  // Range / index
+  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
+  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
+  // Type / argument
+  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
+  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
+  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
+  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
+  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
+  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
+  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
+  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
+  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
+  // State / operation
+  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
+  // Matrix
+  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
+  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
+  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
+  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
+  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch"),
+  // Order statistic
+  orderStatisticNotEnabled: /* @__PURE__ */ __name((method, ctx) => `${ctx ? ctx + ": " : ""}${method}() requires enableOrderStatistic: true.`, "orderStatisticNotEnabled")
+};
+
+// src/common/index.ts
+var Range = class {
+  constructor(low, high, includeLow = true, includeHigh = true) {
+    this.low = low;
+    this.high = high;
+    this.includeLow = includeLow;
+    this.includeHigh = includeHigh;
+  }
+  static {
+    __name(this, "Range");
+  }
+  // Determine whether a key is within the range
+  isInRange(key, comparator) {
+    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+    return lowCheck && highCheck;
+  }
+};
+
 // src/data-structures/base/iterable-element-base.ts
 var IterableElementBase = class {
   static {
@@ -75,7 +125,7 @@ var IterableElementBase = class {
     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) raise(TypeError, "toElementFn must be a function type");
     }
   }
   /**
@@ -238,7 +288,7 @@ var IterableElementBase = class {
       acc = initialValue;
     } else {
       const first = iter.next();
-      if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+      if (first.done) raise(TypeError, "Reduce of empty structure with no initial value");
       acc = first.value;
       index = 1;
     }
@@ -473,50 +523,6 @@ var LinearBase = class _LinearBase extends IterableElementBase {
   }
 };
 
-// src/common/error.ts
-var ERR = {
-  // Range / index
-  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
-  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
-  // Type / argument
-  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
-  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
-  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
-  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
-  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
-  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
-  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
-  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
-  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
-  // State / operation
-  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
-  // Matrix
-  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
-  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
-  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
-  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
-  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch")
-};
-
-// src/common/index.ts
-var Range = class {
-  constructor(low, high, includeLow = true, includeHigh = true) {
-    this.low = low;
-    this.high = high;
-    this.includeLow = includeLow;
-    this.includeHigh = includeHigh;
-  }
-  static {
-    __name(this, "Range");
-  }
-  // Determine whether a key is within the range
-  isInRange(key, comparator) {
-    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-    return lowCheck && highCheck;
-  }
-};
-
 // src/data-structures/base/iterable-entry-base.ts
 var IterableEntryBase = class {
   static {
@@ -787,6 +793,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -834,6 +843,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -897,6 +909,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -956,6 +971,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -1022,6 +1040,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -1078,6 +1099,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -1127,6 +1151,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -1217,6 +1244,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -1260,6 +1290,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -1326,6 +1359,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -1376,6 +1412,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -1430,6 +1469,9 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
     
     
     
@@ -1684,7 +1726,7 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
       if (isMapMode !== void 0) this._isMapMode = isMapMode;
       if (isDuplicate !== void 0) this._isDuplicate = isDuplicate;
       if (typeof toEntryFn === "function") this._toEntryFn = toEntryFn;
-      else if (toEntryFn) throw new TypeError(ERR.notAFunction("toEntryFn", "BinaryTree"));
+      else if (toEntryFn) raise(TypeError, ERR.notAFunction("toEntryFn", "BinaryTree"));
     }
     if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
@@ -1927,6 +1969,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -1978,6 +2023,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -2081,6 +2129,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -2120,6 +2171,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -2180,6 +2234,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -2239,6 +2296,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -2376,6 +2436,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -2431,6 +2494,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -2488,6 +2554,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -2533,6 +2602,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -2587,6 +2659,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -2668,6 +2743,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -2726,6 +2804,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -3200,6 +3281,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -3249,6 +3333,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -3302,6 +3389,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -3380,6 +3470,9 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
     
     
     
@@ -4015,12 +4108,16 @@ var BST = class extends BinaryTree {
       } else {
         this._comparator = this._createDefaultComparator();
       }
+      if (options.enableOrderStatistic) {
+        this._enableOrderStatistic = true;
+      }
     } else {
       this._comparator = this._createDefaultComparator();
     }
     if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
   _root = void 0;
+  _enableOrderStatistic = false;
   /**
    * Gets the root node of the tree.
    * @remarks Time O(1)
@@ -4190,6 +4287,12 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4351,6 +4454,84 @@ var BST = class extends BinaryTree {
     const searchRange = range instanceof Range ? range : new Range(range[0], range[1]);
     return this.search(searchRange, false, callback, startNode, iterationType);
   }
+  getByRank(k, callback = this._DEFAULT_NODE_CALLBACK, iterationType = this.iterationType) {
+    if (!this._enableOrderStatistic) {
+      raise(Error, ERR.orderStatisticNotEnabled("getByRank"));
+    }
+    if (k < 0 || k >= this._size) return void 0;
+    let actualCallback = void 0;
+    let actualIterationType = this.iterationType;
+    if (typeof callback === "string") {
+      actualIterationType = callback;
+    } else if (callback) {
+      actualCallback = callback;
+      if (iterationType) {
+        actualIterationType = iterationType;
+      }
+    }
+    const node = actualIterationType === "RECURSIVE" ? this._getByRankRecursive(this._root, k) : this._getByRankIterative(this._root, k);
+    if (!node) return void 0;
+    return actualCallback ? actualCallback(node) : node.key;
+  }
+  getRank(keyNodeEntryOrPredicate, iterationType = this.iterationType) {
+    if (!this._enableOrderStatistic) {
+      raise(Error, ERR.orderStatisticNotEnabled("getRank"));
+    }
+    if (!this._root || this._size === 0) return -1;
+    let actualIterationType = this.iterationType;
+    if (iterationType) actualIterationType = iterationType;
+    let key;
+    if (typeof keyNodeEntryOrPredicate === "function") {
+      const results = this.search(keyNodeEntryOrPredicate, true);
+      if (results.length === 0 || results[0] === void 0) return -1;
+      key = results[0];
+    } else if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) {
+      return -1;
+    } else if (this.isNode(keyNodeEntryOrPredicate)) {
+      key = keyNodeEntryOrPredicate.key;
+    } else if (Array.isArray(keyNodeEntryOrPredicate)) {
+      key = keyNodeEntryOrPredicate[0] ?? void 0;
+      if (key === void 0 || key === null) return -1;
+    } else {
+      key = keyNodeEntryOrPredicate;
+    }
+    if (key === void 0) return -1;
+    return actualIterationType === "RECURSIVE" ? this._getRankRecursive(this._root, key) : this._getRankIterative(this._root, key);
+  }
+  rangeByRank(start, end, callback = this._DEFAULT_NODE_CALLBACK, iterationType = this.iterationType) {
+    if (!this._enableOrderStatistic) {
+      raise(Error, ERR.orderStatisticNotEnabled("rangeByRank"));
+    }
+    if (this._size === 0) return [];
+    const lo = Math.max(0, start);
+    const hi = Math.min(this._size - 1, end);
+    if (lo > hi) return [];
+    let actualCallback = void 0;
+    let actualIterationType = this.iterationType;
+    if (typeof callback === "string") {
+      actualIterationType = callback;
+    } else if (callback) {
+      actualCallback = callback;
+      if (iterationType) {
+        actualIterationType = iterationType;
+      }
+    }
+    const results = [];
+    const count = hi - lo + 1;
+    const startNode = actualIterationType === "RECURSIVE" ? this._getByRankRecursive(this._root, lo) : this._getByRankIterative(this._root, lo);
+    if (!startNode) return [];
+    let collected = 0;
+    const cb = actualCallback ?? this._DEFAULT_NODE_CALLBACK;
+    let current = startNode;
+    while (current && collected < count) {
+      results.push(cb(current));
+      collected++;
+      if (collected < count) {
+        current = this._next(current);
+      }
+    }
+    return results;
+  }
   /**
     * Adds a new node to the BST based on key comparison.
     * @remarks Time O(log N), where H is tree height. O(N) worst-case (unbalanced tree), O(log N) average. Space O(1).
@@ -4436,6 +4617,15 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4460,6 +4650,7 @@ var BST = class extends BinaryTree {
       this._setRoot(newNode);
       if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
       this._size++;
+      this._updateCount(newNode);
       return true;
     }
     let current = this._root;
@@ -4473,6 +4664,7 @@ var BST = class extends BinaryTree {
           current.left = newNode;
           if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
+          this._updateCountAlongPath(newNode);
           return true;
         }
         if (current.left !== null) current = current.left;
@@ -4481,6 +4673,7 @@ var BST = class extends BinaryTree {
           current.right = newNode;
           if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
+          this._updateCountAlongPath(newNode);
           return true;
         }
         if (current.right !== null) current = current.right;
@@ -4545,6 +4738,12 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4832,6 +5031,9 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
     
     
     
@@ -4898,6 +5100,9 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
     
     
     
@@ -5011,6 +5216,12 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5092,13 +5303,11 @@ var BST = class extends BinaryTree {
       if (a instanceof Date && b instanceof Date) {
         const ta = a.getTime();
         const tb = b.getTime();
-        if (Number.isNaN(ta) || Number.isNaN(tb)) throw new TypeError(ERR.invalidDate("BST"));
+        if (Number.isNaN(ta) || Number.isNaN(tb)) raise(TypeError, ERR.invalidDate("BST"));
         return ta > tb ? 1 : ta < tb ? -1 : 0;
       }
       if (typeof a === "object" || typeof b === "object") {
-        throw new TypeError(
-          ERR.comparatorRequired("BST")
-        );
+        raise(TypeError, ERR.comparatorRequired("BST"));
       }
       return 0;
     };
@@ -5417,7 +5626,8 @@ var BST = class extends BinaryTree {
   _snapshotOptions() {
     return {
       ...super._snapshotOptions(),
-      comparator: this._comparator
+      comparator: this._comparator,
+      enableOrderStatistic: this._enableOrderStatistic
     };
   }
   /**
@@ -5439,6 +5649,113 @@ var BST = class extends BinaryTree {
    *
    * @param v - The node to set as root.
    */
+  /**
+   * (Protected) Recalculates the subtree count for a single node.
+   * @remarks Time O(1). Only active when enableOrderStatistic is true.
+   */
+  _updateCount(node) {
+    if (!this._enableOrderStatistic) return;
+    node._count = 1 + (this.isRealNode(node.left) ? node.left._count : 0) + (this.isRealNode(node.right) ? node.right._count : 0);
+  }
+  /**
+   * (Protected) Updates subtree counts from a node up to the root.
+   * @remarks Time O(log n). Only active when enableOrderStatistic is true.
+   */
+  _updateCountAlongPath(node) {
+    if (!this._enableOrderStatistic) return;
+    let current = node;
+    while (current) {
+      this._updateCount(current);
+      current = current.parent;
+    }
+  }
+  /**
+   * (Protected) Finds the node at position k in tree order (iterative).
+   * @remarks Time O(log n), Space O(1)
+   */
+  _getByRankIterative(node, k) {
+    let current = node;
+    let remaining = k;
+    while (current) {
+      const leftCount = this.isRealNode(current.left) ? current.left._count : 0;
+      if (remaining < leftCount) {
+        current = current.left;
+      } else if (remaining === leftCount) {
+        return current;
+      } else {
+        remaining = remaining - leftCount - 1;
+        current = current.right;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * (Protected) Finds the node at position k in tree order (recursive).
+   * @remarks Time O(log n), Space O(log n) call stack
+   */
+  _getByRankRecursive(node, k) {
+    if (!node) return void 0;
+    const leftCount = this.isRealNode(node.left) ? node.left._count : 0;
+    if (k < leftCount) return this._getByRankRecursive(node.left, k);
+    if (k === leftCount) return node;
+    return this._getByRankRecursive(node.right, k - leftCount - 1);
+  }
+  /**
+   * (Protected) Computes the rank of a key iteratively.
+   * @remarks Time O(log n), Space O(1)
+   */
+  _getRankIterative(node, key) {
+    let rank = 0;
+    let current = node;
+    while (this.isRealNode(current)) {
+      const cmp = this._compare(current.key, key);
+      if (cmp > 0) {
+        current = current.left;
+      } else if (cmp < 0) {
+        rank += (this.isRealNode(current.left) ? current.left._count : 0) + 1;
+        current = current.right;
+      } else {
+        rank += this.isRealNode(current.left) ? current.left._count : 0;
+        return rank;
+      }
+    }
+    return rank;
+  }
+  /**
+   * (Protected) Computes the rank of a key recursively.
+   * @remarks Time O(log n), Space O(log n) call stack
+   */
+  _getRankRecursive(node, key) {
+    if (!node) return 0;
+    const cmp = this._compare(node.key, key);
+    if (cmp > 0) {
+      return this._getRankRecursive(node.left, key);
+    } else if (cmp < 0) {
+      return (this.isRealNode(node.left) ? node.left._count : 0) + 1 + this._getRankRecursive(node.right, key);
+    } else {
+      return this.isRealNode(node.left) ? node.left._count : 0;
+    }
+  }
+  /**
+   * (Protected) Finds the in-order successor of a node.
+   * @remarks Time O(log n), Space O(1)
+   */
+  _next(node) {
+    if (this.isRealNode(node.right)) {
+      let current2 = node.right;
+      while (this.isRealNode(current2.left)) {
+        current2 = current2.left;
+      }
+      return current2;
+    }
+    let current = node;
+    let parent = current.parent;
+    while (parent && current === parent.right) {
+      current = parent;
+      parent = parent.parent;
+    }
+    return parent;
+  }
   _setRoot(v) {
     if (v) v.parent = void 0;
     this._root = v;
@@ -5485,21 +5802,28 @@ var BST = class extends BinaryTree {
       while (x.left !== void 0 && x.left !== null) x = x.left;
       return x;
     }, "minNode");
+    let countUpdateStart;
     if (node.left === void 0) {
+      countUpdateStart = node.parent;
       transplant(node, node.right);
     } else if (node.right === void 0) {
+      countUpdateStart = node.parent;
       transplant(node, node.left);
     } else {
       const succ = minNode(node.right);
       if (succ.parent !== node) {
+        countUpdateStart = succ.parent;
         transplant(succ, succ.right);
         succ.right = node.right;
         if (succ.right) succ.right.parent = succ;
+      } else {
+        countUpdateStart = succ;
       }
       transplant(node, succ);
       succ.left = node.left;
       if (succ.left) succ.left.parent = succ;
     }
+    this._updateCountAlongPath(countUpdateStart);
     this._size = Math.max(0, this._size - 1);
     return true;
   }
@@ -5786,6 +6110,18 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5904,6 +6240,15 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5984,6 +6329,12 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6108,6 +6459,15 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6236,6 +6596,8 @@ var AVLTree = class extends BST {
     }
     this._updateHeight(A);
     if (B) this._updateHeight(B);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
   }
   /**
    * (Protected) Performs a Left-Right (LR) double rotation.
@@ -6281,6 +6643,9 @@ var AVLTree = class extends BST {
     this._updateHeight(A);
     if (B) this._updateHeight(B);
     if (C) this._updateHeight(C);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
+    if (C) this._updateCount(C);
   }
   /**
    * (Protected) Performs a Right-Right (RR) rotation (a single left rotation).
@@ -6315,6 +6680,8 @@ var AVLTree = class extends BST {
     }
     this._updateHeight(A);
     if (B) this._updateHeight(B);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
   }
   /**
    * (Protected) Performs a Right-Left (RL) double rotation.
@@ -6358,6 +6725,9 @@ var AVLTree = class extends BST {
     this._updateHeight(A);
     if (B) this._updateHeight(B);
     if (C) this._updateHeight(C);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
+    if (C) this._updateCount(C);
   }
   /**
    * (Protected) Traverses up the tree from the specified node, updating heights and performing rotations as needed.
@@ -6372,6 +6742,7 @@ var AVLTree = class extends BST {
       const A = path[i];
       if (A) {
         this._updateHeight(A);
+        this._updateCount(A);
         switch (this._balanceFactor(A)) {
           case -2:
             if (A && A.left) {