data-structure-typed 2.5.1 → 2.5.2

package/dist/esm-legacy/binary-tree.mjs

@@ -66,6 +66,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 {
   /**
@@ -88,7 +137,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");
     }
   }
   /**
@@ -244,7 +293,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;
     }
@@ -480,49 +529,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 {
   /**
@@ -787,6 +793,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -833,6 +843,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -895,6 +909,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -953,6 +971,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1018,6 +1040,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1073,6 +1099,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1121,6 +1151,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1210,6 +1244,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1252,6 +1290,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1317,6 +1359,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1366,6 +1412,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1419,6 +1469,10 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1692,7 +1746,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);
   }
@@ -1923,6 +1977,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1973,6 +2031,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2075,6 +2137,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2113,6 +2179,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2172,6 +2242,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2230,6 +2304,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2366,6 +2444,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2420,6 +2502,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2477,6 +2563,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2521,6 +2611,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2574,6 +2668,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2654,6 +2752,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2711,6 +2813,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3184,6 +3290,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3232,6 +3342,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3284,6 +3398,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3361,6 +3479,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3984,6 +4106,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.
     
@@ -3996,6 +4119,9 @@ var _BST = class _BST extends BinaryTree {
       } else {
         this._comparator = this._createDefaultComparator();
       }
+      if (options.enableOrderStatistic) {
+        this._enableOrderStatistic = true;
+      }
     } else {
       this._comparator = this._createDefaultComparator();
     }
@@ -4161,6 +4287,14 @@ var _BST = class _BST extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4325,6 +4459,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).
@@ -4417,20 +4630,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;
@@ -4444,6 +4670,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;
@@ -4452,6 +4679,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;
@@ -4512,6 +4740,14 @@ var _BST = class _BST extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4799,6 +5035,10 @@ var _BST = class _BST extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -4864,6 +5104,10 @@ var _BST = class _BST extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -4974,6 +5218,14 @@ var _BST = class _BST extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5057,13 +5309,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;
     };
@@ -5385,7 +5635,8 @@ var _BST = class _BST extends BinaryTree {
   _snapshotOptions() {
     return {
       ...super._snapshotOptions(),
-      comparator: this._comparator
+      comparator: this._comparator,
+      enableOrderStatistic: this._enableOrderStatistic
     };
   }
   /**
@@ -5407,6 +5658,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;
@@ -5453,21 +5811,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;
   }
@@ -5493,7 +5858,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);
@@ -5548,6 +5913,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5616,6 +5989,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5684,6 +6065,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5752,6 +6141,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5818,6 +6215,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5891,6 +6296,14 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5941,6 +6354,10 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -5998,6 +6415,10 @@ var _BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6072,10 +6493,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. */
@@ -6157,6 +6578,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6225,6 +6650,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6287,6 +6716,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6356,6 +6789,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6403,6 +6840,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6476,6 +6917,10 @@ var _SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6843,6 +7288,22 @@ var _AVLTree = class _AVLTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6959,6 +7420,18 @@ var _AVLTree = class _AVLTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7038,6 +7511,14 @@ var _AVLTree = class _AVLTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7158,6 +7639,18 @@ var _AVLTree = class _AVLTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7289,6 +7782,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.
@@ -7334,6 +7829,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).
@@ -7368,6 +7866,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.
@@ -7411,6 +7911,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.
@@ -7425,6 +7928,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) {
@@ -7752,6 +8256,22 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7859,6 +8379,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";
   }
@@ -7969,6 +8490,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;
@@ -8212,6 +8734,22 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8412,16 +8950,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);
@@ -8466,6 +9020,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);
@@ -8572,6 +9127,18 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8704,6 +9271,22 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8807,6 +9390,7 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     node.left = NIL;
     node.right = NIL;
     node.color = "RED";
+    this._updateCountAlongPath(node);
     this._insertFixup(node);
     return "CREATED";
   }
@@ -8975,6 +9559,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.
@@ -9001,6 +9587,8 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     }
     x.right = y;
     y.parent = x;
+    this._updateCount(y);
+    this._updateCount(x);
   }
 };
 __name(_RedBlackTree, "RedBlackTree");
