data-structure-typed 2.5.1 → 2.5.2

package/dist/esm/binary-tree.mjs

@@ -57,6 +57,56 @@ function makeTrampoline(fn) {
 }
 __name(makeTrampoline, "makeTrampoline");
 
+// src/common/error.ts
+function raise(ErrorClass, message) {
+  throw new ErrorClass(message);
+}
+__name(raise, "raise");
+var ERR = {
+  // Range / index
+  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
+  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
+  // Type / argument
+  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
+  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
+  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
+  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
+  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
+  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
+  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
+  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
+  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
+  // State / operation
+  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
+  // Matrix
+  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
+  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
+  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
+  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
+  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch"),
+  // Order statistic
+  orderStatisticNotEnabled: /* @__PURE__ */ __name((method, ctx) => `${ctx ? ctx + ": " : ""}${method}() requires enableOrderStatistic: true.`, "orderStatisticNotEnabled")
+};
+
+// src/common/index.ts
+var Range = class {
+  constructor(low, high, includeLow = true, includeHigh = true) {
+    this.low = low;
+    this.high = high;
+    this.includeLow = includeLow;
+    this.includeHigh = includeHigh;
+  }
+  static {
+    __name(this, "Range");
+  }
+  // Determine whether a key is within the range
+  isInRange(key, comparator) {
+    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+    return lowCheck && highCheck;
+  }
+};
+
 // src/data-structures/base/iterable-element-base.ts
 var IterableElementBase = class {
   static {
@@ -75,7 +125,7 @@ var IterableElementBase = class {
     if (options) {
       const { toElementFn } = options;
       if (typeof toElementFn === "function") this._toElementFn = toElementFn;
-      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+      else if (toElementFn) raise(TypeError, "toElementFn must be a function type");
     }
   }
   /**
@@ -238,7 +288,7 @@ var IterableElementBase = class {
       acc = initialValue;
     } else {
       const first = iter.next();
-      if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+      if (first.done) raise(TypeError, "Reduce of empty structure with no initial value");
       acc = first.value;
       index = 1;
     }
@@ -473,50 +523,6 @@ var LinearBase = class _LinearBase extends IterableElementBase {
   }
 };
 
-// src/common/error.ts
-var ERR = {
-  // Range / index
-  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
-  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
-  // Type / argument
-  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
-  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
-  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
-  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
-  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
-  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
-  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
-  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
-  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
-  // State / operation
-  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
-  // Matrix
-  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
-  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
-  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
-  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
-  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch")
-};
-
-// src/common/index.ts
-var Range = class {
-  constructor(low, high, includeLow = true, includeHigh = true) {
-    this.low = low;
-    this.high = high;
-    this.includeLow = includeLow;
-    this.includeHigh = includeHigh;
-  }
-  static {
-    __name(this, "Range");
-  }
-  // Determine whether a key is within the range
-  isInRange(key, comparator) {
-    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-    return lowCheck && highCheck;
-  }
-};
-
 // src/data-structures/base/iterable-entry-base.ts
 var IterableEntryBase = class {
   static {
@@ -785,6 +791,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -831,6 +841,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -893,6 +907,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -951,6 +969,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1016,6 +1038,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1071,6 +1097,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1119,6 +1149,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1208,6 +1242,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1250,6 +1288,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1315,6 +1357,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1364,6 +1410,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1417,6 +1467,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1672,7 +1726,7 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
       if (isMapMode !== void 0) this._isMapMode = isMapMode;
       if (isDuplicate !== void 0) this._isDuplicate = isDuplicate;
       if (typeof toEntryFn === "function") this._toEntryFn = toEntryFn;
-      else if (toEntryFn) throw new TypeError(ERR.notAFunction("toEntryFn", "BinaryTree"));
+      else if (toEntryFn) raise(TypeError, ERR.notAFunction("toEntryFn", "BinaryTree"));
     }
     if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
@@ -1913,6 +1967,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1963,6 +2021,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2065,6 +2127,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2103,6 +2169,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2162,6 +2232,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2220,6 +2294,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2356,6 +2434,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2410,6 +2492,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2466,6 +2552,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2510,6 +2600,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2563,6 +2657,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2643,6 +2741,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2700,6 +2802,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3173,6 +3279,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3221,6 +3331,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3273,6 +3387,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3350,6 +3468,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3986,12 +4108,16 @@ var BST = class extends BinaryTree {
       } else {
         this._comparator = this._createDefaultComparator();
       }
+      if (options.enableOrderStatistic) {
+        this._enableOrderStatistic = true;
+      }
     } else {
       this._comparator = this._createDefaultComparator();
     }
     if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
   _root = void 0;
+  _enableOrderStatistic = false;
   /**
    * Gets the root node of the tree.
    * @remarks Time O(1)
@@ -4157,6 +4283,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4320,6 +4454,84 @@ var BST = class extends BinaryTree {
     const searchRange = range instanceof Range ? range : new Range(range[0], range[1]);
     return this.search(searchRange, false, callback, startNode, iterationType);
   }
+  getByRank(k, callback = this._DEFAULT_NODE_CALLBACK, iterationType = this.iterationType) {
+    if (!this._enableOrderStatistic) {
+      raise(Error, ERR.orderStatisticNotEnabled("getByRank"));
+    }
+    if (k < 0 || k >= this._size) return void 0;
+    let actualCallback = void 0;
+    let actualIterationType = this.iterationType;
+    if (typeof callback === "string") {
+      actualIterationType = callback;
+    } else if (callback) {
+      actualCallback = callback;
+      if (iterationType) {
+        actualIterationType = iterationType;
+      }
+    }
+    const node = actualIterationType === "RECURSIVE" ? this._getByRankRecursive(this._root, k) : this._getByRankIterative(this._root, k);
+    if (!node) return void 0;
+    return actualCallback ? actualCallback(node) : node.key;
+  }
+  getRank(keyNodeEntryOrPredicate, iterationType = this.iterationType) {
+    if (!this._enableOrderStatistic) {
+      raise(Error, ERR.orderStatisticNotEnabled("getRank"));
+    }
+    if (!this._root || this._size === 0) return -1;
+    let actualIterationType = this.iterationType;
+    if (iterationType) actualIterationType = iterationType;
+    let key;
+    if (typeof keyNodeEntryOrPredicate === "function") {
+      const results = this.search(keyNodeEntryOrPredicate, true);
+      if (results.length === 0 || results[0] === void 0) return -1;
+      key = results[0];
+    } else if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) {
+      return -1;
+    } else if (this.isNode(keyNodeEntryOrPredicate)) {
+      key = keyNodeEntryOrPredicate.key;
+    } else if (Array.isArray(keyNodeEntryOrPredicate)) {
+      key = keyNodeEntryOrPredicate[0] ?? void 0;
+      if (key === void 0 || key === null) return -1;
+    } else {
+      key = keyNodeEntryOrPredicate;
+    }
+    if (key === void 0) return -1;
+    return actualIterationType === "RECURSIVE" ? this._getRankRecursive(this._root, key) : this._getRankIterative(this._root, key);
+  }
+  rangeByRank(start, end, callback = this._DEFAULT_NODE_CALLBACK, iterationType = this.iterationType) {
+    if (!this._enableOrderStatistic) {
+      raise(Error, ERR.orderStatisticNotEnabled("rangeByRank"));
+    }
+    if (this._size === 0) return [];
+    const lo = Math.max(0, start);
+    const hi = Math.min(this._size - 1, end);
+    if (lo > hi) return [];
+    let actualCallback = void 0;
+    let actualIterationType = this.iterationType;
+    if (typeof callback === "string") {
+      actualIterationType = callback;
+    } else if (callback) {
+      actualCallback = callback;
+      if (iterationType) {
+        actualIterationType = iterationType;
+      }
+    }
+    const results = [];
+    const count = hi - lo + 1;
+    const startNode = actualIterationType === "RECURSIVE" ? this._getByRankRecursive(this._root, lo) : this._getByRankIterative(this._root, lo);
+    if (!startNode) return [];
+    let collected = 0;
+    const cb = actualCallback ?? this._DEFAULT_NODE_CALLBACK;
+    let current = startNode;
+    while (current && collected < count) {
+      results.push(cb(current));
+      collected++;
+      if (collected < count) {
+        current = this._next(current);
+      }
+    }
+    return results;
+  }
   /**
     * Adds a new node to the BST based on key comparison.
     * @remarks Time O(log N), where H is tree height. O(N) worst-case (unbalanced tree), O(log N) average. Space O(1).
@@ -4412,20 +4624,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;
@@ -4439,6 +4664,7 @@ var BST = class extends BinaryTree {
           current.left = newNode;
           if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
+          this._updateCountAlongPath(newNode);
           return true;
         }
         if (current.left !== null) current = current.left;
@@ -4447,6 +4673,7 @@ var BST = class extends BinaryTree {
           current.right = newNode;
           if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
+          this._updateCountAlongPath(newNode);
           return true;
         }
         if (current.right !== null) current = current.right;
@@ -4507,6 +4734,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4794,6 +5029,10 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -4859,6 +5098,10 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -4969,6 +5212,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5052,13 +5303,11 @@ var BST = class extends BinaryTree {
       if (a instanceof Date && b instanceof Date) {
         const ta = a.getTime();
         const tb = b.getTime();
-        if (Number.isNaN(ta) || Number.isNaN(tb)) throw new TypeError(ERR.invalidDate("BST"));
+        if (Number.isNaN(ta) || Number.isNaN(tb)) raise(TypeError, ERR.invalidDate("BST"));
         return ta > tb ? 1 : ta < tb ? -1 : 0;
       }
       if (typeof a === "object" || typeof b === "object") {
-        throw new TypeError(
-          ERR.comparatorRequired("BST")
-        );
+        raise(TypeError, ERR.comparatorRequired("BST"));
       }
       return 0;
     };
@@ -5377,7 +5626,8 @@ var BST = class extends BinaryTree {
   _snapshotOptions() {
     return {
       ...super._snapshotOptions(),
-      comparator: this._comparator
+      comparator: this._comparator,
+      enableOrderStatistic: this._enableOrderStatistic
     };
   }
   /**
@@ -5399,6 +5649,113 @@ var BST = class extends BinaryTree {
    *
    * @param v - The node to set as root.
    */
+  /**
+   * (Protected) Recalculates the subtree count for a single node.
+   * @remarks Time O(1). Only active when enableOrderStatistic is true.
+   */
+  _updateCount(node) {
+    if (!this._enableOrderStatistic) return;
+    node._count = 1 + (this.isRealNode(node.left) ? node.left._count : 0) + (this.isRealNode(node.right) ? node.right._count : 0);
+  }
+  /**
+   * (Protected) Updates subtree counts from a node up to the root.
+   * @remarks Time O(log n). Only active when enableOrderStatistic is true.
+   */
+  _updateCountAlongPath(node) {
+    if (!this._enableOrderStatistic) return;
+    let current = node;
+    while (current) {
+      this._updateCount(current);
+      current = current.parent;
+    }
+  }
+  /**
+   * (Protected) Finds the node at position k in tree order (iterative).
+   * @remarks Time O(log n), Space O(1)
+   */
+  _getByRankIterative(node, k) {
+    let current = node;
+    let remaining = k;
+    while (current) {
+      const leftCount = this.isRealNode(current.left) ? current.left._count : 0;
+      if (remaining < leftCount) {
+        current = current.left;
+      } else if (remaining === leftCount) {
+        return current;
+      } else {
+        remaining = remaining - leftCount - 1;
+        current = current.right;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * (Protected) Finds the node at position k in tree order (recursive).
+   * @remarks Time O(log n), Space O(log n) call stack
+   */
+  _getByRankRecursive(node, k) {
+    if (!node) return void 0;
+    const leftCount = this.isRealNode(node.left) ? node.left._count : 0;
+    if (k < leftCount) return this._getByRankRecursive(node.left, k);
+    if (k === leftCount) return node;
+    return this._getByRankRecursive(node.right, k - leftCount - 1);
+  }
+  /**
+   * (Protected) Computes the rank of a key iteratively.
+   * @remarks Time O(log n), Space O(1)
+   */
+  _getRankIterative(node, key) {
+    let rank = 0;
+    let current = node;
+    while (this.isRealNode(current)) {
+      const cmp = this._compare(current.key, key);
+      if (cmp > 0) {
+        current = current.left;
+      } else if (cmp < 0) {
+        rank += (this.isRealNode(current.left) ? current.left._count : 0) + 1;
+        current = current.right;
+      } else {
+        rank += this.isRealNode(current.left) ? current.left._count : 0;
+        return rank;
+      }
+    }
+    return rank;
+  }
+  /**
+   * (Protected) Computes the rank of a key recursively.
+   * @remarks Time O(log n), Space O(log n) call stack
+   */
+  _getRankRecursive(node, key) {
+    if (!node) return 0;
+    const cmp = this._compare(node.key, key);
+    if (cmp > 0) {
+      return this._getRankRecursive(node.left, key);
+    } else if (cmp < 0) {
+      return (this.isRealNode(node.left) ? node.left._count : 0) + 1 + this._getRankRecursive(node.right, key);
+    } else {
+      return this.isRealNode(node.left) ? node.left._count : 0;
+    }
+  }
+  /**
+   * (Protected) Finds the in-order successor of a node.
+   * @remarks Time O(log n), Space O(1)
+   */
+  _next(node) {
+    if (this.isRealNode(node.right)) {
+      let current2 = node.right;
+      while (this.isRealNode(current2.left)) {
+        current2 = current2.left;
+      }
+      return current2;
+    }
+    let current = node;
+    let parent = current.parent;
+    while (parent && current === parent.right) {
+      current = parent;
+      parent = parent.parent;
+    }
+    return parent;
+  }
   _setRoot(v) {
     if (v) v.parent = void 0;
     this._root = v;
@@ -5445,21 +5802,28 @@ var BST = class extends BinaryTree {
       while (x.left !== void 0 && x.left !== null) x = x.left;
       return x;
     }, "minNode");
+    let countUpdateStart;
     if (node.left === void 0) {
+      countUpdateStart = node.parent;
       transplant(node, node.right);
     } else if (node.right === void 0) {
+      countUpdateStart = node.parent;
       transplant(node, node.left);
     } else {
       const succ = minNode(node.right);
       if (succ.parent !== node) {
+        countUpdateStart = succ.parent;
         transplant(succ, succ.right);
         succ.right = node.right;
         if (succ.right) succ.right.parent = succ;
+      } else {
+        countUpdateStart = succ;
       }
       transplant(node, succ);
       succ.left = node.left;
       if (succ.left) succ.left.parent = succ;
     }
+    this._updateCountAlongPath(countUpdateStart);
     this._size = Math.max(0, this._size - 1);
     return true;
   }
@@ -5486,7 +5850,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);
@@ -5541,6 +5905,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5609,6 +5981,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5677,6 +6057,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5745,6 +6133,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5811,6 +6207,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5884,6 +6288,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5934,6 +6346,10 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -5991,6 +6407,10 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6065,10 +6485,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. */
@@ -6151,6 +6571,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6219,6 +6643,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6281,6 +6709,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6350,6 +6782,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6397,6 +6833,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6470,6 +6910,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6839,6 +7283,22 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6955,6 +7415,18 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7034,6 +7506,14 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7154,6 +7634,18 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7285,6 +7777,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.
@@ -7330,6 +7824,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).
@@ -7364,6 +7861,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.
@@ -7407,6 +7906,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.
@@ -7421,6 +7923,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) {
@@ -7750,6 +8253,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7856,6 +8375,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";
   }
@@ -7965,6 +8485,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;
@@ -8207,6 +8728,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8407,17 +8944,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) {
@@ -8460,6 +9013,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);
@@ -8566,6 +9120,18 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8698,6 +9264,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8800,6 +9382,7 @@ var RedBlackTree = class extends BST {
     node.left = NIL;
     node.right = NIL;
     node.color = "RED";
+    this._updateCountAlongPath(node);
     this._insertFixup(node);
     return "CREATED";
   }
