data-structure-typed 2.5.1 → 2.5.2

package/dist/cjs-legacy/binary-tree.cjs

@@ -68,6 +68,55 @@ 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 _Range {
+  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;
+  }
+};
+__name(_Range, "Range");
+var Range = _Range;
+
 // src/data-structures/base/iterable-element-base.ts
 var _IterableElementBase = class _IterableElementBase {
   /**
@@ -90,7 +139,7 @@ var _IterableElementBase = class _IterableElementBase {
     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");
     }
   }
   /**
@@ -246,7 +295,7 @@ var _IterableElementBase = class _IterableElementBase {
       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;
     }
@@ -482,49 +531,6 @@ var _LinearBase = class _LinearBase extends IterableElementBase {
 __name(_LinearBase, "LinearBase");
 var LinearBase = _LinearBase;
 
-// 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 _Range {
-  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;
-  }
-};
-__name(_Range, "Range");
-var Range = _Range;
-
 // src/data-structures/base/iterable-entry-base.ts
 var _IterableEntryBase = class _IterableEntryBase {
   /**
@@ -789,6 +795,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -835,6 +845,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -897,6 +911,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -955,6 +973,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1020,6 +1042,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1075,6 +1101,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1123,6 +1153,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1212,6 +1246,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1254,6 +1292,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1319,6 +1361,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1368,6 +1414,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1421,6 +1471,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1694,7 +1748,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);
   }
@@ -1925,6 +1979,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1975,6 +2033,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2077,6 +2139,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2115,6 +2181,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2174,6 +2244,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2232,6 +2306,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2368,6 +2446,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2422,6 +2504,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2479,6 +2565,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2523,6 +2613,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2576,6 +2670,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2656,6 +2754,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2713,6 +2815,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3186,6 +3292,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3234,6 +3344,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3286,6 +3400,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3363,6 +3481,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3986,6 +4108,7 @@ var _BST = class _BST extends BinaryTree {
   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.
     
@@ -3998,6 +4121,9 @@ var _BST = class _BST extends BinaryTree {
       } else {
         this._comparator = this._createDefaultComparator();
       }
+      if (options.enableOrderStatistic) {
+        this._enableOrderStatistic = true;
+      }
     } else {
       this._comparator = this._createDefaultComparator();
     }
@@ -4163,6 +4289,14 @@ var _BST = class _BST extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4327,6 +4461,85 @@ var _BST = class _BST 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) {
+    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).
@@ -4419,20 +4632,33 @@ var _BST = class _BST extends BinaryTree {
     
     
     
-     * @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';
-    */
-  set(keyNodeOrEntry, value) {
-    const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
-    if (newNode === void 0) return false;
-    if (this._root === void 0) {
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @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';
+    */
+  set(keyNodeOrEntry, value) {
+    const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
+    if (newNode === void 0) return false;
+    if (this._root === void 0) {
       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;
@@ -4446,6 +4672,7 @@ var _BST = class _BST 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;
@@ -4454,6 +4681,7 @@ var _BST = class _BST 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;
@@ -4514,6 +4742,14 @@ var _BST = class _BST extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4801,6 +5037,10 @@ var _BST = class _BST extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -4866,6 +5106,10 @@ var _BST = class _BST extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -4976,6 +5220,14 @@ var _BST = class _BST extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5059,13 +5311,11 @@ var _BST = class _BST 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;
     };
@@ -5387,7 +5637,8 @@ var _BST = class _BST extends BinaryTree {
   _snapshotOptions() {
     return {
       ...super._snapshotOptions(),
-      comparator: this._comparator
+      comparator: this._comparator,
+      enableOrderStatistic: this._enableOrderStatistic
     };
   }
   /**
@@ -5409,6 +5660,113 @@ var _BST = class _BST 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;
@@ -5455,21 +5813,28 @@ var _BST = class _BST 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;
   }
@@ -5495,7 +5860,7 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
       }
     } else {
       if (!Number.isInteger(sizeOrElements) || sizeOrElements < 0) {
-        throw new RangeError(ERR.invalidArgument("size must be a non-negative integer", "BinaryIndexedTree"));
+        raise(RangeError, ERR.invalidArgument("size must be a non-negative integer", "BinaryIndexedTree"));
       }
       this._size = sizeOrElements;
       this._tree = new Array(this._size + 1).fill(0);
@@ -5550,6 +5915,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5618,6 +5991,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5686,6 +6067,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5754,6 +6143,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5820,6 +6217,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5893,6 +6298,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5943,6 +6356,10 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6000,6 +6417,10 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6074,10 +6495,10 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
   }
   _checkIndex(index) {
     if (!Number.isInteger(index)) {
-      throw new TypeError(ERR.invalidIndex("BinaryIndexedTree"));
+      raise(TypeError, ERR.invalidIndex("BinaryIndexedTree"));
     }
     if (index < 0 || index >= this._size) {
-      throw new RangeError(ERR.indexOutOfRange(index, 0, this._size - 1, "BinaryIndexedTree"));
+      raise(RangeError, ERR.indexOutOfRange(index, 0, this._size - 1, "BinaryIndexedTree"));
     }
   }
   /** Returns highest power of 2 <= n. */
@@ -6159,6 +6580,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6227,6 +6652,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6289,6 +6718,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6358,6 +6791,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6405,6 +6842,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6478,6 +6919,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6845,6 +7290,22 @@ var _AVLTree = class _AVLTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6961,6 +7422,18 @@ var _AVLTree = class _AVLTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7040,6 +7513,14 @@ var _AVLTree = class _AVLTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7160,6 +7641,18 @@ var _AVLTree = class _AVLTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7291,6 +7784,8 @@ var _AVLTree = class _AVLTree 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.
@@ -7336,6 +7831,9 @@ var _AVLTree = class _AVLTree 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).
@@ -7370,6 +7868,8 @@ var _AVLTree = class _AVLTree 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.
@@ -7413,6 +7913,9 @@ var _AVLTree = class _AVLTree 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.
@@ -7427,6 +7930,7 @@ var _AVLTree = class _AVLTree extends BST {
       const A = path[i];
       if (A) {
         this._updateHeight(A);
+        this._updateCount(A);
         switch (this._balanceFactor(A)) {
           case -2:
             if (A && A.left) {
@@ -7754,6 +8258,22 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7861,6 +8381,7 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     node.left = NIL;
     node.right = NIL;
     node.color = "RED";
+    this._updateCountAlongPath(node);
     this._insertFixup(node);
     if (this.isRealNode(this._root)) this._root.color = "BLACK";
   }
@@ -7971,6 +8492,7 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     newNode.left = NIL;
     newNode.right = NIL;
     newNode.color = "RED";
+    this._updateCountAlongPath(newNode);
     this._insertFixup(newNode);
     if (this.isRealNode(this._root)) this._root.color = "BLACK";
     else return void 0;
@@ -8214,6 +8736,22 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8414,16 +8952,32 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     
     
     
-     * @example
-  * // Remove and rebalance
-  *  const rbt = new RedBlackTree<number>([10, 5, 15, 3, 7]);
-  *     rbt.delete(5);
-  *     console.log(rbt.has(5)); // false;
-  *     console.log(rbt.size); // 4;
-    */
-  delete(keyNodeEntryRawOrPredicate) {
-    var _a, _b;
-    if (keyNodeEntryRawOrPredicate === null) return [];
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove and rebalance
+  *  const rbt = new RedBlackTree<number>([10, 5, 15, 3, 7]);
+  *     rbt.delete(5);
+  *     console.log(rbt.has(5)); // false;
+  *     console.log(rbt.size); // 4;
+    */
+  delete(keyNodeEntryRawOrPredicate) {
+    var _a, _b, _c;
+    if (keyNodeEntryRawOrPredicate === null) return [];
     const results = [];
     let nodeToDelete;
     if (this._isPredicate(keyNodeEntryRawOrPredicate)) nodeToDelete = this.getNode(keyNodeEntryRawOrPredicate);
@@ -8468,6 +9022,7 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     }
     if (this._isMapMode) this._store.delete(nodeToDelete.key);
     this._size--;
+    this._updateCountAlongPath((_c = replacementNode == null ? void 0 : replacementNode.parent) != null ? _c : replacementNode);
     if (this._size <= 0) {
       this._setMinCache(void 0);
       this._setMaxCache(void 0);
@@ -8574,6 +9129,18 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8706,6 +9273,22 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8809,6 +9392,7 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     node.left = NIL;
     node.right = NIL;
     node.color = "RED";
+    this._updateCountAlongPath(node);
     this._insertFixup(node);
     return "CREATED";
   }
@@ -8977,6 +9561,8 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     }
     y.left = x;
     x.parent = y;
+    this._updateCount(x);
+    this._updateCount(y);
   }
   /**
    * (Protected) Perform a right rotation around y.
@@ -9003,6 +9589,8 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     }
     x.right = y;
     y.parent = x;
+    this._updateCount(y);
+    this._updateCount(x);
   }
 };
 __name(_RedBlackTree, "RedBlackTree");
@@ -9035,7 +9623,7 @@ var _TreeSet = class _TreeSet {
     const toElementFn = options.toElementFn;
     const comparator = (_a = options.comparator) != null ? _a : _TreeSet.createDefaultComparator();
     __privateSet(this, _isDefaultComparator, options.comparator === void 0);
-    __privateSet(this, _core, new RedBlackTree([], { comparator, isMapMode: options.isMapMode }));
+    __privateSet(this, _core, new RedBlackTree([], { comparator, isMapMode: options.isMapMode, enableOrderStatistic: options.enableOrderStatistic }));
     for (const item of elements) {
       const k = toElementFn ? toElementFn(item) : item;
       this.add(k);
@@ -9054,7 +9642,7 @@ var _TreeSet = class _TreeSet {
   static createDefaultComparator() {
     return (a, b) => {
       if (typeof a === "number" && typeof b === "number") {
-        if (Number.isNaN(a) || Number.isNaN(b)) throw new TypeError(ERR.invalidNaN("TreeSet"));
+        if (Number.isNaN(a) || Number.isNaN(b)) raise(TypeError, ERR.invalidNaN("TreeSet"));
         const aa = Object.is(a, -0) ? 0 : a;
         const bb = Object.is(b, -0) ? 0 : b;
         return aa > bb ? 1 : aa < bb ? -1 : 0;
@@ -9065,10 +9653,10 @@ var _TreeSet = class _TreeSet {
       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("TreeSet"));
+        if (Number.isNaN(ta) || Number.isNaN(tb)) raise(TypeError, ERR.invalidDate("TreeSet"));
         return ta > tb ? 1 : ta < tb ? -1 : 0;
       }
-      throw new TypeError(ERR.comparatorRequired("TreeSet"));
+      raise(TypeError, ERR.comparatorRequired("TreeSet"));
     };
   }
   /**
@@ -9196,6 +9784,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9227,15 +9835,15 @@ var _TreeSet = class _TreeSet {
   _validateKey(key) {
     if (!__privateGet(this, _isDefaultComparator)) return;
     if (typeof key === "number") {
-      if (Number.isNaN(key)) throw new TypeError(ERR.invalidNaN("TreeSet"));
+      if (Number.isNaN(key)) raise(TypeError, ERR.invalidNaN("TreeSet"));
       return;
     }
     if (typeof key === "string") return;
     if (key instanceof Date) {
-      if (Number.isNaN(key.getTime())) throw new TypeError(ERR.invalidDate("TreeSet"));
+      if (Number.isNaN(key.getTime())) raise(TypeError, ERR.invalidDate("TreeSet"));
       return;
     }
-    throw new TypeError(ERR.comparatorRequired("TreeSet"));
+    raise(TypeError, ERR.comparatorRequired("TreeSet"));
   }
   /**
     * Add a key to the set (no-op if already present).
@@ -9360,6 +9968,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9529,6 +10157,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9693,6 +10341,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9847,6 +10515,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9996,6 +10684,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10146,6 +10854,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10296,6 +11024,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10449,6 +11197,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10602,6 +11370,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10779,8 +11567,28 @@ var _TreeSet = class _TreeSet {
     
     
     
-     * @example
-  * // Filter
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Filter
   *  const ts = new TreeSet<number>([1, 2, 3, 4, 5]);
   *       const evens = ts.filter(k => k % 2 === 0);
   *       console.log([...evens]); // [2, 4];
@@ -10914,6 +11722,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11065,6 +11893,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11217,6 +12065,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11369,6 +12237,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11524,6 +12412,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11673,6 +12581,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11731,6 +12659,10 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11795,6 +12727,10 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11837,6 +12773,10 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11884,6 +12824,10 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -12005,6 +12949,22 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12146,6 +13106,22 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12279,6 +13255,22 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12410,6 +13402,22 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12544,6 +13552,22 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12595,6 +13619,62 @@ var _TreeSet = class _TreeSet {
     }
     return out;
   }
+  // ─── Order-Statistic Methods ───────────────────────────
+  /**
+    * Returns the element at the k-th position in tree order (0-indexed).
+    * @remarks Time O(log n). Requires `enableOrderStatistic: true`.
+    
+    
+    
+     * @example
+  * // Find k-th element in a TreeSet
+  *  const set = new TreeSet<number>([30, 10, 50, 20, 40], { enableOrderStatistic: true });
+  *       console.log(set.getByRank(0)); // 10;
+  *       console.log(set.getByRank(2)); // 30;
+  *       console.log(set.getRank(30)); // 2;
+    */
+  getByRank(k) {
+    return __privateGet(this, _core).getByRank(k);
+  }
+  /**
+    * Returns the 0-based rank of a key (number of elements that precede it in tree order).
+    * @remarks Time O(log n). Requires `enableOrderStatistic: true`.
+     * @example
+  * // Get the rank of a key in sorted order
+  *  const tree = new TreeSet<number>(
+  *         [10, 20, 30, 40, 50],
+  *         { enableOrderStatistic: true }
+  *       );
+  *       console.log(tree.getRank(10)); // 0;  // smallest → rank 0
+  *       console.log(tree.getRank(30)); // 2;  // 2 elements before 30 in tree order
+  *       console.log(tree.getRank(50)); // 4;  // largest → rank 4
+  *       console.log(tree.getRank(25)); // 2;
+    */
+  getRank(key) {
+    return __privateGet(this, _core).getRank(key);
+  }
+  /**
+    * Returns elements by rank range (0-indexed, inclusive on both ends).
+    * @remarks Time O(log n + k). Requires `enableOrderStatistic: true`.
+    
+     * @example
+  * // Pagination with rangeByRank
+  *  const tree = new TreeSet<number>(
+  *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
+  *         { enableOrderStatistic: true }
+  *       );
+  *       const pageSize = 3;
+  *
+  *       // Page 1
+  *       console.log(tree.rangeByRank(0, pageSize - 1)); // [10, 20, 30];
+  *       // Page 2
+  *       console.log(tree.rangeByRank(pageSize, 2 * pageSize - 1)); // [40, 50, 60];
+  *       // Page 3
+  *       console.log(tree.rangeByRank(2 * pageSize, 3 * pageSize - 1)); // [70, 80, 90];
+    */
+  rangeByRank(start, end) {
+    return __privateGet(this, _core).rangeByRank(start, end).filter((k) => k !== void 0);
+  }
   /**
     * Creates a shallow clone of this set.
     * @remarks Time O(n log n), Space O(n)
@@ -12737,7 +13817,27 @@ var _TreeSet = class _TreeSet {
     
     
     
-     * @example
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
   * // Deep clone
   *  const ts = new TreeSet<number>([1, 2, 3]);
   *       const copy = ts.clone();
@@ -12780,7 +13880,7 @@ var _TreeMultiMap = class _TreeMultiMap {
     const comparator = (_a = options.comparator) != null ? _a : TreeSet.createDefaultComparator();
     __privateSet(this, _isDefaultComparator2, options.comparator === void 0);
     const toEntryFn = options.toEntryFn;
-    __privateSet(this, _core2, new RedBlackTree([], { ...options, comparator, isMapMode: options.isMapMode }));
+    __privateSet(this, _core2, new RedBlackTree([], { ...options, comparator, isMapMode: options.isMapMode, enableOrderStatistic: options.enableOrderStatistic }));
     for (const x of keysNodesEntriesOrRaws) {
       if (x === null || x === void 0) continue;
       if (toEntryFn) {
@@ -12813,15 +13913,15 @@ var _TreeMultiMap = class _TreeMultiMap {
   _validateKey(key) {
     if (!__privateGet(this, _isDefaultComparator2)) return;
     if (typeof key === "number") {
-      if (Number.isNaN(key)) throw new TypeError(ERR.invalidNaN("TreeMultiMap"));
+      if (Number.isNaN(key)) raise(TypeError, ERR.invalidNaN("TreeMultiMap"));
       return;
     }
     if (typeof key === "string") return;
     if (key instanceof Date) {
-      if (Number.isNaN(key.getTime())) throw new TypeError(ERR.invalidDate("TreeMultiMap"));
+      if (Number.isNaN(key.getTime())) raise(TypeError, ERR.invalidDate("TreeMultiMap"));
       return;
     }
-    throw new TypeError(ERR.comparatorRequired("TreeMultiMap"));
+    raise(TypeError, ERR.comparatorRequired("TreeMultiMap"));
   }
   /**
    * Number of distinct keys.
@@ -12950,6 +14050,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13098,6 +14218,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13149,6 +14289,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13185,6 +14329,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13357,6 +14505,30 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13543,6 +14715,30 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13689,6 +14885,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13900,6 +15116,30 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13953,6 +15193,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13990,6 +15234,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14032,6 +15280,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14192,6 +15444,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14343,6 +15615,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14395,6 +15687,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14432,6 +15728,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14469,6 +15769,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14536,6 +15840,14 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14609,6 +15921,14 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14655,6 +15975,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14696,6 +16020,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14859,13 +16187,33 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
-     * @example
-  * // Least key ≥ target
-  *  const mm = new TreeMultiMap<number, string>();
-  *       mm.add(10, 'a');
-  *       mm.add(20, 'b');
-  *       mm.add(30, 'c');
-  *       console.log(mm.ceiling(15)?.[0]); // 20;
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Least key ≥ target
+  *  const mm = new TreeMultiMap<number, string>();
+  *       mm.add(10, 'a');
+  *       mm.add(20, 'b');
+  *       mm.add(30, 'c');
+  *       console.log(mm.ceiling(15)?.[0]); // 20;
     */
   ceiling(key) {
     this._validateKey(key);
@@ -15000,6 +16348,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15135,6 +16503,22 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15265,6 +16649,22 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15420,6 +16820,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15570,6 +16990,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15725,6 +17165,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15882,6 +17342,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16037,6 +17517,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16185,6 +17685,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16315,6 +17835,22 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16482,6 +18018,85 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Order-statistic on BST
+  *  const tree = new TreeMultiMap<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;
+    */
+  // ─── Order-Statistic Methods ───────────────────────────
+  getByRank(k) {
+    var _a;
+    const key = __privateGet(this, _core2).getByRank(k);
+    if (key === void 0) return void 0;
+    return [key, (_a = __privateGet(this, _core2).get(key)) != null ? _a : []];
+  }
+  /**
+    * Get the rank of a key in sorted order
+    * @example
+  * // Get the rank of a key in sorted order
+  *  const tree = new TreeMultiMap<number>(
+  *         [10, 20, 30, 40, 50],
+  *         { enableOrderStatistic: true }
+  *       );
+  *       console.log(tree.getRank(10)); // 0;  // smallest → rank 0
+  *       console.log(tree.getRank(30)); // 2;  // 2 elements before 30 in tree order
+  *       console.log(tree.getRank(50)); // 4;  // largest → rank 4
+  *       console.log(tree.getRank(25)); // 2;
+    */
+  getRank(key) {
+    return __privateGet(this, _core2).getRank(key);
+  }
+  /**
+    * Get elements by rank range
+   
+     * @example
+  * // Pagination with rangeByRank
+  *  const tree = new TreeMultiMap<number>(
+  *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
+  *         { enableOrderStatistic: true }
+  *       );
+  *       const pageSize = 3;
+  *
+  *       // Page 1
+  *       console.log(tree.rangeByRank(0, pageSize - 1)); // [10, 20, 30];
+  *       // Page 2
+  *       console.log(tree.rangeByRank(pageSize, 2 * pageSize - 1)); // [40, 50, 60];
+  *       // Page 3
+  *       console.log(tree.rangeByRank(2 * pageSize, 3 * pageSize - 1)); // [70, 80, 90];
+    */
+  rangeByRank(start, end) {
+    const keys = __privateGet(this, _core2).rangeByRank(start, end);
+    return keys.filter((k) => k !== void 0).map((k) => {
+      var _a;
+      return [k, (_a = __privateGet(this, _core2).get(k)) != null ? _a : []];
+    });
+  }
+  /**
+    * Deep copy
+   
     
     
     
@@ -16536,7 +18151,7 @@ var _TreeMap = class _TreeMap {
     const toEntryFn = options.toEntryFn;
     const comparator = (_a = options.comparator) != null ? _a : _TreeMap.createDefaultComparator();
     __privateSet(this, _isDefaultComparator3, options.comparator === void 0);
-    __privateSet(this, _core3, new RedBlackTree([], { comparator, isMapMode: options.isMapMode }));
+    __privateSet(this, _core3, new RedBlackTree([], { comparator, isMapMode: options.isMapMode, enableOrderStatistic: options.enableOrderStatistic }));
     for (const item of entries) {
       let k;
       let v;
@@ -16544,7 +18159,7 @@ var _TreeMap = class _TreeMap {
         [k, v] = toEntryFn(item);
       } else {
         if (!Array.isArray(item) || item.length < 2) {
-          throw new TypeError(ERR.invalidEntry("TreeMap"));
+          raise(TypeError, ERR.invalidEntry("TreeMap"));
         }
         k = item[0];
         v = item[1];
@@ -16565,7 +18180,7 @@ var _TreeMap = class _TreeMap {
   static createDefaultComparator() {
     return (a, b) => {
       if (typeof a === "number" && typeof b === "number") {
-        if (Number.isNaN(a) || Number.isNaN(b)) throw new TypeError(ERR.invalidNaN("TreeMap"));
+        if (Number.isNaN(a) || Number.isNaN(b)) raise(TypeError, ERR.invalidNaN("TreeMap"));
         const aa = Object.is(a, -0) ? 0 : a;
         const bb = Object.is(b, -0) ? 0 : b;
         return aa > bb ? 1 : aa < bb ? -1 : 0;
@@ -16576,24 +18191,24 @@ var _TreeMap = class _TreeMap {
       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("TreeMap"));
+        if (Number.isNaN(ta) || Number.isNaN(tb)) raise(TypeError, ERR.invalidDate("TreeMap"));
         return ta > tb ? 1 : ta < tb ? -1 : 0;
       }
-      throw new TypeError(ERR.comparatorRequired("TreeMap"));
+      raise(TypeError, ERR.comparatorRequired("TreeMap"));
     };
   }
   _validateKey(key) {
     if (!__privateGet(this, _isDefaultComparator3)) return;
     if (typeof key === "number") {
-      if (Number.isNaN(key)) throw new TypeError(ERR.invalidNaN("TreeMap"));
+      if (Number.isNaN(key)) raise(TypeError, ERR.invalidNaN("TreeMap"));
       return;
     }
     if (typeof key === "string") return;
     if (key instanceof Date) {
-      if (Number.isNaN(key.getTime())) throw new TypeError(ERR.invalidDate("TreeMap"));
+      if (Number.isNaN(key.getTime())) raise(TypeError, ERR.invalidDate("TreeMap"));
       return;
     }
-    throw new TypeError(ERR.comparatorRequired("TreeMap"));
+    raise(TypeError, ERR.comparatorRequired("TreeMap"));
   }
   /**
    * Number of entries in the map.
@@ -16741,11 +18356,31 @@ var _TreeMap = class _TreeMap {
     
     
     
-     * @example
-  * // Check empty
-  *  console.log(new TreeMap().isEmpty()); // true;
-    */
-  isEmpty() {
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check empty
+  *  console.log(new TreeMap().isEmpty()); // true;
+    */
+  isEmpty() {
     return this.size === 0;
   }
   /**
@@ -16877,6 +18512,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17055,6 +18710,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17223,6 +18898,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17391,6 +19086,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17550,6 +19265,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17699,6 +19434,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17852,6 +19607,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18002,6 +19777,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18155,6 +19950,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18308,6 +20123,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18464,6 +20299,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18641,17 +20496,37 @@ var _TreeMap = class _TreeMap {
     
     
     
-     * @example
-  * // Aggregate values
-  *  const tm = new TreeMap<number, number>([[1, 10], [2, 20]]);
-  *       console.log(tm.reduce((acc, v) => acc + (v ?? 0), 0)); // 30;
-    */
-  reduce(callbackfn, initialValue) {
-    let acc = initialValue;
-    let index = 0;
-    for (const [k, v] of this) acc = callbackfn(acc, v, k, index++, this);
-    return acc;
-  }
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Aggregate values
+  *  const tm = new TreeMap<number, number>([[1, 10], [2, 20]]);
+  *       console.log(tm.reduce((acc, v) => acc + (v ?? 0), 0)); // 30;
+    */
+  reduce(callbackfn, initialValue) {
+    let acc = initialValue;
+    let index = 0;
+    for (const [k, v] of this) acc = callbackfn(acc, v, k, index++, this);
+    return acc;
+  }
   /**
     * Test whether all entries satisfy a predicate.
     * @remarks Time O(n), Space O(1)
@@ -18770,6 +20645,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18922,6 +20817,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19075,6 +20990,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19229,6 +21164,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19378,6 +21333,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19437,6 +21412,10 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19501,6 +21480,10 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19549,6 +21532,10 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19601,6 +21588,10 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19728,6 +21719,22 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19885,6 +21892,22 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20026,6 +22049,22 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20167,6 +22206,22 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20309,6 +22364,22 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20373,6 +22444,68 @@ var _TreeMap = class _TreeMap {
     }
     return out;
   }
+  // ─── Order-Statistic Methods ───────────────────────────
+  /**
+    * Returns the entry at the k-th position in tree order (0-indexed).
+    * @remarks Time O(log n). Requires `enableOrderStatistic: true`.
+    
+    
+    
+     * @example
+  * // Find k-th entry in a TreeMap
+  *  const map = new TreeMap<string, number>(
+  *         [['alice', 95], ['bob', 87], ['charlie', 92]],
+  *         { enableOrderStatistic: true }
+  *       );
+  *       console.log(map.getByRank(0)); // 'alice';
+  *       console.log(map.getByRank(1)); // 'bob';
+  *       console.log(map.getByRank(2)); // 'charlie';
+    */
+  getByRank(k) {
+    const key = __privateGet(this, _core3).getByRank(k);
+    if (key === void 0) return void 0;
+    return [key, __privateGet(this, _core3).get(key)];
+  }
+  /**
+    * Returns the 0-based rank of a key (number of elements that precede it in tree order).
+    * @remarks Time O(log n). Requires `enableOrderStatistic: true`.
+     * @example
+  * // Get the rank of a key in sorted order
+  *  const tree = new TreeMap<number>(
+  *         [10, 20, 30, 40, 50],
+  *         { enableOrderStatistic: true }
+  *       );
+  *       console.log(tree.getRank(10)); // 0;  // smallest → rank 0
+  *       console.log(tree.getRank(30)); // 2;  // 2 elements before 30 in tree order
+  *       console.log(tree.getRank(50)); // 4;  // largest → rank 4
+  *       console.log(tree.getRank(25)); // 2;
+    */
+  getRank(key) {
+    return __privateGet(this, _core3).getRank(key);
+  }
+  /**
+    * Returns keys by rank range (0-indexed, inclusive on both ends).
+    * @remarks Time O(log n + k). Requires `enableOrderStatistic: true`.
+    
+     * @example
+  * // Pagination with rangeByRank
+  *  const tree = new TreeMap<number>(
+  *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
+  *         { enableOrderStatistic: true }
+  *       );
+  *       const pageSize = 3;
+  *
+  *       // Page 1
+  *       console.log(tree.rangeByRank(0, pageSize - 1)); // [10, 20, 30];
+  *       // Page 2
+  *       console.log(tree.rangeByRank(pageSize, 2 * pageSize - 1)); // [40, 50, 60];
+  *       // Page 3
+  *       console.log(tree.rangeByRank(2 * pageSize, 3 * pageSize - 1)); // [70, 80, 90];
+    */
+  rangeByRank(start, end) {
+    const keys = __privateGet(this, _core3).rangeByRank(start, end);
+    return keys.filter((k) => k !== void 0).map((k) => [k, __privateGet(this, _core3).get(k)]);
+  }
   /**
     * Creates a shallow clone of this map.
     * @remarks Time O(n log n), Space O(n)
@@ -20515,17 +22648,37 @@ var _TreeMap = class _TreeMap {
     
     
     
-     * @example
-  * // Deep clone
-  *  const tm = new TreeMap<number, string>([[1, 'a'], [2, 'b']]);
-  *       const copy = tm.clone();
-  *       copy.delete(1);
-  *       console.log(tm.has(1)); // true;
-    */
-  clone() {
-    return new _TreeMap(this, {
-      comparator: __privateGet(this, _isDefaultComparator3) ? void 0 : __privateGet(this, _userComparator2),
-      isMapMode: __privateGet(this, _core3).isMapMode
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Deep clone
+  *  const tm = new TreeMap<number, string>([[1, 'a'], [2, 'b']]);
+  *       const copy = tm.clone();
+  *       copy.delete(1);
+  *       console.log(tm.has(1)); // true;
+    */
+  clone() {
+    return new _TreeMap(this, {
+      comparator: __privateGet(this, _isDefaultComparator3) ? void 0 : __privateGet(this, _userComparator2),
+      isMapMode: __privateGet(this, _core3).isMapMode
     });
   }
 };
@@ -20560,7 +22713,7 @@ var _TreeMultiSet = class _TreeMultiSet {
     const toElementFn = options.toElementFn;
     const comparator = (_a = options.comparator) != null ? _a : TreeSet.createDefaultComparator();
     __privateSet(this, _isDefaultComparator4, options.comparator === void 0);
-    __privateSet(this, _core4, new RedBlackTree([], { comparator, isMapMode: options.isMapMode }));
+    __privateSet(this, _core4, new RedBlackTree([], { comparator, isMapMode: options.isMapMode, enableOrderStatistic: options.enableOrderStatistic }));
     for (const item of elements) {
       const k = toElementFn ? toElementFn(item) : item;
       this.add(k);
@@ -20573,22 +22726,22 @@ var _TreeMultiSet = class _TreeMultiSet {
   _validateKey(key) {
     if (!__privateGet(this, _isDefaultComparator4)) return;
     if (typeof key === "number") {
-      if (Number.isNaN(key)) throw new TypeError(ERR.invalidNaN("TreeMultiSet"));
+      if (Number.isNaN(key)) raise(TypeError, ERR.invalidNaN("TreeMultiSet"));
       return;
     }
     if (typeof key === "string") return;
     if (key instanceof Date) {
-      if (Number.isNaN(key.getTime())) throw new TypeError(ERR.invalidDate("TreeMultiSet"));
+      if (Number.isNaN(key.getTime())) raise(TypeError, ERR.invalidDate("TreeMultiSet"));
       return;
     }
-    throw new TypeError(ERR.comparatorRequired("TreeMultiSet"));
+    raise(TypeError, ERR.comparatorRequired("TreeMultiSet"));
   }
   /**
    * Validates that count is a non-negative safe integer.
    * @remarks Time O(1), Space O(1)
    */
   _validateCount(n) {
-    if (!Number.isSafeInteger(n) || n < 0) throw new RangeError(ERR.invalidArgument("count must be a safe integer >= 0.", "TreeMultiSet"));
+    if (!Number.isSafeInteger(n) || n < 0) raise(RangeError, ERR.invalidArgument("count must be a safe integer >= 0.", "TreeMultiSet"));
   }
   /**
    * Total occurrences (sumCounts).
@@ -20617,6 +22770,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -20752,6 +22909,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20903,6 +23080,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20955,6 +23152,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21086,6 +23287,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21148,6 +23369,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21297,6 +23522,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21360,6 +23605,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21401,6 +23650,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21536,6 +23789,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21697,6 +23970,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21748,6 +24041,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21783,6 +24080,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21927,6 +24228,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21981,6 +24302,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22017,6 +24342,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22053,6 +24382,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22093,6 +24426,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22207,6 +24544,22 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22332,6 +24685,22 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22457,6 +24826,22 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22581,6 +24966,22 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22731,6 +25132,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22887,6 +25308,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23050,6 +25491,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23208,6 +25669,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23387,6 +25868,78 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Order-statistic on BST
+  *  const tree = new TreeMultiSet<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;
+    */
+  // ─── Order-Statistic Methods ───────────────────────────
+  getByRank(k) {
+    return __privateGet(this, _core4).getByRank(k);
+  }
+  /**
+    * Get the rank of a key in sorted order
+    * @example
+  * // Get the rank of a key in sorted order
+  *  const tree = new TreeMultiSet<number>(
+  *         [10, 20, 30, 40, 50],
+  *         { enableOrderStatistic: true }
+  *       );
+  *       console.log(tree.getRank(10)); // 0;  // smallest → rank 0
+  *       console.log(tree.getRank(30)); // 2;  // 2 elements before 30 in tree order
+  *       console.log(tree.getRank(50)); // 4;  // largest → rank 4
+  *       console.log(tree.getRank(25)); // 2;
+    */
+  getRank(key) {
+    return __privateGet(this, _core4).getRank(key);
+  }
+  /**
+    * Get elements by rank range
+   
+     * @example
+  * // Pagination with rangeByRank
+  *  const tree = new TreeMultiSet<number>(
+  *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
+  *         { enableOrderStatistic: true }
+  *       );
+  *       const pageSize = 3;
+  *
+  *       // Page 1
+  *       console.log(tree.rangeByRank(0, pageSize - 1)); // [10, 20, 30];
+  *       // Page 2
+  *       console.log(tree.rangeByRank(pageSize, 2 * pageSize - 1)); // [40, 50, 60];
+  *       // Page 3
+  *       console.log(tree.rangeByRank(2 * pageSize, 3 * pageSize - 1)); // [70, 80, 90];
+    */
+  rangeByRank(start, end) {
+    return __privateGet(this, _core4).rangeByRank(start, end).filter((k) => k !== void 0);
+  }
+  /**
+    * Deep copy
+   
     
     
     
@@ -23505,6 +26058,22 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23656,6 +26225,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+