@@ -9033,7 +9621,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);
@@ -9052,7 +9640,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;
@@ -9063,10 +9651,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"));
     };
   }
   /**
@@ -9194,6 +9782,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9225,15 +9833,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).
@@ -9358,6 +9966,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9527,6 +10155,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9691,6 +10339,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9845,6 +10513,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9994,6 +10682,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10144,6 +10852,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10294,6 +11022,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10447,6 +11195,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10600,6 +11368,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10777,8 +11565,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];
@@ -10912,6 +11720,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11063,6 +11891,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11215,6 +12063,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11367,6 +12235,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11522,6 +12410,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11671,6 +12579,26 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11729,6 +12657,10 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11793,6 +12725,10 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11835,6 +12771,10 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11882,6 +12822,10 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -12003,6 +12947,22 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12144,6 +13104,22 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12277,6 +13253,22 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12408,6 +13400,22 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12542,6 +13550,22 @@ var _TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12593,6 +13617,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)
@@ -12735,7 +13815,27 @@ var _TreeSet = class _TreeSet {
     
     
     
-     * @example
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
   * // Deep clone
   *  const ts = new TreeSet<number>([1, 2, 3]);
   *       const copy = ts.clone();
@@ -12778,7 +13878,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) {
@@ -12811,15 +13911,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.
@@ -12948,6 +14048,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13096,6 +14216,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13147,6 +14287,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13183,6 +14327,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13355,6 +14503,30 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13541,6 +14713,30 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13687,6 +14883,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13898,6 +15114,30 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13951,6 +15191,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13988,6 +15232,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14030,6 +15278,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14190,6 +15442,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14341,6 +15613,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14393,6 +15685,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14430,6 +15726,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14467,6 +15767,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14534,6 +15838,14 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14607,6 +15919,14 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14653,6 +15973,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14694,6 +16018,10 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14857,13 +16185,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);
@@ -14998,6 +16346,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15133,6 +16501,22 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15263,6 +16647,22 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15418,6 +16818,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15568,6 +16988,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15723,6 +17163,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15880,6 +17340,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16035,6 +17515,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16183,6 +17683,26 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16313,6 +17833,22 @@ var _TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16480,6 +18016,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
+   
     
     
     
@@ -16534,7 +18149,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;
@@ -16542,7 +18157,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];
@@ -16563,7 +18178,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;
@@ -16574,24 +18189,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.
@@ -16739,11 +18354,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;
   }
   /**
@@ -16875,6 +18510,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17053,6 +18708,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17221,6 +18896,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17389,6 +19084,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17548,6 +19263,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17697,6 +19432,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17850,6 +19605,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18000,6 +19775,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18153,6 +19948,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18306,6 +20121,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18462,6 +20297,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18639,17 +20494,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)
@@ -18768,6 +20643,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18920,6 +20815,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19073,6 +20988,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19227,6 +21162,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19376,6 +21331,26 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19435,6 +21410,10 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19499,6 +21478,10 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19547,6 +21530,10 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19599,6 +21586,10 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19726,6 +21717,22 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19883,6 +21890,22 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20024,6 +22047,22 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20165,6 +22204,22 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20307,6 +22362,22 @@ var _TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20371,6 +22442,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)
@@ -20513,17 +22646,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
     });
   }
 };
@@ -20558,7 +22711,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);
@@ -20571,22 +22724,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).
@@ -20615,6 +22768,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -20750,6 +22907,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20901,6 +23078,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20953,6 +23150,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21084,6 +23285,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21146,6 +23367,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21295,6 +23520,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21358,6 +23603,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21399,6 +23648,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21534,6 +23787,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21695,6 +23968,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21746,6 +24039,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21781,6 +24078,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21925,6 +24226,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21979,6 +24300,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22015,6 +24340,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22051,6 +24380,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22091,6 +24424,10 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22205,6 +24542,22 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22330,6 +24683,22 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22455,6 +24824,22 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22579,6 +24964,22 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22729,6 +25130,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22885,6 +25306,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23048,6 +25489,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23206,6 +25667,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23385,6 +25866,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
+   
     
     
     
@@ -23503,6 +26056,22 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23654,6 +26223,26 @@ var _TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+