@@ -8968,6 +9551,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.
@@ -8994,6 +9579,8 @@ var RedBlackTree = class extends BST {
     }
     x.right = y;
     y.parent = x;
+    this._updateCount(y);
+    this._updateCount(x);
   }
 };
 
@@ -9025,7 +9612,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);
@@ -9044,7 +9631,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;
@@ -9055,10 +9642,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"));
     };
   }
   /**
@@ -9186,6 +9773,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9217,15 +9824,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).
@@ -9350,6 +9957,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9519,6 +10146,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9683,6 +10330,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9836,6 +10503,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9985,6 +10672,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10135,6 +10842,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10285,6 +11012,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10438,6 +11185,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10591,6 +11358,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10768,7 +11555,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);
@@ -10903,6 +11710,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11054,6 +11881,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11206,6 +12053,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11358,6 +12225,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11513,6 +12400,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11662,6 +12569,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11720,6 +12647,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11784,6 +12715,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11826,6 +12761,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11873,6 +12812,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -11994,6 +12937,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12135,6 +13094,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12268,6 +13243,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12399,6 +13390,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12533,6 +13540,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12584,6 +13607,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)
@@ -12726,8 +13805,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);
@@ -12765,7 +13864,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) {
@@ -12798,15 +13897,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.
@@ -12935,6 +14034,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13083,6 +14202,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13134,6 +14273,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13170,6 +14313,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13342,6 +14489,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13528,6 +14699,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13674,6 +14869,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13885,6 +15100,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13938,6 +15177,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -13975,6 +15218,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14017,6 +15264,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14175,6 +15426,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14326,6 +15597,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14378,6 +15669,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14415,6 +15710,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14452,6 +15751,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14519,6 +15822,14 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14592,6 +15903,14 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14638,6 +15957,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14679,6 +16002,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14842,12 +16169,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) {
@@ -14983,6 +16330,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15118,6 +16485,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15248,6 +16631,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15403,6 +16802,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15553,6 +16972,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15708,6 +17147,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15865,6 +17324,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16020,6 +17499,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16168,6 +17667,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16298,6 +17817,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16465,6 +18000,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
+   
     
     
     
@@ -16516,7 +18126,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;
@@ -16524,7 +18134,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];
@@ -16545,7 +18155,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;
@@ -16556,24 +18166,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.
@@ -16721,14 +18331,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)
     
@@ -16857,6 +18487,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17035,6 +18685,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17203,6 +18873,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17371,6 +19061,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17529,6 +19239,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17678,6 +19408,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17831,6 +19581,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17981,6 +19751,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18134,6 +19924,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18287,6 +20097,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18443,6 +20273,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18620,14 +20470,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;
   }
@@ -18749,6 +20619,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18901,6 +20791,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19054,6 +20964,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19208,6 +21138,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19357,6 +21307,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19416,6 +21386,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19480,6 +21454,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19528,6 +21506,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19580,6 +21562,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -19707,6 +21693,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19864,6 +21866,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20005,6 +22023,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20146,6 +22180,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20288,6 +22338,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20352,6 +22418,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)
@@ -20494,20 +22622,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 {
@@ -20535,7 +22683,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);
@@ -20548,22 +22696,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).
@@ -20592,6 +22740,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -20727,6 +22879,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20878,6 +23050,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20930,6 +23122,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21060,6 +23256,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21121,6 +23337,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21269,6 +23489,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21331,6 +23571,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21371,6 +23615,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21506,6 +23754,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21667,6 +23935,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21718,6 +24006,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21753,6 +24045,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21897,6 +24193,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21951,6 +24267,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21987,6 +24307,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22023,6 +24347,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22063,6 +24391,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22177,6 +24509,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22302,6 +24650,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22427,6 +24791,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22551,6 +24931,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22701,6 +25097,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22857,6 +25273,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23020,6 +25456,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23178,6 +25634,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23357,6 +25833,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
+   
     
     
     
@@ -23475,6 +26023,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23626,6 +26190,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+