data-structure-typed 2.2.8 → 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.
@@ -7288,7 +7300,6 @@ var dataStructureTyped = (() => {
      * @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 set.
-     * @param [values] - An optional parallel iterable of values.
      * @returns An array of booleans indicating the success of each individual `set` operation.
      */
     addMany(keysNodesEntriesOrRaws) {
@@ -7345,13 +7356,13 @@ var dataStructureTyped = (() => {
      * 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;
@@ -7535,7 +7546,7 @@ var dataStructureTyped = (() => {
           }
           return true;
         };
-        const isStandardBST = checkBST(false);
+        const isStandardBST = checkBST();
         const isInverseBST = checkBST(true);
         return isStandardBST || isInverseBST;
       }
@@ -8762,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.
@@ -8784,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;
@@ -9672,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);
@@ -9711,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;
     }
   };
@@ -10806,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");
@@ -10942,7 +11005,29 @@ 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.setMany(keysNodesEntriesOrRaws);
       }
@@ -10980,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)
+     */
+    _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);
@@ -11013,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)) {
@@ -11064,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);
       }
@@ -11072,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
@@ -11089,41 +11563,62 @@ var dataStructureTyped = (() => {
       }
       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";
@@ -11132,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";
@@ -11164,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
      */
@@ -12104,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;
       }
@@ -12156,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--;
@@ -12259,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;
     }
     /**