data-structure-typed 2.2.7 → 2.3.0

package/dist/umd/data-structure-typed.js

@@ -1475,6 +1475,12 @@ var dataStructureTyped = (() => {
       }
       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) {
@@ -4276,6 +4282,12 @@ var dataStructureTyped = (() => {
      */
     _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.
@@ -6989,9 +7001,9 @@ var dataStructureTyped = (() => {
   var BinaryTree = class extends IterableEntryBase {
     /**
      * 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) {
@@ -7020,7 +7032,7 @@ var dataStructureTyped = (() => {
         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);
     }
     /**
      * Gets whether the tree is in Map mode.
@@ -7227,10 +7239,20 @@ var dataStructureTyped = (() => {
      * @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) {
@@ -7274,25 +7296,24 @@ var dataStructureTyped = (() => {
       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) {
@@ -7307,52 +7328,41 @@ var dataStructureTyped = (() => {
           }
         }
         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 == null ? void 0 : curr.parent;
       let needBalanced;
@@ -7536,7 +7546,7 @@ var dataStructureTyped = (() => {
           }
           return true;
         };
-        const isStandardBST = checkBST(false);
+        const isStandardBST = checkBST();
         const isInverseBST = checkBST(true);
         return isStandardBST || isInverseBST;
       }
@@ -8006,7 +8016,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * 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.
      */
@@ -8017,7 +8027,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * 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.
@@ -8026,7 +8036,7 @@ var dataStructureTyped = (() => {
     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;
     }
     /**
@@ -8044,7 +8054,7 @@ var dataStructureTyped = (() => {
     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 dataStructureTyped = (() => {
       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,
@@ -8628,7 +8638,7 @@ var dataStructureTyped = (() => {
      * 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) {
@@ -8649,7 +8659,7 @@ var dataStructureTyped = (() => {
       } else {
         this._comparator = this._createDefaultComparator();
       }
-      if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+      if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
     }
     /**
      * Gets the root node of the tree.
@@ -8763,8 +8773,40 @@ var dataStructureTyped = (() => {
      * @returns The first matching node, or undefined if not found.
      */
     getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-      var _a;
-      return (_a = this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0]) != null ? _a : void 0;
+      var _a, _b;
+      if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) return void 0;
+      if (this._isPredicate(keyNodeEntryOrPredicate)) {
+        return (_a = this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0]) != null ? _a : void 0;
+      }
+      if (keyNodeEntryOrPredicate instanceof Range) {
+        return (_b = this.getNodes(
+          keyNodeEntryOrPredicate,
+          true,
+          startNode,
+          iterationType
+        )[0]) != null ? _b : 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.
@@ -8785,8 +8827,30 @@ var dataStructureTyped = (() => {
       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 = (node) => {
           if (!node) return false;
@@ -8860,11 +8924,11 @@ var dataStructureTyped = (() => {
      * 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) {
@@ -8901,24 +8965,24 @@ var dataStructureTyped = (() => {
     }
     /**
      * 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 == null ? void 0 : values[Symbol.iterator]();
       if (!isBalanceAdd) {
         for (let kve of keysNodesEntriesOrRaws) {
           const val = valuesIterator == null ? void 0 : 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;
       }
@@ -8946,9 +9010,9 @@ var dataStructureTyped = (() => {
         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));
@@ -8965,9 +9029,9 @@ var dataStructureTyped = (() => {
           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]);
@@ -9242,7 +9306,7 @@ var dataStructureTyped = (() => {
       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;
     }
@@ -9673,7 +9737,6 @@ var dataStructureTyped = (() => {
      * @returns True if the node was found and deleted, false otherwise.
      */
     _deleteByKey(key) {
-      var _a;
       let node = this._root;
       while (node) {
         const cmp = this._compare(node.key, key);
@@ -9712,7 +9775,7 @@ var dataStructureTyped = (() => {
         succ.left = node.left;
         if (succ.left) succ.left.parent = succ;
       }
-      this._size = Math.max(0, ((_a = this._size) != null ? _a : 0) - 1);
+      this._size = Math.max(0, this._size - 1);
       return true;
     }
   };
@@ -10418,14 +10481,14 @@ var dataStructureTyped = (() => {
   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.
@@ -10449,16 +10512,16 @@ var dataStructureTyped = (() => {
       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;
     }
@@ -10510,7 +10573,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * 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.
@@ -10524,7 +10587,7 @@ var dataStructureTyped = (() => {
       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;
     }
@@ -10807,12 +10870,11 @@ var dataStructureTyped = (() => {
   // src/data-structures/binary-tree/red-black-tree.ts
   var RedBlackTreeNode = class {
     /**
-     * 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") {
       __publicField(this, "key");
@@ -10943,9 +11005,31 @@ var dataStructureTyped = (() => {
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       __publicField(this, "_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`.
+       */
+      __publicField(this, "_header");
+      /**
+       * (Internal) Cache of the current minimum and maximum nodes.
+       * Used for fast-path insert/update when keys are monotonic or near-boundary.
+       */
+      __publicField(this, "_minNode");
+      __publicField(this, "_maxNode");
       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);
       }
     }
     /**
@@ -10981,18 +11065,390 @@ var dataStructureTyped = (() => {
      * @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) {
+      var _a, _b, _c;
+      const NIL = this.NIL;
+      const cmp = this._compare.bind(this);
+      let cur = (_a = this._header.parent) != null ? _a : NIL;
+      while (cur !== NIL) {
+        const c = cmp(key, cur.key);
+        if (c < 0) cur = (_b = cur.left) != null ? _b : NIL;
+        else if (c > 0) cur = (_c = cur.right) != null ? _c : 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)
      */
-    add(keyNodeOrEntry, value) {
+    _setMinCache(node) {
+      this._minNode = node;
+      this._header._left = node != null ? 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 != null ? 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) {
+      var _a, _b, _c, _d, _e, _f, _g;
+      const NIL = this.NIL;
+      const comparator = this._comparator;
+      const header = this._header;
+      const minN = (_a = header._left) != null ? _a : 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 = (_b = header._right) != null ? _b : 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 = (_c = this._header.parent) != null ? _c : NIL;
+      let parent;
+      let lastCompared = 0;
+      while (current !== NIL) {
+        parent = current;
+        lastCompared = cmp(key, current.key);
+        if (lastCompared < 0) current = (_d = current.left) != null ? _d : NIL;
+        else if (lastCompared > 0) current = (_e = current.right) != null ? _e : 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 = (_f = this._header._left) != null ? _f : NIL;
+      const hMax = (_g = this._header._right) != null ? _g : 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)
+     */
+    setWithHintNode(key, value, hint) {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+      if (!hint || !this.isRealNode(hint)) {
+        return (_a = this._setKVNode(key, value)) == null ? void 0 : _a.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 = (_b = this._header._left) != null ? _b : NIL;
+          if (hMin === NIL || this._compare(newNode.key, hMin.key) < 0) this._setMinCache(newNode);
+          const hMax = (_c = this._header._right) != null ? _c : 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 (_d = this._setKVNode(key, value)) == null ? void 0 : _d.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 = (_e = this._header._left) != null ? _e : NIL;
+          if (hMin === NIL || this._compare(newNode.key, hMin.key) < 0) this._setMinCache(newNode);
+          const hMax = (_f = this._header._right) != null ? _f : NIL;
+          if (hMax === NIL || this._compare(newNode.key, hMax.key) > 0) this._setMaxCache(newNode);
+          return newNode;
+        }
+        return (_g = this._setKVNode(key, value)) == null ? void 0 : _g.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 = (_h = this._header._left) != null ? _h : NIL;
+        if (hMin === NIL || this._compare(newNode.key, hMin.key) < 0) this._setMinCache(newNode);
+        const hMax = (_i = this._header._right) != null ? _i : 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 (_j = this._setKVNode(key, value)) == null ? void 0 : _j.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 = (_k = this._header._left) != null ? _k : NIL;
+        if (hMin === NIL || this._compare(newNode.key, hMin.key) < 0) this._setMinCache(newNode);
+        const hMax = (_l = this._header._right) != null ? _l : NIL;
+        if (hMax === NIL || this._compare(newNode.key, hMax.key) > 0) this._setMaxCache(newNode);
+        return newNode;
+      }
+      return (_m = this._setKVNode(key, value)) == null ? void 0 : _m.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 != null ? 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);
@@ -11014,19 +11470,23 @@ var dataStructureTyped = (() => {
     }
     /**
      * 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)) {
@@ -11065,6 +11525,19 @@ var dataStructureTyped = (() => {
       }
       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);
       }
@@ -11073,7 +11546,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * 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
@@ -11086,45 +11559,66 @@ var dataStructureTyped = (() => {
       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 != null ? 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 != null ? 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 != null ? 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) {
       var _a, _b, _c;
-      let current = (_a = this.root) != null ? _a : this.NIL;
-      let parent = void 0;
-      while (current !== this.NIL) {
+      const NIL = this.NIL;
+      const cmp = this._compare.bind(this);
+      let current = (_a = this._header.parent) != null ? _a : NIL;
+      let parent;
+      let lastCompared = 0;
+      while (current !== NIL) {
         parent = current;
-        const compared = this._compare(node.key, current.key);
-        if (compared < 0) {
-          current = (_b = current.left) != null ? _b : this.NIL;
-        } else if (compared > 0) {
-          current = (_c = current.right) != null ? _c : this.NIL;
+        lastCompared = cmp(node.key, current.key);
+        if (lastCompared < 0) {
+          current = (_b = current.left) != null ? _b : NIL;
+        } else if (lastCompared > 0) {
+          current = (_c = current.right) != null ? _c : NIL;
         } else {
           this._replaceNode(current, node);
           return "UPDATED";
@@ -11133,13 +11627,13 @@ var dataStructureTyped = (() => {
       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";
@@ -11165,56 +11659,66 @@ var dataStructureTyped = (() => {
     }
     /**
      * (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) {
-      var _a, _b, _c, _d, _e;
-      while (((_a = z == null ? void 0 : z.parent) == null ? void 0 : _a.color) === "RED") {
-        if (z.parent === ((_b = z.parent.parent) == null ? void 0 : _b.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 == null ? void 0 : 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 == null ? void 0 : z.parent;
+          const gp2 = p2 == null ? void 0 : p2.parent;
+          if (p2 && gp2) {
+            p2.color = "BLACK";
+            gp2.color = "RED";
+            rightRotate(gp2);
           }
         } else {
-          const y = (_e = (_d = (_c = z == null ? void 0 : z.parent) == null ? void 0 : _c.parent) == null ? void 0 : _d.left) != null ? _e : void 0;
+          const y = gp.left;
           if ((y == null ? void 0 : 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 == null ? void 0 : z.parent;
+          const gp2 = p2 == null ? void 0 : 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
      */
@@ -11471,7 +11975,7 @@ var dataStructureTyped = (() => {
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], { ...options, isMapMode: true });
       if (keysNodesEntriesOrRaws) {
-        this.addMany(keysNodesEntriesOrRaws);
+        this.setMany(keysNodesEntriesOrRaws);
       }
     }
     createNode(key, value = []) {
@@ -11491,14 +11995,14 @@ var dataStructureTyped = (() => {
      * 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 = (key, values) => {
         if (key === void 0 || key === null) return false;
-        const _addToValues = () => {
+        const _setToValues = () => {
           const existingValues = this.get(key);
           if (existingValues !== void 0 && values !== void 0) {
             for (const value2 of values) existingValues.push(value2);
@@ -11506,12 +12010,12 @@ var dataStructureTyped = (() => {
           }
           return false;
         };
-        const _addByNode = () => {
+        const _setByNode = () => {
           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) {
@@ -11521,13 +12025,13 @@ var dataStructureTyped = (() => {
               return false;
             }
           } else {
-            return super.add(key, values);
+            return super.set(key, values);
           }
         };
         if (this._isMapMode) {
-          return _addByNode() || _addToValues();
+          return _setByNode() || _setToValues();
         }
-        return _addToValues() || _addByNode();
+        return _setToValues() || _setByNode();
       };
       if (this.isEntry(keyNodeOrEntry)) {
         const [key, values] = keyNodeOrEntry;
@@ -11595,7 +12099,7 @@ var dataStructureTyped = (() => {
     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;
     }
     /**
@@ -11774,7 +12278,7 @@ var dataStructureTyped = (() => {
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], { ...options });
       if (keysNodesEntriesOrRaws) {
-        this.addMany(keysNodesEntriesOrRaws);
+        this.setMany(keysNodesEntriesOrRaws);
       }
     }
     createNode(key, value = []) {
@@ -11794,14 +12298,14 @@ var dataStructureTyped = (() => {
      * 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 = (key, values) => {
         if (key === void 0 || key === null) return false;
-        const _addToValues = () => {
+        const _setToValues = () => {
           const existingValues = this.get(key);
           if (existingValues !== void 0 && values !== void 0) {
             for (const value2 of values) existingValues.push(value2);
@@ -11809,12 +12313,12 @@ var dataStructureTyped = (() => {
           }
           return false;
         };
-        const _addByNode = () => {
+        const _setByNode = () => {
           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) {
@@ -11824,13 +12328,13 @@ var dataStructureTyped = (() => {
               return false;
             }
           } else {
-            return super.add(key, values);
+            return super.set(key, values);
           }
         };
         if (this._isMapMode) {
-          return _addByNode() || _addToValues();
+          return _setByNode() || _setToValues();
         }
-        return _addToValues() || _addByNode();
+        return _setToValues() || _setByNode();
       };
       if (this.isEntry(keyNodeOrEntry)) {
         const [key, values] = keyNodeOrEntry;
@@ -11870,7 +12374,7 @@ var dataStructureTyped = (() => {
     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;
     }
     /**
@@ -12052,7 +12556,7 @@ var dataStructureTyped = (() => {
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
-      if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+      if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
     }
     /**
      * Get the total aggregate count across all nodes.
@@ -12091,10 +12595,10 @@ var dataStructureTyped = (() => {
      * @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 == null ? void 0 : newNode.count) || 0;
-      const isSuccessAdded = super.add(newNode, newValue);
+      const isSuccessAdded = super.set(newNode, newValue);
       if (isSuccessAdded) {
         this._count += orgCount;
         return true;
@@ -12105,16 +12609,16 @@ var dataStructureTyped = (() => {
     /**
      * 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;
       }
@@ -12157,7 +12661,6 @@ var dataStructureTyped = (() => {
             if (ignoreCount || nodeToDelete.count <= 1) {
               if (successor.right !== null) {
                 this._transplant(successor, successor.right);
-                this._count -= nodeToDelete.count;
               }
             } else {
               nodeToDelete.count--;
@@ -12247,7 +12750,7 @@ var dataStructureTyped = (() => {
       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;
     }
@@ -12260,6 +12763,11 @@ var dataStructureTyped = (() => {
       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;
     }
     /**
@@ -12498,7 +13006,7 @@ var dataStructureTyped = (() => {
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
-      if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+      if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
     }
     get count() {
       return this._count;
@@ -12532,11 +13040,11 @@ var dataStructureTyped = (() => {
      * @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 == null ? void 0 : newNode.count) || 0;
-      const inserted = super.add(newNode, newValue);
+      const inserted = super.set(newNode, newValue);
       if (inserted) {
         this._count += orgNodeCount;
       }
@@ -12645,9 +13153,9 @@ var dataStructureTyped = (() => {
     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;
@@ -12667,7 +13175,7 @@ var dataStructureTyped = (() => {
       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;
     }