data-structure-typed 2.5.2 → 2.5.3

package/dist/esm/binary-tree.mjs

@@ -795,6 +795,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -845,6 +849,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -859,6 +867,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)
@@ -911,6 +927,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -973,6 +993,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1042,6 +1066,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1101,6 +1129,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1153,6 +1185,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1204,6 +1240,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)
@@ -1246,6 +1297,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1292,6 +1347,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1361,6 +1420,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1414,6 +1477,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1471,6 +1538,10 @@ var Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1942,7 +2013,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.
@@ -1971,6 +2042,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -1990,7 +2065,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.
@@ -2025,6 +2100,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2131,6 +2210,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2173,6 +2256,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2236,6 +2323,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2252,22 +2343,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.
+    
+    
+    
+    
     
     
     
@@ -2311,51 +2446,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.
@@ -2404,7 +2499,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.
@@ -2438,6 +2533,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2460,7 +2559,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).
@@ -2496,6 +2595,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2556,6 +2659,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2604,6 +2711,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2661,6 +2772,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2745,6 +2860,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -2806,6 +2925,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3283,6 +3406,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3335,6 +3462,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3391,6 +3522,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -3472,6 +3607,10 @@ var BinaryTree = class _BinaryTree extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -4291,6 +4430,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4623,6 +4770,18 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -4742,6 +4901,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5033,6 +5200,10 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -5102,6 +5273,10 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -5220,6 +5395,14 @@ var BST = class extends BinaryTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5281,12 +5464,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.
@@ -5913,6 +6095,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -5989,6 +6179,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6065,6 +6263,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6141,6 +6347,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6215,6 +6429,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6296,6 +6518,14 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -6350,6 +6580,10 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6411,6 +6645,10 @@ var BinaryIndexedTree = class _BinaryIndexedTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6575,6 +6813,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6647,6 +6889,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6713,6 +6959,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6786,6 +7036,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6837,6 +7091,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -6914,6 +7172,10 @@ var SegmentTree = class _SegmentTree {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -7299,6 +7561,22 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7427,6 +7705,18 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7448,13 +7738,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.
@@ -7514,6 +7804,14 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -7646,6 +7944,18 @@ var AVLTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8148,13 +8458,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)
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8744,6 +9065,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8943,6 +9280,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -8968,13 +9321,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;
@@ -9030,8 +9382,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.
@@ -9132,6 +9483,18 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9280,6 +9643,22 @@ var RedBlackTree = class extends BST {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9793,6 +10172,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -9998,28 +10397,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)
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10350,6 +10824,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10381,8 +10875,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.
@@ -10523,6 +11033,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10692,6 +11222,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -10862,6 +11412,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11032,6 +11602,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11205,6 +11795,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11378,6 +11988,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11554,6 +12184,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11730,6 +12380,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -11901,6 +12571,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12073,6 +12763,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12266,23 +12976,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)
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -12421,6 +13191,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)
     
     
     
@@ -12441,17 +13222,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)
     
     
     
@@ -12651,6 +13421,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -12719,6 +13493,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -12765,6 +13543,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -12816,6 +13598,10 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -12953,6 +13739,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13110,6 +13912,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13259,6 +14077,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13406,6 +14240,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13556,6 +14406,22 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -13645,8 +14511,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 }
@@ -13804,6 +14678,26 @@ var TreeSet = class _TreeSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14054,6 +14948,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14222,6 +15136,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14277,6 +15211,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14317,6 +15255,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -14513,6 +15455,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14723,6 +15689,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -14889,6 +15879,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15124,6 +16134,30 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15155,7 +16189,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.
@@ -15181,6 +16215,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15222,6 +16260,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15268,6 +16310,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15446,6 +16492,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15617,6 +16683,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15673,6 +16759,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15714,6 +16804,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15755,6 +16849,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -15830,6 +16928,14 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15911,6 +17017,14 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -15961,6 +17075,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -16006,6 +17124,10 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -16168,6 +17290,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16350,6 +17492,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16501,6 +17663,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16647,6 +17825,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16822,6 +18016,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -16992,6 +18206,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17167,6 +18401,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17344,6 +18598,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17519,6 +18793,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17687,6 +18981,26 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -17833,6 +19147,22 @@ var TreeMultiMap = class _TreeMultiMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18053,8 +19383,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 }
@@ -18077,6 +19415,26 @@ var TreeMultiMap = class _TreeMultiMap {
    
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
      * @example
   * // Deep clone
@@ -18330,6 +19688,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18507,6 +19885,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18554,6 +19952,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)
@@ -18705,6 +20138,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -18893,6 +20346,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19081,6 +20554,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19117,8 +20610,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.
@@ -19259,6 +20768,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19428,6 +20957,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19601,6 +21150,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19771,6 +21340,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -19944,6 +21533,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20117,6 +21726,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20293,6 +21922,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20469,6 +22118,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20639,6 +22308,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20811,6 +22500,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -20984,6 +22693,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21158,6 +22887,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21327,6 +23076,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21390,6 +23159,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21458,6 +23231,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21510,6 +23287,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21566,6 +23347,10 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -21709,6 +23494,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -21882,6 +23683,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22039,6 +23856,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22196,6 +24029,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22354,6 +24203,22 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22461,8 +24326,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 }
@@ -22621,6 +24494,26 @@ var TreeMap = class _TreeMap {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -22744,6 +24637,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -22899,6 +24796,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23070,6 +24987,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23126,6 +25063,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -23276,6 +25217,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23341,6 +25302,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -23509,6 +25474,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23575,6 +25560,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -23619,6 +25608,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -23774,6 +25767,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -23955,6 +25968,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -24010,6 +26043,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24049,6 +26086,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24213,6 +26254,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -24271,6 +26332,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24311,6 +26376,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24351,6 +26420,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24395,6 +26468,10 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
     
     
     
@@ -24525,6 +26602,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -24666,6 +26759,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -24807,6 +26916,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -24947,6 +27072,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -25117,6 +27258,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -25293,6 +27454,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -25476,6 +27657,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -25654,6 +27855,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -25884,8 +28105,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 }
@@ -25907,6 +28136,26 @@ var TreeMultiSet = class _TreeMultiSet {
    
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
      * @example
   * // Deep clone
@@ -26039,6 +28288,22 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -26210,6 +28475,26 @@ var TreeMultiSet = class _TreeMultiSet {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+