data-structure-typed 2.2.7 → 2.3.0

package/dist/esm/index.mjs

@@ -1402,6 +1402,12 @@ var LinearLinkedBase = class extends LinearBase {
     }
     return -1;
   }
+  /**
+   * Concatenate lists/elements preserving order.
+   * @param items - Elements or `LinearBase` instances.
+   * @returns New list with combined elements (`this` type).
+   * @remarks Time O(sum(length)), Space O(sum(length))
+   */
   concat(...items) {
     const newList = this.clone();
     for (const item of items) {
@@ -4228,6 +4234,12 @@ var Deque = class extends LinearBase {
    */
   _setBucketSize(size) {
     this._bucketSize = size;
+    if (this._length === 0) {
+      this._buckets = [new Array(this._bucketSize)];
+      this._bucketCount = 1;
+      this._bucketFirst = this._bucketLast = 0;
+      this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
+    }
   }
   /**
    * (Protected) Iterate elements from front to back.
@@ -6993,9 +7005,9 @@ var BinaryTree = class extends IterableEntryBase {
   iterationType = "ITERATIVE";
   /**
    * Creates an instance of BinaryTree.
-   * @remarks Time O(N * M), where N is the number of items in `keysNodesEntriesOrRaws` and M is the tree size at insertion time (due to O(M) `add` operation). Space O(N) for storing the nodes.
+   * @remarks Time O(N * M), where N is the number of items in `keysNodesEntriesOrRaws` and M is the tree size at insertion time (due to O(M) `set` operation). Space O(N) for storing the nodes.
    *
-   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to set.
    * @param [options] - Configuration options for the tree.
    */
   constructor(keysNodesEntriesOrRaws = [], options) {
@@ -7008,7 +7020,7 @@ var BinaryTree = class extends IterableEntryBase {
       if (typeof toEntryFn === "function") this._toEntryFn = toEntryFn;
       else if (toEntryFn) throw TypeError("toEntryFn must be a function type");
     }
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
   _isMapMode = true;
   /**
@@ -7222,10 +7234,20 @@ var BinaryTree = class extends IterableEntryBase {
    * @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).
    *
    * @param keyNodeOrEntry - The key, node, or entry to add.
+   * @returns True if the addition was successful, false otherwise.
+   */
+  add(keyNodeOrEntry) {
+    return this.set(keyNodeOrEntry);
+  }
+  /**
+   * 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).
+   *
+   * @param keyNodeOrEntry - The key, node, or entry to set or update.
    * @param [value] - The value, if providing just a key.
    * @returns True if the addition was successful, false otherwise.
    */
-  add(keyNodeOrEntry, value) {
+  set(keyNodeOrEntry, value) {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === void 0) return false;
     if (!this._root) {
@@ -7269,25 +7291,24 @@ var BinaryTree = class extends IterableEntryBase {
     return false;
   }
   /**
-   * 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 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).
+   * Adds multiple items to the tree.
+   * @remarks Time O(N * M), where N is the number of items to set and M is the size of the tree at insertion (due to O(M) `set` operation). Space O(M) (from `set`) + O(N) (for the `inserted` array).
    *
-   * @param keyNodeOrEntry - The key, node, or entry to add or update.
-   * @param [value] - The value, if providing just a key.
-   * @returns True if the addition was successful, false otherwise.
+   * @param keysNodesEntriesOrRaws - An iterable of items to set.
+   * @returns An array of booleans indicating the success of each individual `set` operation.
    */
-  set(keyNodeOrEntry, value) {
-    return this.add(keyNodeOrEntry, value);
+  addMany(keysNodesEntriesOrRaws) {
+    return this.setMany(keysNodesEntriesOrRaws);
   }
   /**
-   * Adds multiple items to the tree.
-   * @remarks Time O(N * M), where N is the number of items to add and M is the size of the tree at insertion (due to O(M) `add` operation). Space O(M) (from `add`) + O(N) (for the `inserted` array).
+   * Adds or updates multiple items to the tree.
+   * @remarks Time O(N * M), where N is the number of items to set and M is the size of the tree at insertion (due to O(M) `set` operation). Space O(M) (from `set`) + O(N) (for the `inserted` array).
    *
-   * @param keysNodesEntriesOrRaws - An iterable of items to add.
+   * @param keysNodesEntriesOrRaws - An iterable of items to set or update.
    * @param [values] - An optional parallel iterable of values.
-   * @returns An array of booleans indicating the success of each individual `add` operation.
+   * @returns An array of booleans indicating the success of each individual `set` operation.
    */
-  addMany(keysNodesEntriesOrRaws, values) {
+  setMany(keysNodesEntriesOrRaws, values) {
     const inserted = [];
     let valuesIterator;
     if (values) {
@@ -7302,52 +7323,41 @@ var BinaryTree = class extends IterableEntryBase {
         }
       }
       if (this.isRaw(keyNodeEntryOrRaw)) keyNodeEntryOrRaw = this._toEntryFn(keyNodeEntryOrRaw);
-      inserted.push(this.add(keyNodeEntryOrRaw, value));
+      inserted.push(this.set(keyNodeEntryOrRaw, value));
     }
     return inserted;
   }
   /**
-   * Adds or updates multiple items to the tree.
-   * @remarks Time O(N * M), where N is the number of items to add and M is the size of the tree at insertion (due to O(M) `add` operation). Space O(M) (from `add`) + O(N) (for the `inserted` array).
-   *
-   * @param keysNodesEntriesOrRaws - An iterable of items to add or update.
-   * @param [values] - An optional parallel iterable of values.
-   * @returns An array of booleans indicating the success of each individual `add` operation.
-   */
-  setMany(keysNodesEntriesOrRaws, values) {
-    return this.addMany(keysNodesEntriesOrRaws, values);
-  }
-  /**
-   * Merges another tree into this one by adding all its nodes.
-   * @remarks Time O(N * M), same as `addMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `add`).
+   * Merges another tree into this one by seting all its nodes.
+   * @remarks Time O(N * M), same as `setMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `set`).
    *
    * @param anotherTree - The tree to merge.
    */
   merge(anotherTree) {
-    this.addMany(anotherTree, []);
+    this.setMany(anotherTree, []);
   }
   /**
    * Clears the tree and refills it with new items.
-   * @remarks Time O(N) (for `clear`) + O(N * M) (for `addMany`) = O(N * M). Space O(M) (from `addMany`).
+   * @remarks Time O(N) (for `clear`) + O(N * M) (for `setMany`) = O(N * M). Space O(M) (from `setMany`).
    *
-   * @param keysNodesEntriesOrRaws - An iterable of items to add.
+   * @param keysNodesEntriesOrRaws - An iterable of items to set.
    * @param [values] - An optional parallel iterable of values.
    */
   refill(keysNodesEntriesOrRaws, values) {
     this.clear();
-    this.addMany(keysNodesEntriesOrRaws, values);
+    this.setMany(keysNodesEntriesOrRaws, values);
   }
   /**
    * 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).
    *
-   * @param keyNodeOrEntry - The node to delete.
+   * @param keyNodeEntryRawOrPredicate - The node to delete.
    * @returns An array containing deletion results (for compatibility with self-balancing trees).
    */
-  delete(keyNodeOrEntry) {
+  delete(keyNodeEntryRawOrPredicate) {
     const deletedResult = [];
     if (!this._root) return deletedResult;
-    const curr = this.getNode(keyNodeOrEntry);
+    const curr = this.getNode(keyNodeEntryRawOrPredicate);
     if (!curr) return deletedResult;
     const parent = curr?.parent;
     let needBalanced;
@@ -7530,7 +7540,7 @@ var BinaryTree = class extends IterableEntryBase {
         }
         return true;
       }, "checkBST");
-      const isStandardBST = checkBST(false);
+      const isStandardBST = checkBST();
       const isInverseBST = checkBST(true);
       return isStandardBST || isInverseBST;
     }
@@ -8000,7 +8010,7 @@ var BinaryTree = class extends IterableEntryBase {
   }
   /**
    * Clones the tree.
-   * @remarks Time O(N * M), where N is the number of nodes and M is the tree size during insertion (due to `bfs` + `add`, and `add` is O(M)). Space O(N) for the new tree and the BFS queue.
+   * @remarks Time O(N * M), where N is the number of nodes and M is the tree size during insertion (due to `bfs` + `set`, and `set` is O(M)). Space O(N) for the new tree and the BFS queue.
    *
    * @returns A new, cloned instance of the tree.
    */
@@ -8011,7 +8021,7 @@ var BinaryTree = class extends IterableEntryBase {
   }
   /**
    * Creates a new tree containing only the entries that satisfy the predicate.
-   * @remarks Time O(N * M), where N is nodes in this tree, and M is size of the new tree during insertion (O(N) iteration + O(M) `add` for each item). Space O(N) for the new tree.
+   * @remarks Time O(N * M), where N is nodes in this tree, and M is size of the new tree during insertion (O(N) iteration + O(M) `set` for each item). Space O(N) for the new tree.
    *
    * @param predicate - A function to test each [key, value] pair.
    * @param [thisArg] - `this` context for the predicate.
@@ -8020,7 +8030,7 @@ var BinaryTree = class extends IterableEntryBase {
   filter(predicate, thisArg) {
     const out = this._createInstance();
     let i = 0;
-    for (const [k, v] of this) if (predicate.call(thisArg, v, k, i++, this)) out.add([k, v]);
+    for (const [k, v] of this) if (predicate.call(thisArg, v, k, i++, this)) out.set([k, v]);
     return out;
   }
   /**
@@ -8038,7 +8048,7 @@ var BinaryTree = class extends IterableEntryBase {
   map(cb, options, thisArg) {
     const out = this._createLike([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(cb.call(thisArg, v, k, i++, this));
+    for (const [k, v] of this) out.set(cb.call(thisArg, v, k, i++, this));
     return out;
   }
   /**
@@ -8290,18 +8300,18 @@ var BinaryTree = class extends IterableEntryBase {
     return [this.createNode(keyNodeOrEntry, value), value];
   }
   /**
-   * (Protected) Helper for cloning. Performs a BFS and adds all nodes to the new tree.
-   * @remarks Time O(N * M) (O(N) BFS + O(M) `add` for each node).
+   * (Protected) Helper for cloning. Performs a BFS and sets all nodes to the new tree.
+   * @remarks Time O(N * M) (O(N) BFS + O(M) `set` for each node).
    *
    * @param cloned - The new, empty tree instance to populate.
    */
   _clone(cloned) {
     this.bfs(
       (node) => {
-        if (node === null) cloned.add(null);
+        if (node === null) cloned.set(null);
         else {
-          if (this._isMapMode) cloned.add([node.key, this._store.get(node.key)]);
-          else cloned.add([node.key, node.value]);
+          if (this._isMapMode) cloned.set([node.key, this._store.get(node.key)]);
+          else cloned.set([node.key, node.value]);
         }
       },
       this._root,
@@ -8634,7 +8644,7 @@ var BST = class extends BinaryTree {
    * Creates an instance of BST.
    * @remarks Time O(N log N) or O(N^2) depending on `isBalanceAdd` in `addMany` and input order. Space O(N).
    *
-   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to set.
    * @param [options] - Configuration options for the BST, including comparator.
    */
   constructor(keysNodesEntriesOrRaws = [], options) {
@@ -8648,7 +8658,7 @@ var BST = class extends BinaryTree {
     } else {
       this._comparator = this._createDefaultComparator();
     }
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
   _root = void 0;
   /**
@@ -8768,7 +8778,39 @@ var BST = class extends BinaryTree {
    * @returns The first matching node, or undefined if not found.
    */
   getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? void 0;
+    if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) return void 0;
+    if (this._isPredicate(keyNodeEntryOrPredicate)) {
+      return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? void 0;
+    }
+    if (keyNodeEntryOrPredicate instanceof Range) {
+      return this.getNodes(
+        keyNodeEntryOrPredicate,
+        true,
+        startNode,
+        iterationType
+      )[0] ?? void 0;
+    }
+    let targetKey;
+    if (this.isNode(keyNodeEntryOrPredicate)) {
+      targetKey = keyNodeEntryOrPredicate.key;
+    } else if (this.isEntry(keyNodeEntryOrPredicate)) {
+      const k = keyNodeEntryOrPredicate[0];
+      if (k === null || k === void 0) return void 0;
+      targetKey = k;
+    } else {
+      targetKey = keyNodeEntryOrPredicate;
+    }
+    const start = this.ensureNode(startNode);
+    if (!start) return void 0;
+    const NIL = this._NIL;
+    let cur = start;
+    const cmpFn = this._comparator;
+    while (cur && cur !== NIL) {
+      const c = cmpFn(targetKey, cur.key);
+      if (c === 0) return cur;
+      cur = c < 0 ? cur._left : cur._right;
+    }
+    return void 0;
   }
   /**
    * Searches the tree for nodes matching a predicate, key, or range.
@@ -8789,8 +8831,30 @@ var BST = class extends BinaryTree {
     if (keyNodeEntryOrPredicate === null) return [];
     startNode = this.ensureNode(startNode);
     if (!startNode) return [];
-    let predicate;
     const isRange = this.isRange(keyNodeEntryOrPredicate);
+    const isPred = !isRange && this._isPredicate(keyNodeEntryOrPredicate);
+    if (!isRange && !isPred) {
+      let targetKey;
+      if (this.isNode(keyNodeEntryOrPredicate)) {
+        targetKey = keyNodeEntryOrPredicate.key;
+      } else if (this.isEntry(keyNodeEntryOrPredicate)) {
+        const k = keyNodeEntryOrPredicate[0];
+        if (k !== null && k !== void 0) targetKey = k;
+      } else {
+        targetKey = keyNodeEntryOrPredicate;
+      }
+      if (targetKey === void 0) return [];
+      const NIL = this._NIL;
+      const cmpFn = this._comparator;
+      let cur = startNode;
+      while (cur && cur !== NIL) {
+        const c = cmpFn(targetKey, cur.key);
+        if (c === 0) return [callback(cur)];
+        cur = c < 0 ? cur._left : cur._right;
+      }
+      return [];
+    }
+    let predicate;
     if (isRange) {
       predicate = /* @__PURE__ */ __name((node) => {
         if (!node) return false;
@@ -8864,11 +8928,11 @@ var BST = class extends BinaryTree {
    * Adds a new node to the BST based on key comparison.
    * @remarks Time O(log N), where H is tree height. O(N) worst-case (unbalanced tree), O(log N) average. Space O(1).
    *
-   * @param keyNodeOrEntry - The key, node, or entry to add.
+   * @param keyNodeOrEntry - The key, node, or entry to set.
    * @param [value] - The value, if providing just a key.
    * @returns True if the addition was successful, false otherwise.
    */
-  add(keyNodeOrEntry, value) {
+  set(keyNodeOrEntry, value) {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === void 0) return false;
     if (this._root === void 0) {
@@ -8905,24 +8969,24 @@ var BST = class extends BinaryTree {
   }
   /**
    * Adds multiple items to the tree.
-   * @remarks If `isBalanceAdd` is true, sorts the input and builds a balanced tree. Time O(N log N) (due to sort and balanced add).
+   * @remarks If `isBalanceAdd` is true, sorts the input and builds a balanced tree. Time O(N log N) (due to sort and balanced set).
    * If false, adds items one by one. Time O(N * H), which is O(N^2) worst-case.
    * Space O(N) for sorting and recursion/iteration stack.
    *
-   * @param keysNodesEntriesOrRaws - An iterable of items to add.
+   * @param keysNodesEntriesOrRaws - An iterable of items to set.
    * @param [values] - An optional parallel iterable of values.
    * @param [isBalanceAdd=true] - If true, builds a balanced tree from the items.
-   * @param [iterationType=this.iterationType] - The traversal method for balanced add (recursive or iterative).
-   * @returns An array of booleans indicating the success of each individual `add` operation.
+   * @param [iterationType=this.iterationType] - The traversal method for balanced set (recursive or iterative).
+   * @returns An array of booleans indicating the success of each individual `set` operation.
    */
-  addMany(keysNodesEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
+  setMany(keysNodesEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
     const inserted = [];
     const valuesIterator = values?.[Symbol.iterator]();
     if (!isBalanceAdd) {
       for (let kve of keysNodesEntriesOrRaws) {
         const val = valuesIterator?.next().value;
         if (this.isRaw(kve)) kve = this._toEntryFn(kve);
-        inserted.push(this.add(kve, val));
+        inserted.push(this.set(kve, val));
       }
       return inserted;
     }
@@ -8950,9 +9014,9 @@ var BST = class extends BinaryTree {
       const { key, value, orgIndex } = arr[mid];
       if (this.isRaw(key)) {
         const entry = this._toEntryFn(key);
-        inserted[orgIndex] = this.add(entry);
+        inserted[orgIndex] = this.set(entry);
       } else {
-        inserted[orgIndex] = this.add(key, value);
+        inserted[orgIndex] = this.set(key, value);
       }
       _dfs(arr.slice(0, mid));
       _dfs(arr.slice(mid + 1));
@@ -8969,9 +9033,9 @@ var BST = class extends BinaryTree {
         const { key, value, orgIndex } = sorted[m];
         if (this.isRaw(key)) {
           const entry = this._toEntryFn(key);
-          inserted[orgIndex] = this.add(entry);
+          inserted[orgIndex] = this.set(entry);
         } else {
-          inserted[orgIndex] = this.add(key, value);
+          inserted[orgIndex] = this.set(key, value);
         }
         stack.push([m + 1, r]);
         stack.push([l, m - 1]);
@@ -9246,7 +9310,7 @@ var BST = class extends BinaryTree {
     const out = this._createLike([], options);
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }
@@ -9712,7 +9776,7 @@ var BST = class extends BinaryTree {
       succ.left = node.left;
       if (succ.left) succ.left.parent = succ;
     }
-    this._size = Math.max(0, (this._size ?? 0) - 1);
+    this._size = Math.max(0, this._size - 1);
     return true;
   }
 };
@@ -10433,14 +10497,14 @@ var AVLTree = class extends BST {
   }
   /**
    * Creates an instance of AVLTree.
-   * @remarks Time O(N log N) (from `addMany` with balanced add). Space O(N).
+   * @remarks Time O(N log N) (from `setMany` with balanced set). Space O(N).
    *
-   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to set.
    * @param [options] - Configuration options for the AVL tree.
    */
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], options);
-    if (keysNodesEntriesOrRaws) super.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) super.setMany(keysNodesEntriesOrRaws);
   }
   /**
    * (Protected) Creates a new AVL tree node.
@@ -10464,16 +10528,16 @@ var AVLTree = class extends BST {
     return keyNodeOrEntry instanceof AVLTreeNode;
   }
   /**
-   * Adds a new node to the AVL tree and balances the tree path.
-   * @remarks Time O(log N) (O(H) for BST add + O(H) for `_balancePath`). Space O(H) for path/recursion.
+   * Sets a new node to the AVL tree and balances the tree path.
+   * @remarks Time O(log N) (O(H) for BST set + O(H) for `_balancePath`). Space O(H) for path/recursion.
    *
-   * @param keyNodeOrEntry - The key, node, or entry to add.
+   * @param keyNodeOrEntry - The key, node, or entry to set.
    * @param [value] - The value, if providing just a key.
    * @returns True if the addition was successful, false otherwise.
    */
-  add(keyNodeOrEntry, value) {
+  set(keyNodeOrEntry, value) {
     if (keyNodeOrEntry === null) return false;
-    const inserted = super.add(keyNodeOrEntry, value);
+    const inserted = super.set(keyNodeOrEntry, value);
     if (inserted) this._balancePath(keyNodeOrEntry);
     return inserted;
   }
@@ -10525,7 +10589,7 @@ var AVLTree = class extends BST {
   }
   /**
    * Creates a new AVLTree by mapping each [key, value] pair.
-   * @remarks Time O(N log N) (O(N) iteration + O(log M) `add` for each item into the new tree). Space O(N) for the new tree.
+   * @remarks Time O(N log N) (O(N) iteration + O(log M) `set` for each item into the new tree). Space O(N) for the new tree.
    *
    * @template MK - New key type.
    * @template MV - New value type.
@@ -10539,7 +10603,7 @@ var AVLTree = class extends BST {
     const out = this._createLike([], options);
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }
@@ -10828,12 +10892,11 @@ var RedBlackTreeNode = class {
   value;
   parent = void 0;
   /**
-   * Create a Red-Black Tree and optionally bulk-insert items.
-   * @remarks Time O(n log n), Space O(n)
-   * @param key - See parameter type for details.
-   * @param [value]- See parameter type for details.
-   * @param color - See parameter type for details.
-   * @returns New RedBlackTree instance.
+   * Create a Red-Black Tree node.
+   * @remarks Time O(1), Space O(1)
+   * @param key - Node key.
+   * @param [value] - Node value (unused in map mode trees).
+   * @param color - Node color.
    */
   constructor(key, value, color = "BLACK") {
     this.key = key;
@@ -10964,11 +11027,33 @@ var RedBlackTree = class extends BST {
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], options);
     this._root = this.NIL;
+    this._header = new RedBlackTreeNode(void 0, void 0, "BLACK");
+    this._header.parent = this.NIL;
+    this._header._left = this.NIL;
+    this._header._right = this.NIL;
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
   _root;
+  /**
+   * (Internal) Header sentinel:
+   * - header.parent -> root
+   * - header._left  -> min (or NIL)
+   * - header._right -> max (or NIL)
+   *
+   * IMPORTANT:
+   * - This header is NOT part of the actual tree.
+   * - Do NOT use `header.left` / `header.right` accessors for wiring: those setters update `NIL.parent`
+   *   and can corrupt sentinel invariants / cause hangs. Only touch `header._left/_right`.
+   */
+  _header;
+  /**
+   * (Internal) Cache of the current minimum and maximum nodes.
+   * Used for fast-path insert/update when keys are monotonic or near-boundary.
+   */
+  _minNode;
+  _maxNode;
   /**
    * Get the current root node.
    * @remarks Time O(1), Space O(1)
@@ -11002,18 +11087,387 @@ var RedBlackTree = class extends BST {
    * @remarks Time O(n), Space O(1)
    * @returns void
    */
+  /**
+   * Remove all nodes and clear internal caches.
+   * @remarks Time O(n) average, Space O(1)
+   */
   clear() {
     super.clear();
     this._root = this.NIL;
+    this._header.parent = this.NIL;
+    this._setMinCache(void 0);
+    this._setMaxCache(void 0);
   }
   /**
-   * Insert or replace an entry using BST order and red-black fix-up.
-   * @remarks Time O(log n), Space O(1)
-   * @param keyNodeOrEntry - Key, node, or [key, value] entry to insert.
-   * @param [value]- See parameter type for details.
-   * @returns True if inserted or updated; false if ignored.
+   * (Internal) Find a node by key using a tight BST walk (no allocations).
+   *
+   * NOTE: This uses `header.parent` as the canonical root pointer.
+   * @remarks Time O(log n) average, Space O(1)
+   */
+  _findNodeByKey(key) {
+    const NIL = this.NIL;
+    const cmp = this._compare.bind(this);
+    let cur = this._header.parent ?? NIL;
+    while (cur !== NIL) {
+      const c = cmp(key, cur.key);
+      if (c < 0) cur = cur.left ?? NIL;
+      else if (c > 0) cur = cur.right ?? NIL;
+      else return cur;
+    }
+    return void 0;
+  }
+  /**
+   * (Internal) In-order predecessor of a node in a BST.
+   * @remarks Time O(log n) average, Space O(1)
+   */
+  _predecessorOf(node) {
+    const NIL = this.NIL;
+    if (node.left && node.left !== NIL) {
+      let cur2 = node.left;
+      while (cur2.right && cur2.right !== NIL) cur2 = cur2.right;
+      return cur2;
+    }
+    let cur = node;
+    let p = node.parent;
+    while (p && cur === p.left) {
+      cur = p;
+      p = p.parent;
+    }
+    return p;
+  }
+  /**
+   * (Internal) In-order successor of a node in a BST.
+   * @remarks Time O(log n) average, Space O(1)
+   */
+  _successorOf(node) {
+    const NIL = this.NIL;
+    if (node.right && node.right !== NIL) {
+      let cur2 = node.right;
+      while (cur2.left && cur2.left !== NIL) cur2 = cur2.left;
+      return cur2;
+    }
+    let cur = node;
+    let p = node.parent;
+    while (p && cur === p.right) {
+      cur = p;
+      p = p.parent;
+    }
+    return p;
+  }
+  /**
+   * (Internal) Attach a new node directly under a known parent/side (no search).
+   *
+   * This is a performance-oriented helper used by boundary fast paths and hinted insertion.
+   * It will:
+   * - wire parent/child pointers (using accessors, so parent pointers are updated)
+   * - initialize children to NIL
+   * - mark the new node RED, then run insert fix-up
+   *
+   * Precondition: the chosen slot (parent.left/parent.right) is empty (NIL/null/undefined).
+   * @remarks Time O(log n) average, Space O(1)
+   */
+  _attachNewNode(parent, side, node) {
+    const NIL = this.NIL;
+    node.parent = parent;
+    if (side === "left") parent.left = node;
+    else parent.right = node;
+    node.left = NIL;
+    node.right = NIL;
+    node.color = "RED";
+    this._insertFixup(node);
+    if (this.isRealNode(this._root)) this._root.color = "BLACK";
+  }
+  /**
+   * (Internal) a single source of truth for min/max is header._left/_right.
+   * Keep legacy _minNode/_maxNode mirrored for compatibility.
+   * @remarks Time O(1), Space O(1)
+   */
+  /**
+   * (Internal) Update min cache pointers (header._left is the canonical min pointer).
+   * @remarks Time O(1), Space O(1)
+   */
+  _setMinCache(node) {
+    this._minNode = node;
+    this._header._left = node ?? this.NIL;
+  }
+  /**
+   * (Internal) Update max cache pointers (header._right is the canonical max pointer).
+   * @remarks Time O(1), Space O(1)
+   */
+  _setMaxCache(node) {
+    this._maxNode = node;
+    this._header._right = node ?? this.NIL;
+  }
+  /**
+   * (Internal) Core set implementation returning the affected node.
+   *
+   * Hot path goals:
+   * - Avoid double walks (search+insert): do a single traversal that either updates or inserts.
+   * - Use header min/max caches to fast-path boundary inserts.
+   * - Keep header._left/_right as canonical min/max pointers.
+   *
+   * Return value:
+   * - `{ node, created:false }` when an existing key is updated
+   * - `{ node, created:true }` when a new node is inserted
+   * - `undefined` only on unexpected internal failure.
+   * @remarks Time O(log n) average, Space O(1)
+   */
+  _setKVNode(key, nextValue) {
+    const NIL = this.NIL;
+    const comparator = this._comparator;
+    const header = this._header;
+    const minN = header._left ?? NIL;
+    if (minN !== NIL) {
+      const cMin = comparator(key, minN.key);
+      if (cMin === 0) {
+        if (this._isMapMode) {
+          if (nextValue !== void 0) this._store.set(key, nextValue);
+          else this._setValue(key, nextValue);
+        } else minN.value = nextValue;
+        return { node: minN, created: false };
+      }
+      const minL = minN.left;
+      if (cMin < 0 && (minL === NIL || minL === null || minL === void 0)) {
+        const newNode2 = this.createNode(key, nextValue);
+        this._attachNewNode(minN, "left", newNode2);
+        if (this._isMapMode) {
+          if (nextValue !== void 0) this._store.set(newNode2.key, nextValue);
+          else this._setValue(newNode2.key, nextValue);
+        }
+        this._size++;
+        this._setMinCache(newNode2);
+        if (header._right === NIL) this._setMaxCache(newNode2);
+        return { node: newNode2, created: true };
+      }
+      if (cMin > 0) {
+        const maxN = header._right ?? NIL;
+        const cMax = comparator(key, maxN.key);
+        if (cMax === 0) {
+          if (this._isMapMode) {
+            if (nextValue !== void 0) this._store.set(key, nextValue);
+            else this._setValue(key, nextValue);
+          } else maxN.value = nextValue;
+          return { node: maxN, created: false };
+        }
+        const maxR = maxN.right;
+        if (cMax > 0 && (maxR === NIL || maxR === null || maxR === void 0)) {
+          const newNode2 = this.createNode(key, nextValue);
+          this._attachNewNode(maxN, "right", newNode2);
+          if (this._isMapMode) {
+            if (nextValue !== void 0) this._store.set(newNode2.key, nextValue);
+            else this._setValue(newNode2.key, nextValue);
+          }
+          this._size++;
+          this._setMaxCache(newNode2);
+          if (header._left === NIL) this._setMinCache(newNode2);
+          return { node: newNode2, created: true };
+        }
+      }
+    }
+    const cmp = comparator;
+    const isMapMode = this._isMapMode;
+    const store = this._store;
+    let current = this._header.parent ?? NIL;
+    let parent;
+    let lastCompared = 0;
+    while (current !== NIL) {
+      parent = current;
+      lastCompared = cmp(key, current.key);
+      if (lastCompared < 0) current = current.left ?? NIL;
+      else if (lastCompared > 0) current = current.right ?? NIL;
+      else {
+        if (isMapMode) {
+          if (nextValue !== void 0) store.set(key, nextValue);
+          else this._setValue(key, nextValue);
+        } else {
+          current.value = nextValue;
+        }
+        return { node: current, created: false };
+      }
+    }
+    const newNode = this.createNode(key, nextValue);
+    newNode.parent = parent;
+    if (!parent) {
+      this._setRoot(newNode);
+    } else if (lastCompared < 0) {
+      parent.left = newNode;
+    } else {
+      parent.right = newNode;
+    }
+    newNode.left = NIL;
+    newNode.right = NIL;
+    newNode.color = "RED";
+    this._insertFixup(newNode);
+    if (this.isRealNode(this._root)) this._root.color = "BLACK";
+    else return void 0;
+    if (isMapMode) {
+      if (nextValue !== void 0) store.set(newNode.key, nextValue);
+      else this._setValue(newNode.key, nextValue);
+    }
+    this._size++;
+    const hMin = this._header._left ?? NIL;
+    const hMax = this._header._right ?? NIL;
+    if (hMin === NIL || hMax === NIL) {
+      this._setMinCache(newNode);
+      this._setMaxCache(newNode);
+    } else if (parent === hMax && lastCompared > 0) {
+      this._setMaxCache(newNode);
+    } else if (parent === hMin && lastCompared < 0) {
+      this._setMinCache(newNode);
+    } else {
+      if (cmp(newNode.key, hMin.key) < 0) this._setMinCache(newNode);
+      if (cmp(newNode.key, hMax.key) > 0) this._setMaxCache(newNode);
+    }
+    return { node: newNode, created: true };
+  }
+  /**
+   * (Internal) Boolean wrapper around `_setKVNode`.
+   *
+   * Includes a map-mode update fast-path:
+   * - If `isMapMode=true` and the key already exists in `_store`, then updating the value does not
+   *   require any tree search/rotation (tree shape depends only on key).
+   * - This path is intentionally limited to `nextValue !== undefined` to preserve existing
+   *   semantics for `undefined` values.
+   * @remarks Time O(log n) average, Space O(1)
+   */
+  _setKV(key, nextValue) {
+    if (this._isMapMode && nextValue !== void 0) {
+      const store = this._store;
+      if (store.has(key)) {
+        store.set(key, nextValue);
+        return true;
+      }
+    }
+    return this._setKVNode(key, nextValue) !== void 0;
+  }
+  /**
+   * Insert/update using a hint node to speed up nearby insertions.
+   *
+   * close to the expected insertion position (often the previously returned node in a loop).
+   *
+   * When the hint is a good fit (sorted / nearly-sorted insertion), this can avoid most of the
+   * normal root-to-leaf search and reduce constant factors.
+   *
+   * When the hint does not match (random workloads), this will fall back to the normal set path.
+   * @remarks Time O(log n) average, Space O(1)
    */
-  add(keyNodeOrEntry, value) {
+  setWithHintNode(key, value, hint) {
+    if (!hint || !this.isRealNode(hint)) {
+      return this._setKVNode(key, value)?.node;
+    }
+    const cmp = this._compare.bind(this);
+    const c0 = cmp(key, hint.key);
+    if (c0 === 0) {
+      if (this._isMapMode) {
+        if (value !== void 0) this._store.set(key, value);
+        else this._setValue(key, value);
+      } else hint.value = value;
+      return hint;
+    }
+    if (c0 < 0) {
+      if (!this.isRealNode(hint.left)) {
+        const newNode = this.createNode(key, value);
+        if (!this.isRealNode(newNode)) return void 0;
+        this._attachNewNode(hint, "left", newNode);
+        if (this._isMapMode) {
+          if (value !== void 0) this._store.set(key, value);
+          else this._setValue(key, value);
+        }
+        this._size++;
+        const NIL = this.NIL;
+        const hMin = this._header._left ?? NIL;
+        if (hMin === NIL || this._compare(newNode.key, hMin.key) < 0) this._setMinCache(newNode);
+        const hMax = this._header._right ?? NIL;
+        if (hMax === NIL || this._compare(newNode.key, hMax.key) > 0) this._setMaxCache(newNode);
+        return newNode;
+      }
+      const pred = this._predecessorOf(hint);
+      if (pred && cmp(pred.key, key) >= 0) {
+        return this._setKVNode(key, value)?.node;
+      }
+      if (pred && !this.isRealNode(pred.right)) {
+        const newNode = this.createNode(key, value);
+        if (!this.isRealNode(newNode)) return void 0;
+        this._attachNewNode(pred, "right", newNode);
+        if (this._isMapMode) {
+          if (value !== void 0) this._store.set(key, value);
+          else this._setValue(key, value);
+        }
+        this._size++;
+        const NIL = this.NIL;
+        const hMin = this._header._left ?? NIL;
+        if (hMin === NIL || this._compare(newNode.key, hMin.key) < 0) this._setMinCache(newNode);
+        const hMax = this._header._right ?? NIL;
+        if (hMax === NIL || this._compare(newNode.key, hMax.key) > 0) this._setMaxCache(newNode);
+        return newNode;
+      }
+      return this._setKVNode(key, value)?.node;
+    }
+    if (!this.isRealNode(hint.right)) {
+      const newNode = this.createNode(key, value);
+      if (!this.isRealNode(newNode)) return void 0;
+      this._attachNewNode(hint, "right", newNode);
+      if (this._isMapMode) {
+        if (value !== void 0) this._store.set(key, value);
+        else this._setValue(key, value);
+      }
+      this._size++;
+      const NIL = this.NIL;
+      const hMin = this._header._left ?? NIL;
+      if (hMin === NIL || this._compare(newNode.key, hMin.key) < 0) this._setMinCache(newNode);
+      const hMax = this._header._right ?? NIL;
+      if (hMax === NIL || this._compare(newNode.key, hMax.key) > 0) this._setMaxCache(newNode);
+      return newNode;
+    }
+    const succ = this._successorOf(hint);
+    if (succ && cmp(succ.key, key) <= 0) {
+      return this._setKVNode(key, value)?.node;
+    }
+    if (succ && !this.isRealNode(succ.left)) {
+      const newNode = this.createNode(key, value);
+      if (!this.isRealNode(newNode)) return void 0;
+      this._attachNewNode(succ, "left", newNode);
+      if (this._isMapMode) {
+        if (value !== void 0) this._store.set(key, value);
+        else this._setValue(key, value);
+      }
+      this._size++;
+      const NIL = this.NIL;
+      const hMin = this._header._left ?? NIL;
+      if (hMin === NIL || this._compare(newNode.key, hMin.key) < 0) this._setMinCache(newNode);
+      const hMax = this._header._right ?? NIL;
+      if (hMax === NIL || this._compare(newNode.key, hMax.key) > 0) this._setMaxCache(newNode);
+      return newNode;
+    }
+    return this._setKVNode(key, value)?.node;
+  }
+  /**
+   * Boolean wrapper for setWithHintNode.
+   * @remarks Time O(log n) average, Space O(1)
+   */
+  setWithHint(key, value, hint) {
+    return this.setWithHintNode(key, value, hint) !== void 0;
+  }
+  /**
+   * Insert or update a key/value (map mode) or key-only (set mode).
+   *
+   * This method is optimized for:
+   * - monotonic inserts via min/max boundary fast paths
+   * - updates via a single-pass search (no double walk)
+   *
+   * @remarks Time O(log n) average, Space O(1)
+   */
+  set(keyNodeOrEntry, value) {
+    if (!this.isNode(keyNodeOrEntry)) {
+      if (keyNodeOrEntry === null || keyNodeOrEntry === void 0) return false;
+      if (this.isEntry(keyNodeOrEntry)) {
+        const key = keyNodeOrEntry[0];
+        if (key === null || key === void 0) return false;
+        const nextValue = value ?? keyNodeOrEntry[1];
+        return this._setKV(key, nextValue);
+      }
+      return this._setKV(keyNodeOrEntry, value);
+    }
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (!this.isRealNode(newNode)) return false;
     const insertStatus = this._insert(newNode);
@@ -11035,19 +11489,23 @@ var RedBlackTree = class extends BST {
   }
   /**
    * Delete a node by key/node/entry and rebalance as needed.
-   * @remarks Time O(log n), Space O(1)
-   * @param keyNodeOrEntry - Key, node, or [key, value] entry identifying the node to delete.
+   * @remarks Time O(log n) average, Space O(1)
+   * @param keyNodeEntryRawOrPredicate - Key, node, or [key, value] entry identifying the node to delete.
    * @returns Array with deletion metadata (removed node, rebalancing hint if any).
    */
-  delete(keyNodeOrEntry) {
-    if (keyNodeOrEntry === null) return [];
+  delete(keyNodeEntryRawOrPredicate) {
+    if (keyNodeEntryRawOrPredicate === null) return [];
     const results = [];
     let nodeToDelete;
-    if (this._isPredicate(keyNodeOrEntry)) nodeToDelete = this.getNode(keyNodeOrEntry);
-    else nodeToDelete = this.isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : this.getNode(keyNodeOrEntry);
+    if (this._isPredicate(keyNodeEntryRawOrPredicate)) nodeToDelete = this.getNode(keyNodeEntryRawOrPredicate);
+    else nodeToDelete = this.isRealNode(keyNodeEntryRawOrPredicate) ? keyNodeEntryRawOrPredicate : this.getNode(keyNodeEntryRawOrPredicate);
     if (!nodeToDelete) {
       return results;
     }
+    const willDeleteMin = nodeToDelete === this._minNode;
+    const willDeleteMax = nodeToDelete === this._maxNode;
+    const nextMin = willDeleteMin ? this._successorOf(nodeToDelete) : void 0;
+    const nextMax = willDeleteMax ? this._predecessorOf(nodeToDelete) : void 0;
     let originalColor = nodeToDelete.color;
     let replacementNode;
     if (!this.isRealNode(nodeToDelete.left)) {
@@ -11086,6 +11544,19 @@ var RedBlackTree = class extends BST {
     }
     if (this._isMapMode) this._store.delete(nodeToDelete.key);
     this._size--;
+    if (this._size <= 0) {
+      this._setMinCache(void 0);
+      this._setMaxCache(void 0);
+    } else {
+      if (willDeleteMin) this._setMinCache(nextMin);
+      if (willDeleteMax) this._setMaxCache(nextMax);
+      if (!this._minNode || !this.isRealNode(this._minNode)) {
+        this._setMinCache(this.isRealNode(this._root) ? this.getLeftMost((n) => n, this._root) : void 0);
+      }
+      if (!this._maxNode || !this.isRealNode(this._maxNode)) {
+        this._setMaxCache(this.isRealNode(this._root) ? this.getRightMost((n) => n, this._root) : void 0);
+      }
+    }
     if (originalColor === "BLACK") {
       this._deleteFixup(replacementNode);
     }
@@ -11094,7 +11565,7 @@ var RedBlackTree = class extends BST {
   }
   /**
    * Transform entries into a like-kind red-black tree with possibly different key/value types.
-   * @remarks Time O(n), Space O(n)
+   * @remarks Time O(n) average, Space O(n)
    * @template MK
    * @template MV
    * @template MR
@@ -11107,44 +11578,65 @@ var RedBlackTree = class extends BST {
     const out = this._createLike([], options);
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }
+  /**
+   * (Internal) Create an empty instance of the same concrete tree type.
+   * @remarks Time O(1) average, Space O(1)
+   */
   _createInstance(options) {
     const Ctor = this.constructor;
     return new Ctor([], { ...this._snapshotOptions(), ...options ?? {} });
   }
+  /**
+   * (Internal) Create a like-kind tree (same concrete class) populated from an iterable.
+   * @remarks Time O(m log m) average (m = iterable length), Space O(m)
+   */
   _createLike(iter = [], options) {
     const Ctor = this.constructor;
     return new Ctor(iter, { ...this._snapshotOptions(), ...options ?? {} });
   }
+  /**
+   * (Internal) Set the root pointer and keep header.parent in sync.
+   * @remarks Time O(1), Space O(1)
+   */
   _setRoot(v) {
+    const NIL = this.NIL;
     if (v) {
       v.parent = void 0;
     }
     this._root = v;
+    this._header.parent = v ?? NIL;
   }
+  /**
+   * (Internal) Replace a node in place while preserving its color.
+   * @remarks Time O(1) average, Space O(1)
+   */
   _replaceNode(oldNode, newNode) {
     newNode.color = oldNode.color;
     return super._replaceNode(oldNode, newNode);
   }
   /**
    * (Protected) Standard BST insert followed by red-black fix-up.
-   * @remarks Time O(log n), Space O(1)
+   * @remarks Time O(log n) average, Space O(1)
    * @param node - Node to insert.
    * @returns Status string: 'CREATED' or 'UPDATED'.
    */
   _insert(node) {
-    let current = this.root ?? this.NIL;
-    let parent = void 0;
-    while (current !== this.NIL) {
+    const NIL = this.NIL;
+    const cmp = this._compare.bind(this);
+    let current = this._header.parent ?? NIL;
+    let parent;
+    let lastCompared = 0;
+    while (current !== NIL) {
       parent = current;
-      const compared = this._compare(node.key, current.key);
-      if (compared < 0) {
-        current = current.left ?? this.NIL;
-      } else if (compared > 0) {
-        current = current.right ?? this.NIL;
+      lastCompared = cmp(node.key, current.key);
+      if (lastCompared < 0) {
+        current = current.left ?? NIL;
+      } else if (lastCompared > 0) {
+        current = current.right ?? NIL;
       } else {
         this._replaceNode(current, node);
         return "UPDATED";
@@ -11153,13 +11645,13 @@ var RedBlackTree = class extends BST {
     node.parent = parent;
     if (!parent) {
       this._setRoot(node);
-    } else if (this._compare(node.key, parent.key) < 0) {
+    } else if (lastCompared < 0) {
       parent.left = node;
     } else {
       parent.right = node;
     }
-    node.left = this.NIL;
-    node.right = this.NIL;
+    node.left = NIL;
+    node.right = NIL;
     node.color = "RED";
     this._insertFixup(node);
     return "CREATED";
@@ -11185,55 +11677,66 @@ var RedBlackTree = class extends BST {
   }
   /**
    * (Protected) Restore red-black properties after insertion (recolor/rotate).
-   * @remarks Time O(log n), Space O(1)
+   * @remarks Time O(log n) average, Space O(1)
    * @param z - Recently inserted node.
    * @returns void
    */
   _insertFixup(z) {
-    while (z?.parent?.color === "RED") {
-      if (z.parent === z.parent.parent?.left) {
-        const y = z.parent.parent.right;
+    const leftRotate = this._leftRotate.bind(this);
+    const rightRotate = this._rightRotate.bind(this);
+    while (z) {
+      const p = z.parent;
+      if (!p || p.color !== "RED") break;
+      const gp = p.parent;
+      if (!gp) break;
+      if (p === gp.left) {
+        const y = gp.right;
         if (y?.color === "RED") {
-          z.parent.color = "BLACK";
+          p.color = "BLACK";
           y.color = "BLACK";
-          z.parent.parent.color = "RED";
-          z = z.parent.parent;
-        } else {
-          if (z === z.parent.right) {
-            z = z.parent;
-            this._leftRotate(z);
-          }
-          if (z && z.parent && z.parent.parent) {
-            z.parent.color = "BLACK";
-            z.parent.parent.color = "RED";
-            this._rightRotate(z.parent.parent);
-          }
+          gp.color = "RED";
+          z = gp;
+          continue;
+        }
+        if (z === p.right) {
+          z = p;
+          leftRotate(z);
+        }
+        const p2 = z?.parent;
+        const gp2 = p2?.parent;
+        if (p2 && gp2) {
+          p2.color = "BLACK";
+          gp2.color = "RED";
+          rightRotate(gp2);
         }
       } else {
-        const y = z?.parent?.parent?.left ?? void 0;
+        const y = gp.left;
         if (y?.color === "RED") {
-          z.parent.color = "BLACK";
+          p.color = "BLACK";
           y.color = "BLACK";
-          z.parent.parent.color = "RED";
-          z = z.parent.parent;
-        } else {
-          if (z === z.parent.left) {
-            z = z.parent;
-            this._rightRotate(z);
-          }
-          if (z && z.parent && z.parent.parent) {
-            z.parent.color = "BLACK";
-            z.parent.parent.color = "RED";
-            this._leftRotate(z.parent.parent);
-          }
+          gp.color = "RED";
+          z = gp;
+          continue;
+        }
+        if (z === p.left) {
+          z = p;
+          rightRotate(z);
+        }
+        const p2 = z?.parent;
+        const gp2 = p2?.parent;
+        if (p2 && gp2) {
+          p2.color = "BLACK";
+          gp2.color = "RED";
+          leftRotate(gp2);
         }
       }
+      break;
     }
     if (this.isRealNode(this._root)) this._root.color = "BLACK";
   }
   /**
    * (Protected) Restore red-black properties after deletion (recolor/rotate).
-   * @remarks Time O(log n), Space O(1)
+   * @remarks Time O(log n) average, Space O(1)
    * @param node - Child that replaced the deleted node (may be undefined).
    * @returns void
    */
@@ -11495,7 +11998,7 @@ var AVLTreeMultiMap = class extends AVLTree {
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], { ...options, isMapMode: true });
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
   createNode(key, value = []) {
@@ -11515,27 +12018,27 @@ var AVLTreeMultiMap = class extends AVLTree {
    * Insert a value or a list of values into the multimap. If the key exists, values are appended.
    * @remarks Time O(log N + M), Space O(1)
    * @param keyNodeOrEntry - Key, node, or [key, values] entry.
-   * @param [value] - Single value to add when a bare key is provided.
+   * @param [value] - Single value to set when a bare key is provided.
    * @returns True if inserted or appended; false if ignored.
    */
-  add(keyNodeOrEntry, value) {
-    if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
+  set(keyNodeOrEntry, value) {
+    if (this.isRealNode(keyNodeOrEntry)) return super.set(keyNodeOrEntry);
     const _commonAdd = /* @__PURE__ */ __name((key, values) => {
       if (key === void 0 || key === null) return false;
-      const _addToValues = /* @__PURE__ */ __name(() => {
+      const _setToValues = /* @__PURE__ */ __name(() => {
         const existingValues = this.get(key);
         if (existingValues !== void 0 && values !== void 0) {
           for (const value2 of values) existingValues.push(value2);
           return true;
         }
         return false;
-      }, "_addToValues");
-      const _addByNode = /* @__PURE__ */ __name(() => {
+      }, "_setToValues");
+      const _setByNode = /* @__PURE__ */ __name(() => {
         const existingNode = this.getNode(key);
         if (this.isRealNode(existingNode)) {
           const existingValues = this.get(existingNode);
           if (existingValues === void 0) {
-            super.add(key, values);
+            super.set(key, values);
             return true;
           }
           if (values !== void 0) {
@@ -11545,13 +12048,13 @@ var AVLTreeMultiMap = class extends AVLTree {
             return false;
           }
         } else {
-          return super.add(key, values);
+          return super.set(key, values);
         }
-      }, "_addByNode");
+      }, "_setByNode");
       if (this._isMapMode) {
-        return _addByNode() || _addToValues();
+        return _setByNode() || _setToValues();
       }
-      return _addToValues() || _addByNode();
+      return _setToValues() || _setByNode();
     }, "_commonAdd");
     if (this.isEntry(keyNodeOrEntry)) {
       const [key, values] = keyNodeOrEntry;
@@ -11619,7 +12122,7 @@ var AVLTreeMultiMap = class extends AVLTree {
   map(callback, options, thisArg) {
     const out = this._createLike([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(callback.call(thisArg, v, k, i++, this));
+    for (const [k, v] of this) out.set(callback.call(thisArg, v, k, i++, this));
     return out;
   }
   /**
@@ -11802,7 +12305,7 @@ var TreeMultiMap = class extends RedBlackTree {
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], { ...options });
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
   createNode(key, value = []) {
@@ -11822,27 +12325,27 @@ var TreeMultiMap = class extends RedBlackTree {
    * Insert a value or a list of values into the multimap. If the key exists, values are appended.
    * @remarks Time O(log N + M), Space O(1)
    * @param keyNodeOrEntry - Key, node, or [key, values] entry.
-   * @param [value] - Single value to add when a bare key is provided.
+   * @param [value] - Single value to set when a bare key is provided.
    * @returns True if inserted or appended; false if ignored.
    */
-  add(keyNodeOrEntry, value) {
-    if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
+  set(keyNodeOrEntry, value) {
+    if (this.isRealNode(keyNodeOrEntry)) return super.set(keyNodeOrEntry);
     const _commonAdd = /* @__PURE__ */ __name((key, values) => {
       if (key === void 0 || key === null) return false;
-      const _addToValues = /* @__PURE__ */ __name(() => {
+      const _setToValues = /* @__PURE__ */ __name(() => {
         const existingValues = this.get(key);
         if (existingValues !== void 0 && values !== void 0) {
           for (const value2 of values) existingValues.push(value2);
           return true;
         }
         return false;
-      }, "_addToValues");
-      const _addByNode = /* @__PURE__ */ __name(() => {
+      }, "_setToValues");
+      const _setByNode = /* @__PURE__ */ __name(() => {
         const existingNode = this.getNode(key);
         if (this.isRealNode(existingNode)) {
           const existingValues = this.get(existingNode);
           if (existingValues === void 0) {
-            super.add(key, values);
+            super.set(key, values);
             return true;
           }
           if (values !== void 0) {
@@ -11852,13 +12355,13 @@ var TreeMultiMap = class extends RedBlackTree {
             return false;
           }
         } else {
-          return super.add(key, values);
+          return super.set(key, values);
         }
-      }, "_addByNode");
+      }, "_setByNode");
       if (this._isMapMode) {
-        return _addByNode() || _addToValues();
+        return _setByNode() || _setToValues();
       }
-      return _addToValues() || _addByNode();
+      return _setToValues() || _setByNode();
     }, "_commonAdd");
     if (this.isEntry(keyNodeOrEntry)) {
       const [key, values] = keyNodeOrEntry;
@@ -11898,7 +12401,7 @@ var TreeMultiMap = class extends RedBlackTree {
   map(callback, options, thisArg) {
     const out = this._createLike([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(callback.call(thisArg, v, k, i++, this));
+    for (const [k, v] of this) out.set(callback.call(thisArg, v, k, i++, this));
     return out;
   }
   /**
@@ -12083,7 +12586,7 @@ var TreeCounter = class extends RedBlackTree {
    */
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], options);
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
   _count = 0;
   /**
@@ -12123,10 +12626,10 @@ var TreeCounter = class extends RedBlackTree {
    * @param [count] - How much to increase the node's count (default 1).
    * @returns True if inserted/updated; false if ignored.
    */
-  add(keyNodeOrEntry, value, count = 1) {
+  set(keyNodeOrEntry, value, count = 1) {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
     const orgCount = newNode?.count || 0;
-    const isSuccessAdded = super.add(newNode, newValue);
+    const isSuccessAdded = super.set(newNode, newValue);
     if (isSuccessAdded) {
       this._count += orgCount;
       return true;
@@ -12137,16 +12640,16 @@ var TreeCounter = class extends RedBlackTree {
   /**
    * Delete a node (or decrement its count) and rebalance if needed.
    * @remarks Time O(log N), Space O(1)
-   * @param keyNodeOrEntry - Key, node, or [key, value] entry identifying the node.
+   * @param keyNodeEntryRawOrPredicate - Key, node, or [key, value] entry identifying the node.
    * @param [ignoreCount] - If true, remove the node regardless of its count.
    * @returns Array of deletion results including deleted node and a rebalance hint when present.
    */
-  delete(keyNodeOrEntry, ignoreCount = false) {
-    if (keyNodeOrEntry === null) return [];
+  delete(keyNodeEntryRawOrPredicate, ignoreCount = false) {
+    if (keyNodeEntryRawOrPredicate === null) return [];
     const results = [];
     let nodeToDelete;
-    if (this._isPredicate(keyNodeOrEntry)) nodeToDelete = this.getNode(keyNodeOrEntry);
-    else nodeToDelete = this.isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : this.getNode(keyNodeOrEntry);
+    if (this._isPredicate(keyNodeEntryRawOrPredicate)) nodeToDelete = this.getNode(keyNodeEntryRawOrPredicate);
+    else nodeToDelete = this.isRealNode(keyNodeEntryRawOrPredicate) ? keyNodeEntryRawOrPredicate : this.getNode(keyNodeEntryRawOrPredicate);
     if (!nodeToDelete) {
       return results;
     }
@@ -12189,7 +12692,6 @@ var TreeCounter = class extends RedBlackTree {
           if (ignoreCount || nodeToDelete.count <= 1) {
             if (successor.right !== null) {
               this._transplant(successor, successor.right);
-              this._count -= nodeToDelete.count;
             }
           } else {
             nodeToDelete.count--;
@@ -12279,7 +12781,7 @@ var TreeCounter = class extends RedBlackTree {
     const out = this._createLike([], options);
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }
@@ -12292,6 +12794,11 @@ var TreeCounter = class extends RedBlackTree {
     const out = this._createInstance();
     this._clone(out);
     out._count = this._count;
+    for (const node of this.dfs((n) => n, "IN")) {
+      if (!node) continue;
+      const outNode = out.getNode(node.key);
+      if (outNode) outNode.count = node.count;
+    }
     return out;
   }
   /**
@@ -12535,7 +13042,7 @@ var AVLTreeCounter = class extends AVLTree {
    */
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], options);
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
   _count = 0;
   get count() {
@@ -12570,11 +13077,11 @@ var AVLTreeCounter = class extends AVLTree {
    * @param [count] - How much to increase the node's count (default 1).
    * @returns True if inserted/updated; false if ignored.
    */
-  add(keyNodeOrEntry, value, count = 1) {
+  set(keyNodeOrEntry, value, count = 1) {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
     if (newNode === void 0) return false;
     const orgNodeCount = newNode?.count || 0;
-    const inserted = super.add(newNode, newValue);
+    const inserted = super.set(newNode, newValue);
     if (inserted) {
       this._count += orgNodeCount;
     }
@@ -12682,9 +13189,9 @@ var AVLTreeCounter = class extends AVLTree {
   clone() {
     const out = this._createInstance();
     if (this._isMapMode) {
-      this.bfs((node) => out.add(node.key, void 0, node.count));
+      this.bfs((node) => out.set(node.key, void 0, node.count));
     } else {
-      this.bfs((node) => out.add(node.key, node.value, node.count));
+      this.bfs((node) => out.set(node.key, node.value, node.count));
     }
     if (this._isMapMode) out._store = this._store;
     return out;
@@ -12704,7 +13211,7 @@ var AVLTreeCounter = class extends AVLTree {
     const out = this._createLike([], options);
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }