data-structure-typed 2.5.1 → 2.5.2

package/dist/cjs/binary-tree.cjs

@@ -59,6 +59,56 @@ function makeTrampoline(fn) {
 }
 __name(makeTrampoline, "makeTrampoline");
 
+// src/common/error.ts
+function raise(ErrorClass, message) {
+  throw new ErrorClass(message);
+}
+__name(raise, "raise");
+var ERR = {
+  // Range / index
+  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
+  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
+  // Type / argument
+  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
+  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
+  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
+  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
+  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
+  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
+  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
+  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
+  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
+  // State / operation
+  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
+  // Matrix
+  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
+  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
+  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
+  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
+  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch"),
+  // Order statistic
+  orderStatisticNotEnabled: /* @__PURE__ */ __name((method, ctx) => `${ctx ? ctx + ": " : ""}${method}() requires enableOrderStatistic: true.`, "orderStatisticNotEnabled")
+};
+
+// src/common/index.ts
+var Range = class {
+  constructor(low, high, includeLow = true, includeHigh = true) {
+    this.low = low;
+    this.high = high;
+    this.includeLow = includeLow;
+    this.includeHigh = includeHigh;
+  }
+  static {
+    __name(this, "Range");
+  }
+  // Determine whether a key is within the range
+  isInRange(key, comparator) {
+    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+    return lowCheck && highCheck;
+  }
+};
+
 // src/data-structures/base/iterable-element-base.ts
 var IterableElementBase = class {
   static {
@@ -77,7 +127,7 @@ var IterableElementBase = class {
     if (options) {
       const { toElementFn } = options;
       if (typeof toElementFn === "function") this._toElementFn = toElementFn;
-      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+      else if (toElementFn) raise(TypeError, "toElementFn must be a function type");
     }
   }
   /**
@@ -240,7 +290,7 @@ var IterableElementBase = class {
       acc = initialValue;
     } else {
       const first = iter.next();
-      if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+      if (first.done) raise(TypeError, "Reduce of empty structure with no initial value");
       acc = first.value;
       index = 1;
     }
@@ -475,50 +525,6 @@ var LinearBase = class _LinearBase extends IterableElementBase {
   }
 };
 
-// src/common/error.ts
-var ERR = {
-  // Range / index
-  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
-  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
-  // Type / argument
-  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
-  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
-  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
-  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
-  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
-  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
-  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
-  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
-  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
-  // State / operation
-  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
-  // Matrix
-  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
-  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
-  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
-  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
-  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch")
-};
-
-// src/common/index.ts
-var Range = class {
-  constructor(low, high, includeLow = true, includeHigh = true) {
-    this.low = low;
-    this.high = high;
-    this.includeLow = includeLow;
-    this.includeHigh = includeHigh;
-  }
-  static {
-    __name(this, "Range");
-  }
-  // Determine whether a key is within the range
-  isInRange(key, comparator) {
-    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-    return lowCheck && highCheck;
-  }
-};
-
 // src/data-structures/base/iterable-entry-base.ts
 var IterableEntryBase = class {
   static {
@@ -787,6 +793,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 {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1674,7 +1728,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);
   }
@@ -1915,6 +1969,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1965,6 +2023,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2067,6 +2129,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2105,6 +2171,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2164,6 +2234,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2222,6 +2296,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2358,6 +2436,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2412,6 +2494,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2468,6 +2554,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2512,6 +2602,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2565,6 +2659,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2645,6 +2743,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2702,6 +2804,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3175,6 +3281,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3223,6 +3333,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3275,6 +3389,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3352,6 +3470,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3988,12 +4110,16 @@ var BST = class extends BinaryTree {
       } else {
         this._comparator = this._createDefaultComparator();
       }
+      if (options.enableOrderStatistic) {
+        this._enableOrderStatistic = true;
+      }
     } else {
       this._comparator = this._createDefaultComparator();
     }
     if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
   _root = void 0;
+  _enableOrderStatistic = false;
   /**
    * Gets the root node of the tree.
    * @remarks Time O(1)
@@ -4159,6 +4285,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4322,6 +4456,84 @@ var BST = class extends BinaryTree {
     const searchRange = range instanceof Range ? range : new Range(range[0], range[1]);
     return this.search(searchRange, false, callback, startNode, iterationType);
   }
+  getByRank(k, callback = this._DEFAULT_NODE_CALLBACK, iterationType = this.iterationType) {
+    if (!this._enableOrderStatistic) {
+      raise(Error, ERR.orderStatisticNotEnabled("getByRank"));
+    }
+    if (k < 0 || k >= this._size) return void 0;
+    let actualCallback = void 0;
+    let actualIterationType = this.iterationType;
+    if (typeof callback === "string") {
+      actualIterationType = callback;
+    } else if (callback) {
+      actualCallback = callback;
+      if (iterationType) {
+        actualIterationType = iterationType;
+      }
+    }
+    const node = actualIterationType === "RECURSIVE" ? this._getByRankRecursive(this._root, k) : this._getByRankIterative(this._root, k);
+    if (!node) return void 0;
+    return actualCallback ? actualCallback(node) : node.key;
+  }
+  getRank(keyNodeEntryOrPredicate, iterationType = this.iterationType) {
+    if (!this._enableOrderStatistic) {
+      raise(Error, ERR.orderStatisticNotEnabled("getRank"));
+    }
+    if (!this._root || this._size === 0) return -1;
+    let actualIterationType = this.iterationType;
+    if (iterationType) actualIterationType = iterationType;
+    let key;
+    if (typeof keyNodeEntryOrPredicate === "function") {
+      const results = this.search(keyNodeEntryOrPredicate, true);
+      if (results.length === 0 || results[0] === void 0) return -1;
+      key = results[0];
+    } else if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) {
+      return -1;
+    } else if (this.isNode(keyNodeEntryOrPredicate)) {
+      key = keyNodeEntryOrPredicate.key;
+    } else if (Array.isArray(keyNodeEntryOrPredicate)) {
+      key = keyNodeEntryOrPredicate[0] ?? void 0;
+      if (key === void 0 || key === null) return -1;
+    } else {
+      key = keyNodeEntryOrPredicate;
+    }
+    if (key === void 0) return -1;
+    return actualIterationType === "RECURSIVE" ? this._getRankRecursive(this._root, key) : this._getRankIterative(this._root, key);
+  }
+  rangeByRank(start, end, callback = this._DEFAULT_NODE_CALLBACK, iterationType = this.iterationType) {
+    if (!this._enableOrderStatistic) {
+      raise(Error, ERR.orderStatisticNotEnabled("rangeByRank"));
+    }
+    if (this._size === 0) return [];
+    const lo = Math.max(0, start);
+    const hi = Math.min(this._size - 1, end);
+    if (lo > hi) return [];
+    let actualCallback = void 0;
+    let actualIterationType = this.iterationType;
+    if (typeof callback === "string") {
+      actualIterationType = callback;
+    } else if (callback) {
+      actualCallback = callback;
+      if (iterationType) {
+        actualIterationType = iterationType;
+      }
+    }
+    const results = [];
+    const count = hi - lo + 1;
+    const startNode = actualIterationType === "RECURSIVE" ? this._getByRankRecursive(this._root, lo) : this._getByRankIterative(this._root, lo);
+    if (!startNode) return [];
+    let collected = 0;
+    const cb = actualCallback ?? this._DEFAULT_NODE_CALLBACK;
+    let current = startNode;
+    while (current && collected < count) {
+      results.push(cb(current));
+      collected++;
+      if (collected < count) {
+        current = this._next(current);
+      }
+    }
+    return results;
+  }
   /**
     * Adds a new node to the BST based on key comparison.
     * @remarks Time O(log N), where H is tree height. O(N) worst-case (unbalanced tree), O(log N) average. Space O(1).
@@ -4414,20 +4626,33 @@ var BST = class 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;
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @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;
@@ -4441,6 +4666,7 @@ var BST = class extends BinaryTree {
           current.left = newNode;
           if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
+          this._updateCountAlongPath(newNode);
           return true;
         }
         if (current.left !== null) current = current.left;
@@ -4449,6 +4675,7 @@ var BST = class extends BinaryTree {
           current.right = newNode;
           if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
+          this._updateCountAlongPath(newNode);
           return true;
         }
         if (current.right !== null) current = current.right;
@@ -4509,6 +4736,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4796,6 +5031,10 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -4861,6 +5100,10 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -4971,6 +5214,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5054,13 +5305,11 @@ var BST = class extends BinaryTree {
       if (a instanceof Date && b instanceof Date) {
         const ta = a.getTime();
         const tb = b.getTime();
-        if (Number.isNaN(ta) || Number.isNaN(tb)) throw new TypeError(ERR.invalidDate("BST"));
+        if (Number.isNaN(ta) || Number.isNaN(tb)) raise(TypeError, ERR.invalidDate("BST"));
         return ta > tb ? 1 : ta < tb ? -1 : 0;
       }
       if (typeof a === "object" || typeof b === "object") {
-        throw new TypeError(
-          ERR.comparatorRequired("BST")
-        );
+        raise(TypeError, ERR.comparatorRequired("BST"));
       }
       return 0;
     };
@@ -5379,7 +5628,8 @@ var BST = class extends BinaryTree {
   _snapshotOptions() {
     return {
       ...super._snapshotOptions(),
-      comparator: this._comparator
+      comparator: this._comparator,
+      enableOrderStatistic: this._enableOrderStatistic
     };
   }
   /**
@@ -5401,6 +5651,113 @@ var BST = class extends BinaryTree {
    *
    * @param v - The node to set as root.
    */
+  /**
+   * (Protected) Recalculates the subtree count for a single node.
+   * @remarks Time O(1). Only active when enableOrderStatistic is true.
+   */
+  _updateCount(node) {
+    if (!this._enableOrderStatistic) return;
+    node._count = 1 + (this.isRealNode(node.left) ? node.left._count : 0) + (this.isRealNode(node.right) ? node.right._count : 0);
+  }
+  /**
+   * (Protected) Updates subtree counts from a node up to the root.
+   * @remarks Time O(log n). Only active when enableOrderStatistic is true.
+   */
+  _updateCountAlongPath(node) {
+    if (!this._enableOrderStatistic) return;
+    let current = node;
+    while (current) {
+      this._updateCount(current);
+      current = current.parent;
+    }
+  }
+  /**
+   * (Protected) Finds the node at position k in tree order (iterative).
+   * @remarks Time O(log n), Space O(1)
+   */
+  _getByRankIterative(node, k) {
+    let current = node;
+    let remaining = k;
+    while (current) {
+      const leftCount = this.isRealNode(current.left) ? current.left._count : 0;
+      if (remaining < leftCount) {
+        current = current.left;
+      } else if (remaining === leftCount) {
+        return current;
+      } else {
+        remaining = remaining - leftCount - 1;
+        current = current.right;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * (Protected) Finds the node at position k in tree order (recursive).
+   * @remarks Time O(log n), Space O(log n) call stack
+   */
+  _getByRankRecursive(node, k) {
+    if (!node) return void 0;
+    const leftCount = this.isRealNode(node.left) ? node.left._count : 0;
+    if (k < leftCount) return this._getByRankRecursive(node.left, k);
+    if (k === leftCount) return node;
+    return this._getByRankRecursive(node.right, k - leftCount - 1);
+  }
+  /**
+   * (Protected) Computes the rank of a key iteratively.
+   * @remarks Time O(log n), Space O(1)
+   */
+  _getRankIterative(node, key) {
+    let rank = 0;
+    let current = node;
+    while (this.isRealNode(current)) {
+      const cmp = this._compare(current.key, key);
+      if (cmp > 0) {
+        current = current.left;
+      } else if (cmp < 0) {
+        rank += (this.isRealNode(current.left) ? current.left._count : 0) + 1;
+        current = current.right;
+      } else {
+        rank += this.isRealNode(current.left) ? current.left._count : 0;
+        return rank;
+      }
+    }
+    return rank;
+  }
+  /**
+   * (Protected) Computes the rank of a key recursively.
+   * @remarks Time O(log n), Space O(log n) call stack
+   */
+  _getRankRecursive(node, key) {
+    if (!node) return 0;
+    const cmp = this._compare(node.key, key);
+    if (cmp > 0) {
+      return this._getRankRecursive(node.left, key);
+    } else if (cmp < 0) {
+      return (this.isRealNode(node.left) ? node.left._count : 0) + 1 + this._getRankRecursive(node.right, key);
+    } else {
+      return this.isRealNode(node.left) ? node.left._count : 0;
+    }
+  }
+  /**
+   * (Protected) Finds the in-order successor of a node.
+   * @remarks Time O(log n), Space O(1)
+   */
+  _next(node) {
+    if (this.isRealNode(node.right)) {
+      let current2 = node.right;
+      while (this.isRealNode(current2.left)) {
+        current2 = current2.left;
+      }
+      return current2;
+    }
+    let current = node;
+    let parent = current.parent;
+    while (parent && current === parent.right) {
+      current = parent;
+      parent = parent.parent;
+    }
+    return parent;
+  }
   _setRoot(v) {
     if (v) v.parent = void 0;
     this._root = v;
@@ -5447,21 +5804,28 @@ var BST = class extends BinaryTree {
       while (x.left !== void 0 && x.left !== null) x = x.left;
       return x;
     }, "minNode");
+    let countUpdateStart;
     if (node.left === void 0) {
+      countUpdateStart = node.parent;
       transplant(node, node.right);
     } else if (node.right === void 0) {
+      countUpdateStart = node.parent;
       transplant(node, node.left);
     } else {
       const succ = minNode(node.right);
       if (succ.parent !== node) {
+        countUpdateStart = succ.parent;
         transplant(succ, succ.right);
         succ.right = node.right;
         if (succ.right) succ.right.parent = succ;
+      } else {
+        countUpdateStart = succ;
       }
       transplant(node, succ);
       succ.left = node.left;
       if (succ.left) succ.left.parent = succ;
     }
+    this._updateCountAlongPath(countUpdateStart);
     this._size = Math.max(0, this._size - 1);
     return true;
   }
@@ -5488,7 +5852,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);
@@ -5543,6 +5907,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5611,6 +5983,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5679,6 +6059,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5747,6 +6135,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5813,6 +6209,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5886,6 +6290,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5936,6 +6348,10 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -5993,6 +6409,10 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6067,10 +6487,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. */
@@ -6153,6 +6573,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6221,6 +6645,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6283,6 +6711,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6352,6 +6784,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6399,6 +6835,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6472,6 +6912,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6841,6 +7285,22 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6957,6 +7417,18 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7036,6 +7508,14 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7156,6 +7636,18 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7287,6 +7779,8 @@ var AVLTree = class extends BST {
     }
     this._updateHeight(A);
     if (B) this._updateHeight(B);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
   }
   /**
    * (Protected) Performs a Left-Right (LR) double rotation.
@@ -7332,6 +7826,9 @@ var AVLTree = class extends BST {
     this._updateHeight(A);
     if (B) this._updateHeight(B);
     if (C) this._updateHeight(C);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
+    if (C) this._updateCount(C);
   }
   /**
    * (Protected) Performs a Right-Right (RR) rotation (a single left rotation).
@@ -7366,6 +7863,8 @@ var AVLTree = class extends BST {
     }
     this._updateHeight(A);
     if (B) this._updateHeight(B);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
   }
   /**
    * (Protected) Performs a Right-Left (RL) double rotation.
@@ -7409,6 +7908,9 @@ var AVLTree = class extends BST {
     this._updateHeight(A);
     if (B) this._updateHeight(B);
     if (C) this._updateHeight(C);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
+    if (C) this._updateCount(C);
   }
   /**
    * (Protected) Traverses up the tree from the specified node, updating heights and performing rotations as needed.
@@ -7423,6 +7925,7 @@ var AVLTree = class extends BST {
       const A = path[i];
       if (A) {
         this._updateHeight(A);
+        this._updateCount(A);
         switch (this._balanceFactor(A)) {
           case -2:
             if (A && A.left) {
@@ -7752,6 +8255,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7858,6 +8377,7 @@ var RedBlackTree = class 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";
   }
@@ -7967,6 +8487,7 @@ var RedBlackTree = class 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;
@@ -8209,6 +8730,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8409,17 +8946,33 @@ var RedBlackTree = class 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) {
-    if (keyNodeEntryRawOrPredicate === null) return [];
-    const results = [];
-    let nodeToDelete;
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @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) {
+    if (keyNodeEntryRawOrPredicate === null) return [];
+    const results = [];
+    let nodeToDelete;
     if (this._isPredicate(keyNodeEntryRawOrPredicate)) nodeToDelete = this.getNode(keyNodeEntryRawOrPredicate);
     else nodeToDelete = this.isRealNode(keyNodeEntryRawOrPredicate) ? keyNodeEntryRawOrPredicate : this.getNode(keyNodeEntryRawOrPredicate);
     if (!nodeToDelete) {
@@ -8462,6 +9015,7 @@ var RedBlackTree = class extends BST {
     }
     if (this._isMapMode) this._store.delete(nodeToDelete.key);
     this._size--;
+    this._updateCountAlongPath(replacementNode?.parent ?? replacementNode);
     if (this._size <= 0) {
       this._setMinCache(void 0);
       this._setMaxCache(void 0);
@@ -8568,6 +9122,18 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8700,6 +9266,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8802,6 +9384,7 @@ var RedBlackTree = class extends BST {
     node.left = NIL;
     node.right = NIL;
     node.color = "RED";
+    this._updateCountAlongPath(node);
     this._insertFixup(node);
     return "CREATED";
   }
@@ -8970,6 +9553,8 @@ var RedBlackTree = class extends BST {
     }
     y.left = x;
     x.parent = y;
+    this._updateCount(x);
+    this._updateCount(y);
   }
   /**
    * (Protected) Perform a right rotation around y.
@@ -8996,6 +9581,8 @@ var RedBlackTree = class extends BST {
     }
     x.right = y;
     y.parent = x;
+    this._updateCount(y);
+    this._updateCount(x);
   }
 };
 
@@ -9027,7 +9614,7 @@ var TreeSet = class _TreeSet {
     const toElementFn = options.toElementFn;
     const comparator = options.comparator ?? _TreeSet.createDefaultComparator();
     this.#isDefaultComparator = options.comparator === void 0;
-    this.#core = new RedBlackTree([], { comparator, isMapMode: options.isMapMode });
+    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);
@@ -9046,7 +9633,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;
@@ -9057,10 +9644,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"));
     };
   }
   /**
@@ -9188,6 +9775,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9219,15 +9826,15 @@ var TreeSet = class _TreeSet {
   _validateKey(key) {
     if (!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).
@@ -9352,6 +9959,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9521,6 +10148,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9685,6 +10332,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9838,6 +10505,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9987,6 +10674,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10137,6 +10844,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10287,6 +11014,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10440,6 +11187,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10593,6 +11360,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10770,7 +11557,27 @@ var TreeSet = class _TreeSet {
     
     
     
-     * @example
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
   * // Filter
   *  const ts = new TreeSet<number>([1, 2, 3, 4, 5]);
   *       const evens = ts.filter(k => k % 2 === 0);
@@ -10905,6 +11712,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11056,6 +11883,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11208,6 +12055,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11360,6 +12227,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11515,6 +12402,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11664,6 +12571,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11722,6 +12649,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11786,6 +12717,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11828,6 +12763,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11875,6 +12814,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11996,6 +12939,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12137,6 +13096,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12270,6 +13245,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12401,6 +13392,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12535,6 +13542,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12586,6 +13609,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 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 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 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)
@@ -12728,8 +13807,28 @@ var TreeSet = class _TreeSet {
     
     
     
-     * @example
-  * // Deep clone
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Deep clone
   *  const ts = new TreeSet<number>([1, 2, 3]);
   *       const copy = ts.clone();
   *       copy.delete(1);
@@ -12767,7 +13866,7 @@ var TreeMultiMap = class _TreeMultiMap {
     const comparator = options.comparator ?? TreeSet.createDefaultComparator();
     this.#isDefaultComparator = options.comparator === void 0;
     const toEntryFn = options.toEntryFn;
-    this.#core = new RedBlackTree([], { ...options, comparator, isMapMode: options.isMapMode });
+    this.#core = new RedBlackTree([], { ...options, comparator, isMapMode: options.isMapMode, enableOrderStatistic: options.enableOrderStatistic });
     for (const x of keysNodesEntriesOrRaws) {
       if (x === null || x === void 0) continue;
       if (toEntryFn) {
@@ -12800,15 +13899,15 @@ var TreeMultiMap = class _TreeMultiMap {
   _validateKey(key) {
     if (!this.#isDefaultComparator) 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.
@@ -12937,6 +14036,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13085,6 +14204,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13136,6 +14275,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13172,6 +14315,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13344,6 +14491,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13530,6 +14701,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13676,6 +14871,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13887,6 +15102,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13940,6 +15179,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13977,6 +15220,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14019,6 +15266,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14177,6 +15428,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14328,6 +15599,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14380,6 +15671,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14417,6 +15712,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14454,6 +15753,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14521,6 +15824,14 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14594,6 +15905,14 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14640,6 +15959,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14681,6 +16004,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14844,12 +16171,32 @@ 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');
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @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) {
@@ -14985,6 +16332,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15120,6 +16487,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15250,6 +16633,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15405,6 +16804,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15555,6 +16974,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15710,6 +17149,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15867,6 +17326,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16022,6 +17501,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16170,6 +17669,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16300,6 +17819,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16467,6 +18002,81 @@ 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) {
+    const key = this.#core.getByRank(k);
+    if (key === void 0) return void 0;
+    return [key, this.#core.get(key) ?? []];
+  }
+  /**
+    * 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 this.#core.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 = this.#core.rangeByRank(start, end);
+    return keys.filter((k) => k !== void 0).map((k) => [k, this.#core.get(k) ?? []]);
+  }
+  /**
+    * Deep copy
+   
     
     
     
@@ -16518,7 +18128,7 @@ var TreeMap = class _TreeMap {
     const toEntryFn = options.toEntryFn;
     const comparator = options.comparator ?? _TreeMap.createDefaultComparator();
     this.#isDefaultComparator = options.comparator === void 0;
-    this.#core = new RedBlackTree([], { comparator, isMapMode: options.isMapMode });
+    this.#core = new RedBlackTree([], { comparator, isMapMode: options.isMapMode, enableOrderStatistic: options.enableOrderStatistic });
     for (const item of entries) {
       let k;
       let v;
@@ -16526,7 +18136,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];
@@ -16547,7 +18157,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;
@@ -16558,24 +18168,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 (!this.#isDefaultComparator) 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.
@@ -16723,14 +18333,34 @@ var TreeMap = class _TreeMap {
     
     
     
-     * @example
-  * // Check empty
-  *  console.log(new TreeMap().isEmpty()); // true;
-    */
-  isEmpty() {
-    return this.size === 0;
-  }
-  /**
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check empty
+  *  console.log(new TreeMap().isEmpty()); // true;
+    */
+  isEmpty() {
+    return this.size === 0;
+  }
+  /**
     * Set or overwrite a value for a key.
     * @remarks Expected time O(log n)
     
@@ -16859,6 +18489,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17037,6 +18687,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17205,6 +18875,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17373,6 +19063,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17531,6 +19241,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17680,6 +19410,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17833,6 +19583,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17983,6 +19753,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18136,6 +19926,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18289,6 +20099,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18445,6 +20275,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18622,14 +20472,34 @@ 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;
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @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;
   }
@@ -18751,6 +20621,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18903,6 +20793,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19056,6 +20966,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19210,6 +21140,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19359,6 +21309,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19418,6 +21388,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19482,6 +21456,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19530,6 +21508,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19582,6 +21564,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19709,6 +21695,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19866,6 +21868,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20007,6 +22025,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20148,6 +22182,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20290,6 +22340,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20354,6 +22420,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 = this.#core.getByRank(k);
+    if (key === void 0) return void 0;
+    return [key, this.#core.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 this.#core.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 = this.#core.rangeByRank(start, end);
+    return keys.filter((k) => k !== void 0).map((k) => [k, this.#core.get(k)]);
+  }
   /**
     * Creates a shallow clone of this map.
     * @remarks Time O(n log n), Space O(n)
@@ -20496,20 +22624,40 @@ 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: this.#isDefaultComparator ? void 0 : this.#userComparator,
-      isMapMode: this.#core.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: this.#isDefaultComparator ? void 0 : this.#userComparator,
+      isMapMode: this.#core.isMapMode
+    });
+  }
+};
 
 // src/data-structures/binary-tree/tree-multi-set.ts
 var TreeMultiSet = class _TreeMultiSet {
@@ -20537,7 +22685,7 @@ var TreeMultiSet = class _TreeMultiSet {
     const toElementFn = options.toElementFn;
     const comparator = options.comparator ?? TreeSet.createDefaultComparator();
     this.#isDefaultComparator = options.comparator === void 0;
-    this.#core = new RedBlackTree([], { comparator, isMapMode: options.isMapMode });
+    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);
@@ -20550,22 +22698,22 @@ var TreeMultiSet = class _TreeMultiSet {
   _validateKey(key) {
     if (!this.#isDefaultComparator) 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).
@@ -20594,6 +22742,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -20729,6 +22881,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20880,6 +23052,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20932,6 +23124,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21062,6 +23258,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21123,6 +23339,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21271,6 +23491,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21333,6 +23573,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21373,6 +23617,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21508,6 +23756,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21669,6 +23937,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21720,6 +24008,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21755,6 +24047,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21899,6 +24195,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21953,6 +24269,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21989,6 +24309,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22025,6 +24349,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22065,6 +24393,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22179,6 +24511,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22304,6 +24652,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22429,6 +24793,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22553,6 +24933,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22703,6 +25099,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22859,6 +25275,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23022,6 +25458,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23180,6 +25636,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23359,6 +25835,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 this.#core.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 this.#core.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 this.#core.rangeByRank(start, end).filter((k) => k !== void 0);
+  }
+  /**
+    * Deep copy
+   
     
     
     
@@ -23477,6 +26025,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23628,6 +26192,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+