avl-tree-typed 2.5.1 → 2.5.2

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

@@ -82,6 +82,52 @@ var avlTreeTyped = (() => {
     return (...args) => trampoline(fn(...args));
   }
 
+  // src/common/error.ts
+  function raise(ErrorClass, message) {
+    throw new ErrorClass(message);
+  }
+  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}.`,
+    // Order statistic
+    orderStatisticNotEnabled: (method, ctx) => `${ctx ? ctx + ": " : ""}${method}() requires enableOrderStatistic: true.`
+  };
+
+  // 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;
+    }
+    // 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 {
     /**
@@ -104,7 +150,7 @@ var avlTreeTyped = (() => {
       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");
       }
     }
     /**
@@ -260,7 +306,7 @@ var avlTreeTyped = (() => {
         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;
       }
@@ -492,47 +538,6 @@ var avlTreeTyped = (() => {
     }
   };
 
-  // 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 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 {
     /**
@@ -797,6 +802,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -844,6 +852,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -907,6 +918,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -966,6 +980,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -1032,6 +1049,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -1088,6 +1108,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -1137,6 +1160,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -1227,6 +1253,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -1270,6 +1299,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -1336,6 +1368,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -1386,6 +1421,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -1440,6 +1478,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -1708,7 +1749,7 @@ var avlTreeTyped = (() => {
         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);
     }
@@ -1941,6 +1982,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -1992,6 +2036,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -2095,6 +2142,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -2134,6 +2184,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -2194,6 +2247,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -2253,6 +2309,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -2390,6 +2449,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -2445,6 +2507,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -2503,6 +2568,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -2548,6 +2616,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -2602,6 +2673,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -2683,6 +2757,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -2741,6 +2818,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -3215,6 +3295,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -3264,6 +3347,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -3317,6 +3403,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -3395,6 +3484,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -4013,6 +4105,7 @@ var avlTreeTyped = (() => {
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       __publicField(this, "_root");
+      __publicField(this, "_enableOrderStatistic", false);
       /**
          * The comparator function used to determine the order of keys in the tree.
       
@@ -4025,6 +4118,9 @@ var avlTreeTyped = (() => {
         } else {
           this._comparator = this._createDefaultComparator();
         }
+        if (options.enableOrderStatistic) {
+          this._enableOrderStatistic = true;
+        }
       } else {
         this._comparator = this._createDefaultComparator();
       }
@@ -4194,6 +4290,12 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
       
       
       
@@ -4356,6 +4458,85 @@ var avlTreeTyped = (() => {
       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) {
+      var _a;
+      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 = (_a = keyNodeEntryOrPredicate[0]) != null ? _a : 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 != null ? 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).
@@ -4441,6 +4622,15 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
       
       
       
@@ -4465,6 +4655,7 @@ var avlTreeTyped = (() => {
         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;
@@ -4478,6 +4669,7 @@ var avlTreeTyped = (() => {
             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;
@@ -4486,6 +4678,7 @@ var avlTreeTyped = (() => {
             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;
@@ -4550,6 +4743,12 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
       
       
       
@@ -4837,6 +5036,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -4903,6 +5105,9 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
       
       
       
@@ -5016,6 +5221,12 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
       
       
       
@@ -5097,13 +5308,11 @@ var avlTreeTyped = (() => {
         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;
       };
@@ -5425,7 +5634,8 @@ var avlTreeTyped = (() => {
     _snapshotOptions() {
       return {
         ...super._snapshotOptions(),
-        comparator: this._comparator
+        comparator: this._comparator,
+        enableOrderStatistic: this._enableOrderStatistic
       };
     }
     /**
@@ -5447,6 +5657,113 @@ var avlTreeTyped = (() => {
      *
      * @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;
@@ -5493,21 +5810,28 @@ var avlTreeTyped = (() => {
         while (x.left !== void 0 && x.left !== null) x = x.left;
         return x;
       };
+      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;
     }
@@ -5788,6 +6112,18 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
       
       
       
@@ -5906,6 +6242,15 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
       
       
       
@@ -5986,6 +6331,12 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
       
       
       
@@ -6110,6 +6461,15 @@ var avlTreeTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
       
       
       
@@ -6238,6 +6598,8 @@ var avlTreeTyped = (() => {
       }
       this._updateHeight(A);
       if (B) this._updateHeight(B);
+      this._updateCount(A);
+      if (B) this._updateCount(B);
     }
     /**
      * (Protected) Performs a Left-Right (LR) double rotation.
@@ -6283,6 +6645,9 @@ var avlTreeTyped = (() => {
       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).
@@ -6317,6 +6682,8 @@ var avlTreeTyped = (() => {
       }
       this._updateHeight(A);
       if (B) this._updateHeight(B);
+      this._updateCount(A);
+      if (B) this._updateCount(B);
     }
     /**
      * (Protected) Performs a Right-Left (RL) double rotation.
@@ -6360,6 +6727,9 @@ var avlTreeTyped = (() => {
       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.
@@ -6374,6 +6744,7 @@ var avlTreeTyped = (() => {
         const A = path[i];
         if (A) {
           this._updateHeight(A);
+          this._updateCount(A);
           switch (this._balanceFactor(A)) {
             case -2:
               if (A && A.left) {