data-structure-typed 2.5.2 → 2.5.3

package/dist/cjs/binary-tree.cjs

@@ -797,6 +797,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -847,6 +851,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -861,6 +869,14 @@ var Queue = class _Queue extends LinearBase {
   get first() {
     return this.length > 0 ? this.elements[this._offset] : void 0;
   }
+  /**
+   * Peek at the front element without removing it (alias for `first`).
+   * @remarks Time O(1), Space O(1)
+   * @returns Front element or undefined.
+   */
+  peek() {
+    return this.first;
+  }
   /**
    * Get the last element (back) without removing it.
    * @remarks Time O(1), Space O(1)
@@ -913,6 +929,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -975,6 +995,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1044,6 +1068,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1103,6 +1131,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1155,6 +1187,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1206,6 +1242,21 @@ var Queue = class _Queue extends LinearBase {
     this._elements[this._offset + index] = newElement;
     return true;
   }
+  /**
+   * Delete the first element that satisfies a predicate.
+   * @remarks Time O(N), Space O(N)
+   * @param predicate - Function (value, index, queue) → boolean to decide deletion.
+   * @returns True if a match was removed.
+   */
+  deleteWhere(predicate) {
+    for (let i = 0; i < this.length; i++) {
+      if (predicate(this._elements[this._offset + i], i, this)) {
+        this.deleteAt(i);
+        return true;
+      }
+    }
+    return false;
+  }
   /**
    * Reverse the queue in-place by compacting then reversing.
    * @remarks Time O(N), Space O(N)
@@ -1248,6 +1299,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1294,6 +1349,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1363,6 +1422,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1416,6 +1479,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1473,6 +1540,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1944,7 +2015,7 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
   }
   /**
     * Adds a new node to the tree.
-    * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation adds the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
+    * @remarks Time O(N) — level-order traversal to find an empty slot. Space O(N) for the BFS queue. BST/Red-Black Tree/AVL Tree subclasses override to O(log N).
     *
     * @param keyNodeOrEntry - The key, node, or entry to add.
     * @returns True if the addition was successful, false otherwise.
@@ -1973,6 +2044,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1992,7 +2067,7 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
   }
   /**
     * Adds or updates a new node to the tree.
-    * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation sets the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
+    * @remarks Time O(N) — level-order traversal to find an empty slot. Space O(N) for the BFS queue. BST/Red-Black Tree/AVL Tree subclasses override to O(log N).
     *
     * @param keyNodeOrEntry - The key, node, or entry to set or update.
     * @param [value] - The value, if providing just a key.
@@ -2027,6 +2102,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2133,6 +2212,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2175,6 +2258,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2238,6 +2325,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2254,22 +2345,66 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     this.setMany(anotherTree, []);
   }
   /**
-   * Clears the tree and refills it with new items.
-   * @remarks Time O(N) (for `clear`) + O(N * M) (for `setMany`) = O(N * M). Space O(M) (from `setMany`).
+   * Deletes a node from the tree (internal, returns balancing metadata).
+   * @remarks Time O(N) — O(N) to find the node + O(H) for predecessor swap. Space O(1). BST/Red-Black Tree/AVL Tree subclasses override to O(log N).
+   * @internal Used by AVL/BST subclasses that need balancing metadata after deletion.
    *
-   * @param keysNodesEntriesOrRaws - An iterable of items to set.
-   * @param [values] - An optional parallel iterable of values.
+   * @param keyNodeEntryRawOrPredicate - The node to delete.
+   * @returns An array containing deletion results with balancing metadata.
    */
-  refill(keysNodesEntriesOrRaws, values) {
-    this.clear();
-    this.setMany(keysNodesEntriesOrRaws, values);
+  _deleteInternal(keyNodeEntryRawOrPredicate) {
+    const deletedResult = [];
+    if (!this._root) return deletedResult;
+    const curr = this.getNode(keyNodeEntryRawOrPredicate);
+    if (!curr) return deletedResult;
+    const parent = curr?.parent;
+    let needBalanced;
+    let orgCurrent = curr;
+    if (!curr.left && !curr.right && !parent) {
+      this._setRoot(void 0);
+    } else if (curr.left) {
+      const leftSubTreeRightMost = this.getRightMost((node) => node, curr.left);
+      if (leftSubTreeRightMost) {
+        const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+        orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
+        if (this._isMapMode) {
+          this._store.set(curr.key, curr);
+          this._store.set(leftSubTreeRightMost.key, leftSubTreeRightMost);
+        }
+        if (parentOfLeftSubTreeMax) {
+          if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
+            parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+          else parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+          needBalanced = parentOfLeftSubTreeMax;
+        }
+      }
+    } else if (parent) {
+      const { familyPosition: fp } = curr;
+      if (fp === "LEFT" || fp === "ROOT_LEFT") {
+        parent.left = curr.right;
+      } else if (fp === "RIGHT" || fp === "ROOT_RIGHT") {
+        parent.right = curr.right;
+      }
+      needBalanced = parent;
+    } else {
+      this._setRoot(curr.right);
+      curr.right = void 0;
+    }
+    this._size = this._size - 1;
+    deletedResult.push({ deleted: orgCurrent, needBalanced });
+    if (this._isMapMode && orgCurrent) this._store.delete(orgCurrent.key);
+    return deletedResult;
   }
   /**
     * Deletes a node from the tree.
-    * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation finds the node, and if it has two children, swaps it with the rightmost node of its left subtree (in-order predecessor) before deleting. Time O(N) in the worst case. O(N) to find the node (`getNode`) and O(H) (which is O(N) worst-case) to find the rightmost node. Space O(1) (if `getNode` is iterative, which it is).
+    * @remarks Time O(N) — O(N) to find the node + O(H) for predecessor swap. Space O(1). BST/Red-Black Tree/AVL Tree subclasses override to O(log N).
     *
     * @param keyNodeEntryRawOrPredicate - The node to delete.
-    * @returns An array containing deletion results (for compatibility with self-balancing trees).
+    * @returns True if the node was found and deleted, false otherwise.
+    
+    
+    
+    
     
     
     
@@ -2313,51 +2448,11 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
   *     console.log(tree.size); // 4;
     */
   delete(keyNodeEntryRawOrPredicate) {
-    const deletedResult = [];
-    if (!this._root) return deletedResult;
-    const curr = this.getNode(keyNodeEntryRawOrPredicate);
-    if (!curr) return deletedResult;
-    const parent = curr?.parent;
-    let needBalanced;
-    let orgCurrent = curr;
-    if (!curr.left && !curr.right && !parent) {
-      this._setRoot(void 0);
-    } else if (curr.left) {
-      const leftSubTreeRightMost = this.getRightMost((node) => node, curr.left);
-      if (leftSubTreeRightMost) {
-        const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-        orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
-        if (this._isMapMode) {
-          this._store.set(curr.key, curr);
-          this._store.set(leftSubTreeRightMost.key, leftSubTreeRightMost);
-        }
-        if (parentOfLeftSubTreeMax) {
-          if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
-            parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
-          else parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
-          needBalanced = parentOfLeftSubTreeMax;
-        }
-      }
-    } else if (parent) {
-      const { familyPosition: fp } = curr;
-      if (fp === "LEFT" || fp === "ROOT_LEFT") {
-        parent.left = curr.right;
-      } else if (fp === "RIGHT" || fp === "ROOT_RIGHT") {
-        parent.right = curr.right;
-      }
-      needBalanced = parent;
-    } else {
-      this._setRoot(curr.right);
-      curr.right = void 0;
-    }
-    this._size = this._size - 1;
-    deletedResult.push({ deleted: orgCurrent, needBalanced });
-    if (this._isMapMode && orgCurrent) this._store.delete(orgCurrent.key);
-    return deletedResult;
+    return this._deleteInternal(keyNodeEntryRawOrPredicate).length > 0;
   }
   /**
    * Searches the tree for nodes matching a predicate.
-   * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). Performs a full DFS (pre-order) scan of the tree. Time O(N), as it may visit every node. Space O(H) for the call stack (recursive) or explicit stack (iterative), where H is the tree height (O(N) worst-case).
+   * @remarks Time O(N) — full DFS scan; may visit every node. Space O(H) for call/explicit stack (O(N) worst-case). BST subclasses with key search override to O(log N).
    *
    * @template C - The type of the callback function.
    * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
@@ -2406,7 +2501,7 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
   }
   /**
     * Gets the first node matching a predicate.
-    * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). Time O(N) in the worst case (via `search`). Space O(H) or O(N) (via `search`).
+    * @remarks Time O(N) via `search`. Space O(H) or O(N). BST/Red-Black Tree/AVL Tree subclasses override to O(log N) for key lookups.
     *
     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
     * @param [startNode=this._root] - The node to start the search from.
@@ -2440,6 +2535,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2462,7 +2561,7 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
   }
   /**
     * Gets the value associated with a key.
-    * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). Time O(1) if in Map mode. O(N) if not in Map mode (uses `getNode`). Space O(1) if in Map mode. O(H) or O(N) otherwise.
+    * @remarks Time O(1) in Map mode, O(N) otherwise (via `getNode`). Space O(1) in Map mode, O(H) or O(N) otherwise. BST subclasses override non-Map-mode to O(log N).
     *
     * @param keyNodeEntryOrPredicate - The key, node, or entry to get the value for.
     * @param [startNode=this._root] - The node to start searching from (if not in Map mode).
@@ -2498,6 +2597,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2558,6 +2661,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2606,6 +2713,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2663,6 +2774,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2747,6 +2862,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2808,6 +2927,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3285,6 +3408,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3337,6 +3464,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3393,6 +3524,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3474,6 +3609,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -4293,6 +4432,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4625,6 +4772,18 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4744,6 +4903,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5035,6 +5202,10 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -5104,6 +5275,10 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -5222,6 +5397,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5283,12 +5466,11 @@ var BST = class extends BinaryTree {
    */
   deleteWhere(keyNodeEntryOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
     const toDelete = this.search(keyNodeEntryOrPredicate, onlyOne, (node) => node, startNode, iterationType);
-    let results = [];
+    let deleted = false;
     for (const node of toDelete) {
-      const deleteInfo = this.delete(node);
-      results = results.concat(deleteInfo);
+      if (this.delete(node)) deleted = true;
     }
-    return results;
+    return deleted;
   }
   /**
    * (Protected) Creates the default comparator function for keys that don't have a custom comparator.
@@ -5915,6 +6097,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5991,6 +6181,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6067,6 +6265,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6143,6 +6349,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6217,6 +6431,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6298,6 +6520,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6352,6 +6582,10 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6413,6 +6647,10 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6577,6 +6815,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6649,6 +6891,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6715,6 +6961,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6788,6 +7038,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6839,6 +7093,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6916,6 +7174,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -7301,6 +7563,22 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7429,6 +7707,18 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7450,13 +7740,13 @@ var AVLTree = class extends BST {
   *     console.log(avl.size); // 6;
     */
   delete(keyNodeOrEntry) {
-    const deletedResults = super.delete(keyNodeOrEntry);
+    const deletedResults = this._deleteInternal(keyNodeOrEntry);
     for (const { needBalanced } of deletedResults) {
       if (needBalanced) {
         this._balancePath(needBalanced);
       }
     }
-    return deletedResults;
+    return deletedResults.length > 0;
   }
   /**
     * Rebuilds the tree to be perfectly balanced.
@@ -7516,6 +7806,14 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7648,6 +7946,18 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8150,13 +8460,24 @@ var RedBlackTree = class extends BST {
     return keyNodeOrEntry instanceof RedBlackTreeNode;
   }
   /**
-   * Remove all nodes and clear the key→value store (if in map mode).
-   * @remarks Time O(n), Space O(1)
-   * @returns void
-   */
-  /**
-    * Remove all nodes and clear internal caches.
-    * @remarks Time O(n) average, Space O(1)
+    * Remove all nodes, clear the key→value store (if in map mode) and internal caches.
+    * @remarks Time O(n), Space O(1)
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8746,6 +9067,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8945,6 +9282,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8970,13 +9323,12 @@ var RedBlackTree = class extends BST {
   *     console.log(rbt.size); // 4;
     */
   delete(keyNodeEntryRawOrPredicate) {
-    if (keyNodeEntryRawOrPredicate === null) return [];
-    const results = [];
+    if (keyNodeEntryRawOrPredicate === null) return false;
     let nodeToDelete;
     if (this._isPredicate(keyNodeEntryRawOrPredicate)) nodeToDelete = this.getNode(keyNodeEntryRawOrPredicate);
     else nodeToDelete = this.isRealNode(keyNodeEntryRawOrPredicate) ? keyNodeEntryRawOrPredicate : this.getNode(keyNodeEntryRawOrPredicate);
     if (!nodeToDelete) {
-      return results;
+      return false;
     }
     const willDeleteMin = nodeToDelete === this._minNode;
     const willDeleteMax = nodeToDelete === this._maxNode;
@@ -9032,8 +9384,7 @@ var RedBlackTree = class extends BST {
     if (originalColor === "BLACK") {
       this._deleteFixup(replacementNode);
     }
-    results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-    return results;
+    return true;
   }
   /**
    * Transform entries into a like-kind red-black tree with possibly different key/value types.
@@ -9134,6 +9485,18 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9282,6 +9645,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9795,6 +10174,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10000,28 +10399,103 @@ var TreeSet = class _TreeSet {
     
     
     
-     * @example
-  * // Unique tags with sorted order
-  *  const tags = new TreeSet<string>(['javascript', 'typescript', 'react', 'typescript', 'node']);
-  *
-  *     // Duplicates removed, sorted alphabetically
-  *     console.log([...tags]); // ['javascript', 'node', 'react', 'typescript'];
-  *     console.log(tags.size); // 4;
-  *
-  *     tags.add('angular');
-  *     console.log(tags.first()); // 'angular';
-  *     console.log(tags.last()); // 'typescript';
-    */
-  add(key) {
-    this._validateKey(key);
-    this.#core.set(key, void 0);
-    return this;
-  }
-  /**
-    * Test whether a key exists.
-    * @remarks Expected time O(log n)
-    
-    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Unique tags with sorted order
+  *  const tags = new TreeSet<string>(['javascript', 'typescript', 'react', 'typescript', 'node']);
+  *
+  *     // Duplicates removed, sorted alphabetically
+  *     console.log([...tags]); // ['javascript', 'node', 'react', 'typescript'];
+  *     console.log(tags.size); // 4;
+  *
+  *     tags.add('angular');
+  *     console.log(tags.first()); // 'angular';
+  *     console.log(tags.last()); // 'typescript';
+    */
+  add(key) {
+    this._validateKey(key);
+    this.#core.set(key, void 0);
+    return this;
+  }
+  /**
+    * Add multiple keys at once.
+    * @remarks Expected time O(m log n), where m is the number of keys.
+    * @param keys - Iterable of keys to add.
+    * @returns Array of booleans indicating whether each key was newly added.
+   
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Add multiple keys
+  *  const ts = new TreeSet<number>();
+  *     ts.addMany([5, 3, 7, 1, 9]);
+  *     console.log(ts.size); // 5;
+    */
+  addMany(keys) {
+    const results = [];
+    for (const key of keys) {
+      this._validateKey(key);
+      results.push(this.#core.set(key, void 0));
+    }
+    return results;
+  }
+  /**
+    * Test whether a key exists.
+    * @remarks Expected time O(log n)
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10352,6 +10826,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10383,8 +10877,24 @@ var TreeSet = class _TreeSet {
     */
   delete(key) {
     this._validateKey(key);
-    const res = this.#core.delete(key);
-    return Array.isArray(res) && res.length > 0 && !!res[0]?.deleted;
+    return this.#core.delete(key);
+  }
+  /**
+   * Delete all keys matching a predicate.
+   * @remarks Time O(N), Space O(N)
+   * @param predicate - Function (key, index, set) → boolean; return true to delete.
+   * @returns True if at least one key was deleted.
+   */
+  deleteWhere(predicate) {
+    let deleted = false;
+    let index = 0;
+    for (const key of this) {
+      if (predicate(key, index++, this)) {
+        this.delete(key);
+        deleted = true;
+      }
+    }
+    return deleted;
   }
   /**
     * Remove all keys.
@@ -10525,6 +11035,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10694,6 +11224,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10864,6 +11414,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11034,6 +11604,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11207,6 +11797,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11380,6 +11990,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11556,6 +12186,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11732,6 +12382,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11903,6 +12573,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12075,6 +12765,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12268,23 +12978,83 @@ var TreeSet = class _TreeSet {
     
     
     
-     * @example
-  * // Find entry
-  *  const ts = new TreeSet<number>([1, 2, 3]);
-  *       const found = ts.find(k => k === 2);
-  *       console.log(found); // 2;
-    */
-  find(callbackfn, thisArg) {
-    let index = 0;
-    for (const v of this) {
-      const ok = thisArg === void 0 ? callbackfn(v, index++, this) : callbackfn.call(thisArg, v, index++, this);
-      if (ok) return v;
-    }
-    return void 0;
-  }
-  /**
-    * Materialize the set into an array of keys.
-    * @remarks Time O(n), Space O(n)
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Find entry
+  *  const ts = new TreeSet<number>([1, 2, 3]);
+  *       const found = ts.find(k => k === 2);
+  *       console.log(found); // 2;
+    */
+  find(callbackfn, thisArg) {
+    let index = 0;
+    for (const v of this) {
+      const ok = thisArg === void 0 ? callbackfn(v, index++, this) : callbackfn.call(thisArg, v, index++, this);
+      if (ok) return v;
+    }
+    return void 0;
+  }
+  /**
+    * Materialize the set into an array of keys.
+    * @remarks Time O(n), Space O(n)
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12423,6 +13193,17 @@ var TreeSet = class _TreeSet {
     
     
     
+     * @example
+  * // Convert to array
+  *  const ts = new TreeSet<number>([3, 1, 2]);
+  *       console.log(ts.toArray()); // [1, 2, 3];
+    */
+  toArray() {
+    return [...this];
+  }
+  /**
+    * Print a human-friendly representation.
+    * @remarks Time O(n), Space O(n)
     
     
     
@@ -12443,17 +13224,6 @@ var TreeSet = class _TreeSet {
     
     
     
-     * @example
-  * // Convert to array
-  *  const ts = new TreeSet<number>([3, 1, 2]);
-  *       console.log(ts.toArray()); // [1, 2, 3];
-    */
-  toArray() {
-    return [...this];
-  }
-  /**
-    * Print a human-friendly representation.
-    * @remarks Time O(n), Space O(n)
     
     
     
@@ -12653,6 +13423,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -12721,6 +13495,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -12767,6 +13545,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -12818,6 +13600,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -12955,6 +13741,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13112,6 +13914,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13261,6 +14079,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13408,6 +14242,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13558,6 +14408,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13647,8 +14513,16 @@ var TreeSet = class _TreeSet {
     * Returns elements by rank range (0-indexed, inclusive on both ends).
     * @remarks Time O(log n + k). Requires `enableOrderStatistic: true`.
     
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
-  * // Pagination with rangeByRank
+  * // Pagination by position in tree order
   *  const tree = new TreeSet<number>(
   *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
   *         { enableOrderStatistic: true }
@@ -13806,6 +14680,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14056,6 +14950,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14224,6 +15138,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14279,6 +15213,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14319,6 +15257,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14515,6 +15457,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14725,6 +15691,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14891,6 +15881,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15126,6 +16136,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15157,7 +16191,7 @@ var TreeMultiMap = class _TreeMultiMap {
     */
   delete(key) {
     this._validateKey(key);
-    return this.#core.delete(key).length > 0;
+    return this.#core.delete(key);
   }
   /**
     * Check if a specific value exists in a key's bucket.
@@ -15183,6 +16217,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15224,6 +16262,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15270,6 +16312,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15448,6 +16494,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15619,6 +16685,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15675,6 +16761,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15716,6 +16806,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15757,6 +16851,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15832,6 +16930,14 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15913,6 +17019,14 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15963,6 +17077,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -16008,6 +17126,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -16170,6 +17292,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16352,6 +17494,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16503,6 +17665,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16649,6 +17827,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16824,6 +18018,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16994,6 +18208,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17169,6 +18403,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17346,6 +18600,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17521,6 +18795,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17689,6 +18983,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17835,6 +19149,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18055,8 +19385,16 @@ var TreeMultiMap = class _TreeMultiMap {
   /**
     * Get elements by rank range
    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
-  * // Pagination with rangeByRank
+  * // Pagination by position in tree order
   *  const tree = new TreeMultiMap<number>(
   *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
   *         { enableOrderStatistic: true }
@@ -18079,6 +19417,26 @@ var TreeMultiMap = class _TreeMultiMap {
    
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
      * @example
   * // Deep clone
@@ -18332,6 +19690,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18509,6 +19887,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18556,6 +19954,41 @@ var TreeMap = class _TreeMap {
     this.#core.set(key, value);
     return this;
   }
+  /**
+    * Set multiple key-value pairs at once.
+    * @remarks Expected time O(m log n), where m is the number of entries.
+    * @param entries - Iterable of `[key, value]` tuples.
+    * @returns Array of booleans indicating whether each entry was successfully set.
+   
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Set multiple key-value pairs
+  *  const tm = new TreeMap<number, string>();
+  *     tm.setMany([[1, 'a'], [2, 'b'], [3, 'c']]);
+  *     console.log(tm.size); // 3;
+    */
+  setMany(entries) {
+    const results = [];
+    for (const [key, value] of entries) {
+      this._validateKey(key);
+      results.push(this.#core.set(key, value));
+    }
+    return results;
+  }
   /**
     * Get the value under a key.
     * @remarks Expected time O(log n)
@@ -18707,6 +20140,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18895,6 +20348,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19083,6 +20556,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19119,8 +20612,24 @@ var TreeMap = class _TreeMap {
     */
   delete(key) {
     this._validateKey(key);
-    const res = this.#core.delete(key);
-    return Array.isArray(res) && res.length > 0 && !!res[0]?.deleted;
+    return this.#core.delete(key);
+  }
+  /**
+   * Delete all entries matching a predicate.
+   * @remarks Time O(N), Space O(N)
+   * @param predicate - Function (key, value, index, map) → boolean; return true to delete.
+   * @returns True if at least one entry was deleted.
+   */
+  deleteWhere(predicate) {
+    let deleted = false;
+    let index = 0;
+    for (const [key, value] of this) {
+      if (predicate(key, value, index++, this)) {
+        this.delete(key);
+        deleted = true;
+      }
+    }
+    return deleted;
   }
   /**
     * Remove all entries.
@@ -19261,6 +20770,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19430,6 +20959,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19603,6 +21152,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19773,6 +21342,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19946,6 +21535,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20119,6 +21728,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20295,6 +21924,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20471,6 +22120,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20641,6 +22310,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20813,6 +22502,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20986,6 +22695,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21160,6 +22889,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21329,6 +23078,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21392,6 +23161,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21460,6 +23233,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21512,6 +23289,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21568,6 +23349,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21711,6 +23496,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21884,6 +23685,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22041,6 +23858,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22198,6 +24031,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22356,6 +24205,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22463,8 +24328,16 @@ var TreeMap = class _TreeMap {
     * Returns keys by rank range (0-indexed, inclusive on both ends).
     * @remarks Time O(log n + k). Requires `enableOrderStatistic: true`.
     
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
-  * // Pagination with rangeByRank
+  * // Pagination by position in tree order
   *  const tree = new TreeMap<number>(
   *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
   *         { enableOrderStatistic: true }
@@ -22623,6 +24496,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22746,6 +24639,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22901,6 +24798,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23072,6 +24989,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23128,6 +25065,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -23278,6 +25219,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23343,6 +25304,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -23511,6 +25476,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23577,6 +25562,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -23621,6 +25610,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -23776,6 +25769,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23957,6 +25970,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -24012,6 +26045,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24051,6 +26088,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24215,6 +26256,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -24273,6 +26334,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24313,6 +26378,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24353,6 +26422,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24397,6 +26470,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24527,6 +26604,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -24668,6 +26761,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -24809,6 +26918,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -24949,6 +27074,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -25119,6 +27260,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -25295,6 +27456,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -25478,6 +27659,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -25656,6 +27857,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -25886,8 +28107,16 @@ var TreeMultiSet = class _TreeMultiSet {
   /**
     * Get elements by rank range
    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
-  * // Pagination with rangeByRank
+  * // Pagination by position in tree order
   *  const tree = new TreeMultiSet<number>(
   *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
   *         { enableOrderStatistic: true }
@@ -25909,6 +28138,26 @@ var TreeMultiSet = class _TreeMultiSet {
    
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
      * @example
   * // Deep clone
@@ -26041,6 +28290,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -26212,6 +28477,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+