data-structure-typed 1.50.5 → 1.50.7

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

@@ -115,6 +115,7 @@ var dataStructureTyped = (() => {
     BinaryTree: () => BinaryTree,
     BinaryTreeNode: () => BinaryTreeNode,
     CP: () => CP,
+    CRUD: () => CRUD,
     Character: () => Character,
     Deque: () => Deque,
     DirectedEdge: () => DirectedEdge,
@@ -7689,6 +7690,13 @@ var dataStructureTyped = (() => {
     FamilyPosition2["MAL_NODE"] = "MAL_NODE";
     return FamilyPosition2;
   })(FamilyPosition || {});
+  var CRUD = /* @__PURE__ */ ((CRUD2) => {
+    CRUD2["CREATED"] = "CREATED";
+    CRUD2["READ"] = "READ";
+    CRUD2["UPDATED"] = "UPDATED";
+    CRUD2["DELETED"] = "DELETED";
+    return CRUD2;
+  })(CRUD || {});
 
   // src/data-structures/binary-tree/binary-tree.ts
   var BinaryTreeNode = class {
@@ -8386,7 +8394,7 @@ var dataStructureTyped = (() => {
         return true;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
         const dfs = (cur, min, max) => {
-          if (!cur)
+          if (!this.isRealNode(cur))
             return true;
           const numKey = this.extractor(cur.key);
           if (numKey <= min || numKey >= max)
@@ -8401,14 +8409,14 @@ var dataStructureTyped = (() => {
           const stack = [];
           let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
           let curr = beginRoot;
-          while (curr || stack.length > 0) {
-            while (curr) {
+          while (this.isRealNode(curr) || stack.length > 0) {
+            while (this.isRealNode(curr)) {
               stack.push(curr);
               curr = curr.left;
             }
             curr = stack.pop();
             const numKey = this.extractor(curr.key);
-            if (!curr || !checkMax && prev >= numKey || checkMax && prev <= numKey)
+            if (!this.isRealNode(curr) || !checkMax && prev >= numKey || checkMax && prev <= numKey)
               return false;
             prev = numKey;
             curr = curr.right;
@@ -8469,11 +8477,11 @@ var dataStructureTyped = (() => {
      */
     getHeight(beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot)
+      if (!this.isRealNode(beginRoot))
         return -1;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
         const _getMaxHeight = (cur) => {
-          if (!cur)
+          if (!this.isRealNode(cur))
             return -1;
           const leftHeight = _getMaxHeight(cur.left);
           const rightHeight = _getMaxHeight(cur.right);
@@ -8485,9 +8493,9 @@ var dataStructureTyped = (() => {
         let maxHeight = 0;
         while (stack.length > 0) {
           const { node, depth } = stack.pop();
-          if (node.left)
+          if (this.isRealNode(node.left))
             stack.push({ node: node.left, depth: depth + 1 });
-          if (node.right)
+          if (this.isRealNode(node.right))
             stack.push({ node: node.right, depth: depth + 1 });
           maxHeight = Math.max(maxHeight, depth);
         }
@@ -8518,9 +8526,9 @@ var dataStructureTyped = (() => {
         return -1;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
         const _getMinHeight = (cur) => {
-          if (!cur)
+          if (!this.isRealNode(cur))
             return 0;
-          if (!cur.left && !cur.right)
+          if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return 0;
           const leftMinHeight = _getMinHeight(cur.left);
           const rightMinHeight = _getMinHeight(cur.right);
@@ -8532,16 +8540,16 @@ var dataStructureTyped = (() => {
         let node = beginRoot, last = null;
         const depths = /* @__PURE__ */ new Map();
         while (stack.length > 0 || node) {
-          if (node) {
+          if (this.isRealNode(node)) {
             stack.push(node);
             node = node.left;
           } else {
             node = stack[stack.length - 1];
-            if (!node.right || last === node.right) {
+            if (!this.isRealNode(node.right) || last === node.right) {
               node = stack.pop();
-              if (node) {
-                const leftMinHeight = node.left ? (_a = depths.get(node.left)) != null ? _a : -1 : -1;
-                const rightMinHeight = node.right ? (_b = depths.get(node.right)) != null ? _b : -1 : -1;
+              if (this.isRealNode(node)) {
+                const leftMinHeight = this.isRealNode(node.left) ? (_a = depths.get(node.left)) != null ? _a : -1 : -1;
+                const rightMinHeight = this.isRealNode(node.right) ? (_b = depths.get(node.right)) != null ? _b : -1 : -1;
                 depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
                 last = node;
                 node = null;
@@ -8603,8 +8611,10 @@ var dataStructureTyped = (() => {
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
+      if (this.isNIL(beginRoot))
+        return beginRoot;
       beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot)
+      if (!this.isRealNode(beginRoot))
         return beginRoot;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
         const _traverse = (cur) => {
@@ -8642,6 +8652,8 @@ var dataStructureTyped = (() => {
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
     getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
+      if (this.isNIL(beginRoot))
+        return beginRoot;
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return beginRoot;
@@ -8752,45 +8764,45 @@ var dataStructureTyped = (() => {
           switch (pattern) {
             case "in":
               if (includeNull) {
-                if (node && this.isNodeOrNull(node.left))
+                if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                   _traverse(node.left);
                 this.isNodeOrNull(node) && ans.push(callback(node));
-                if (node && this.isNodeOrNull(node.right))
+                if (this.isRealNode(node) && this.isNodeOrNull(node.right))
                   _traverse(node.right);
               } else {
-                if (node && node.left)
+                if (this.isRealNode(node) && this.isRealNode(node.left))
                   _traverse(node.left);
                 this.isRealNode(node) && ans.push(callback(node));
-                if (node && node.right)
+                if (this.isRealNode(node) && this.isRealNode(node.right))
                   _traverse(node.right);
               }
               break;
             case "pre":
               if (includeNull) {
                 this.isNodeOrNull(node) && ans.push(callback(node));
-                if (node && this.isNodeOrNull(node.left))
+                if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                   _traverse(node.left);
-                if (node && this.isNodeOrNull(node.right))
+                if (this.isRealNode(node) && this.isNodeOrNull(node.right))
                   _traverse(node.right);
               } else {
                 this.isRealNode(node) && ans.push(callback(node));
-                if (node && node.left)
+                if (this.isRealNode(node) && this.isRealNode(node.left))
                   _traverse(node.left);
-                if (node && node.right)
+                if (this.isRealNode(node) && this.isRealNode(node.right))
                   _traverse(node.right);
               }
               break;
             case "post":
               if (includeNull) {
-                if (node && this.isNodeOrNull(node.left))
+                if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                   _traverse(node.left);
-                if (node && this.isNodeOrNull(node.right))
+                if (this.isRealNode(node) && this.isNodeOrNull(node.right))
                   _traverse(node.right);
                 this.isNodeOrNull(node) && ans.push(callback(node));
               } else {
-                if (node && node.left)
+                if (this.isRealNode(node) && this.isRealNode(node.left))
                   _traverse(node.left);
-                if (node && node.right)
+                if (this.isRealNode(node) && this.isRealNode(node.right))
                   _traverse(node.right);
                 this.isRealNode(node) && ans.push(callback(node));
               }
@@ -9707,17 +9719,17 @@ var dataStructureTyped = (() => {
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
-      if (!this.root)
+      if (!this.isRealNode(this.root))
         return void 0;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
         const _dfs = (cur) => {
           if (cur.key === key)
             return cur;
-          if (!cur.left && !cur.right)
+          if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return;
-          if (this._compare(cur.key, key) === "gt" /* gt */ && cur.left)
+          if (this._compare(cur.key, key) === "gt" /* gt */ && this.isRealNode(cur.left))
             return _dfs(cur.left);
-          if (this._compare(cur.key, key) === "lt" /* lt */ && cur.right)
+          if (this._compare(cur.key, key) === "lt" /* lt */ && this.isRealNode(cur.right))
             return _dfs(cur.right);
         };
         return _dfs(this.root);
@@ -9725,13 +9737,13 @@ var dataStructureTyped = (() => {
         const queue = new Queue([this.root]);
         while (queue.size > 0) {
           const cur = queue.shift();
-          if (cur) {
+          if (this.isRealNode(cur)) {
             if (this._compare(cur.key, key) === "eq" /* eq */)
               return cur;
             if (this._compare(cur.key, key) === "gt" /* gt */)
-              cur.left && queue.push(cur.left);
+              this.isRealNode(cur.left) && queue.push(cur.left);
             if (this._compare(cur.key, key) === "lt" /* lt */)
-              cur.right && queue.push(cur.right);
+              this.isRealNode(cur.right) && queue.push(cur.right);
           }
         }
       }
@@ -9777,16 +9789,16 @@ var dataStructureTyped = (() => {
             if (onlyOne)
               return;
           }
-          if (!cur.left && !cur.right)
+          if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return;
           if (callback === this._defaultOneParamCallback) {
             if (this._compare(cur.key, identifier) === "gt" /* gt */)
-              cur.left && _traverse(cur.left);
+              this.isRealNode(cur.left) && _traverse(cur.left);
             if (this._compare(cur.key, identifier) === "lt" /* lt */)
-              cur.right && _traverse(cur.right);
+              this.isRealNode(cur.right) && _traverse(cur.right);
           } else {
-            cur.left && _traverse(cur.left);
-            cur.right && _traverse(cur.right);
+            this.isRealNode(cur.left) && _traverse(cur.left);
+            this.isRealNode(cur.right) && _traverse(cur.right);
           }
         };
         _traverse(beginRoot);
@@ -9794,7 +9806,7 @@ var dataStructureTyped = (() => {
         const queue = new Queue([beginRoot]);
         while (queue.size > 0) {
           const cur = queue.shift();
-          if (cur) {
+          if (this.isRealNode(cur)) {
             const callbackResult = callback(cur);
             if (callbackResult === identifier) {
               ans.push(cur);
@@ -9803,12 +9815,12 @@ var dataStructureTyped = (() => {
             }
             if (callback === this._defaultOneParamCallback) {
               if (this._compare(cur.key, identifier) === "gt" /* gt */)
-                cur.left && queue.push(cur.left);
+                this.isRealNode(cur.left) && queue.push(cur.left);
               if (this._compare(cur.key, identifier) === "lt" /* lt */)
-                cur.right && queue.push(cur.right);
+                this.isRealNode(cur.right) && queue.push(cur.right);
             } else {
-              cur.left && queue.push(cur.left);
-              cur.right && queue.push(cur.right);
+              this.isRealNode(cur.left) && queue.push(cur.left);
+              this.isRealNode(cur.right) && queue.push(cur.right);
             }
           }
         }
@@ -11161,7 +11173,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function returns the color value of a variable.
-     * @returns The color value stored in the protected variable `_color`.
+     * @returns The color value stored in the private variable `_color`.
      */
     get color() {
       return this._color;
@@ -11176,55 +11188,47 @@ var dataStructureTyped = (() => {
   };
   var RedBlackTree = class _RedBlackTree extends BST {
     /**
-     * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
-     * initializes the tree with optional nodes and options.
-     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, NODE>`
-     * objects. It represents the initial nodes that will be added to the RBTree during its
-     * construction. If this parameter is provided, the `addMany` method is called to add all the
-     * nodes to the
-     * @param [options] - The `options` parameter is an optional object that allows you to customize the
-     * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
-     * only a subset of the properties defined in the `RBTreeOptions` interface.
+     * This is the constructor function for a Red-Black Tree data structure in TypeScript.
+     * @param keysOrNodesOrEntries - The `keysOrNodesOrEntries` parameter is an iterable object that can
+     * contain keys, nodes, or entries. It is used to initialize the RBTree with the provided keys,
+     * nodes, or entries.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the
+     * constructor. It allows you to customize the behavior of the RBTree. It can include properties such
+     * as `compareKeys`, `compareValues`, `allowDuplicates`, etc. These properties define how the RBTree
+     * should compare keys and
      */
     constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
-      __publicField(this, "_Sentinel", new RedBlackTreeNode(NaN));
+      __publicField(this, "_SENTINEL", new RedBlackTreeNode(NaN));
       __publicField(this, "_root");
-      __publicField(this, "_size", 0);
-      this._root = this._Sentinel;
-      if (keysOrNodesOrEntries)
-        super.addMany(keysOrNodesOrEntries);
+      this._root = this.SENTINEL;
+      if (keysOrNodesOrEntries) {
+        this.addMany(keysOrNodesOrEntries);
+      }
     }
     /**
-     * The function returns the value of the `_Sentinel` property.
-     * @returns The method is returning the value of the `_Sentinel` property.
+     * The function returns the value of the _SENTINEL property.
+     * @returns The method is returning the value of the `_SENTINEL` property.
      */
-    get Sentinel() {
-      return this._Sentinel;
+    get SENTINEL() {
+      return this._SENTINEL;
     }
     /**
-     * The function returns the root node.
-     * @returns The root node of the data structure.
+     * The function returns the root node of a tree or undefined if there is no root.
+     * @returns The root node of the tree structure, or undefined if there is no root node.
      */
     get root() {
       return this._root;
     }
-    /**
-     * The function returns the size of an object.
-     * @returns The size of the object, which is a number.
-     */
-    get size() {
-      return this._size;
-    }
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
-     * @param {K} key - The key parameter is the key value associated with the node. It is used to
-     * identify and compare nodes in the Red-Black Tree.
+     * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
+     * which is a generic type representing the key's data type.
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the node. It is of type `V`, which is a generic type that can be replaced with any
-     * specific type when using the `createNode` method.
+     * associated with the key in the node. It is not required and can be omitted if not needed.
      * @param {RBTNColor} color - The "color" parameter is used to specify the color of the node in a
-     * Red-Black Tree. It can be either "RED" or "BLACK". By default, the color is set to "BLACK".
+     * Red-Black Tree. It is an optional parameter with a default value of "RBTNColor.BLACK". The color
+     * can be either "RBTNColor.RED" or "RBTNColor.BLACK".
      * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
      * value, and color.
      */
@@ -11232,10 +11236,10 @@ var dataStructureTyped = (() => {
       return new RedBlackTreeNode(key, value, color);
     }
     /**
-     * The function creates a Red-Black Tree with the specified options and returns it.
-     * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
-     * passed to the `createTree` function. It is used to customize the behavior of the `RedBlackTree`
-     * class.
+     * The function creates a Red-Black Tree with the given options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains configuration
+     * options for creating the Red-Black Tree. It is of type `RBTreeOptions<K>`, where `K` represents
+     * the type of keys in the tree.
      * @returns a new instance of a RedBlackTree object.
      */
     createTree(options) {
@@ -11244,12 +11248,18 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function `keyValueOrEntryToNode` takes an keyOrNodeOrEntry and converts it into a node object if possible.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, where:
-     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If a value
-     * is provided, it will be used when creating the new node. If no value is provided, the new node
-     * @returns a node of type NODE or undefined.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `keyValueOrEntryToNode` takes a key, value, or entry and returns a node if it is
+     * valid, otherwise it returns undefined.
+     * @param {KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntry - The key, value, or entry to convert.
+     * @param {V} [value] - The value associated with the key (if `keyOrNodeOrEntry` is a key).
+     * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
      */
     keyValueOrEntryToNode(keyOrNodeOrEntry, value) {
       let node;
@@ -11272,158 +11282,84 @@ var dataStructureTyped = (() => {
       return node;
     }
     /**
-     * The function checks if an keyOrNodeOrEntry is an instance of the RedBlackTreeNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the RedBlackTreeNode
-     * class.
-     */
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       * /
+    
+       /**
+       * Time Complexity: O(1)
+       * Space Complexity: O(1)
+       *
+       * The function checks if the input is an instance of the RedBlackTreeNode class.
+       * @param {KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntry - The object to check.
+       * @returns {boolean} - `true` if the object is a Red-Black Tree node, `false` otherwise.
+       */
     isNode(keyOrNodeOrEntry) {
       return keyOrNodeOrEntry instanceof RedBlackTreeNode;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given node is a real node in a Red-Black Tree.
      * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
      * it can either be of type `NODE` or `undefined`.
      * @returns a boolean value.
      */
     isRealNode(node) {
-      if (node === this._Sentinel || node === void 0)
+      if (node === this.SENTINEL || node === void 0)
         return false;
       return node instanceof RedBlackTreeNode;
     }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     * On average (where n is the number of nodes in the tree)
      */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `add` function adds a new node to a binary search tree and performs necessary rotations and
-     * color changes to maintain the red-black tree properties.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
-     * entry.
-     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-     * being added to the binary search tree.
-     * @returns The method `add` returns either the newly added node (`NODE`) or `undefined`.
+     * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
+     * callback function.
+     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
+     * that you want to search for in the binary search tree. It can be of any type that is compatible
+     * with the type of nodes in the tree.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+     * the tree. It is used to determine whether a node matches the given identifier. The `callback`
+     * function should take a node as its parameter and return a value that can be compared to the
+     * `identifier` parameter.
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
+     * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
+     * using the `ensureNode` method. If it is not provided, the `root`
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed when searching for nodes in the binary search tree. It is an optional parameter and
+     * its default value is taken from the `iterationType` property of the class.
+     * @returns The method is returning a value of type `NODE | null | undefined`.
      */
-    add(keyOrNodeOrEntry, value) {
-      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
-      if (newNode === void 0)
-        return false;
-      newNode.left = this._Sentinel;
-      newNode.right = this._Sentinel;
-      let y = void 0;
-      let x = this.root;
-      while (x !== this._Sentinel) {
-        y = x;
-        if (x) {
-          if (newNode.key < x.key) {
-            x = x.left;
-          } else if (newNode.key > x.key) {
-            x = x == null ? void 0 : x.right;
-          } else {
-            if (newNode !== x) {
-              this._replaceNode(x, newNode);
-            }
-            return false;
-          }
-        }
-      }
-      newNode.parent = y;
-      if (y === void 0) {
-        this._setRoot(newNode);
-      } else if (newNode.key < y.key) {
-        y.left = newNode;
-      } else {
-        y.right = newNode;
-      }
-      if (newNode.parent === void 0) {
-        newNode.color = 0 /* BLACK */;
-        this._size++;
-        return false;
-      }
-      if (newNode.parent.parent === void 0) {
-        this._size++;
-        return false;
-      }
-      this._fixInsert(newNode);
-      this._size++;
-      return true;
+    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+      var _a;
+      if (identifier instanceof RedBlackTreeNode)
+        callback = (node) => node;
+      return (_a = super.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
     }
     /**
-     * Time Complexity: O(log n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `delete` function removes a node from a binary tree based on a given identifier and updates
-     * the tree accordingly.
-     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
-     * that you want to use to identify the node that you want to delete from the binary tree. It can be
-     * of any type that is returned by the callback function `C`. It can also be `null` or `undefined` if
-     * you don't want to
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` and
-     * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
-     * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
+     * The "clear" function sets the root node of a data structure to a sentinel value and resets the
+     * size counter to zero.
      */
-    delete(identifier, callback = this._defaultOneParamCallback) {
-      const ans = [];
-      if (identifier === null)
-        return ans;
-      const helper = (node) => {
-        let z = this._Sentinel;
-        let x, y;
-        while (node !== this._Sentinel) {
-          if (node && callback(node) === identifier) {
-            z = node;
-          }
-          if (node && identifier && callback(node) <= identifier) {
-            node = node.right;
-          } else {
-            node = node == null ? void 0 : node.left;
-          }
-        }
-        if (z === this._Sentinel) {
-          this._size--;
-          return;
-        }
-        y = z;
-        let yOriginalColor = y.color;
-        if (z.left === this._Sentinel) {
-          x = z.right;
-          this._rbTransplant(z, z.right);
-        } else if (z.right === this._Sentinel) {
-          x = z.left;
-          this._rbTransplant(z, z.left);
-        } else {
-          y = this.getLeftMost(z.right);
-          yOriginalColor = y.color;
-          x = y.right;
-          if (y.parent === z) {
-            x.parent = y;
-          } else {
-            this._rbTransplant(y, y.right);
-            y.right = z.right;
-            y.right.parent = y;
-          }
-          this._rbTransplant(z, y);
-          y.left = z.left;
-          y.left.parent = y;
-          y.color = z.color;
-        }
-        if (yOriginalColor === 0 /* BLACK */) {
-          this._fixDelete(x);
-        }
-        this._size--;
-        ans.push({ deleted: z, needBalanced: void 0 });
-      };
-      helper(this.root);
-      return ans;
+    clear() {
+      super.clear();
+      this._root = this.SENTINEL;
     }
     /**
      * Time Complexity: O(log n)
@@ -11433,43 +11369,30 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `getNode` retrieves a single node from a binary tree based on a given identifier and
-     * callback function.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value used to
-     * identify the node you want to retrieve. It can be of any type that is the return type of the `C`
-     * callback function. If the `identifier` is `undefined`, it means you want to retrieve the first
-     * node that matches the other criteria
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
-     * function should take a single parameter of type `NODE` (the type of the nodes in the binary tree) and
-     * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter is the starting point for
-     * searching for a node in a binary tree. It can be either a key value or a node object. If it is not
-     * provided, the search will start from the root of the binary tree.
-     * @param iterationType - The `iterationType` parameter is a variable that determines the type of
-     * iteration to be performed when searching for nodes in the binary tree. It is used in the
-     * `getNodes` method, which is called within the `getNode` method.
-     * @returns a value of type `NODE`, `null`, or `undefined`.
-     */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-      var _a;
-      if (identifier instanceof RedBlackTreeNode)
-        callback = (node) => node;
-      beginRoot = this.ensureNode(beginRoot);
-      return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The "clear" function sets the root node to the sentinel node and resets the size to 0.
+     * The function adds a new node to a Red-Black Tree data structure and returns a boolean indicating
+     * whether the operation was successful.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
+     * entry.
+     * @param {V} [value] - The `value` parameter is the value associated with the key that is being
+     * added to the tree.
+     * @returns The method is returning a boolean value. It returns true if the node was successfully
+     * added or updated, and false otherwise.
      */
-    clear() {
-      this._root = this._Sentinel;
-      this._size = 0;
+    add(keyOrNodeOrEntry, value) {
+      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
+      if (!this.isRealNode(newNode))
+        return false;
+      const insertStatus = this._insert(newNode);
+      if (insertStatus === "CREATED" /* CREATED */) {
+        if (this.isRealNode(this._root)) {
+          this._root.color = 0 /* BLACK */;
+        } else {
+          return false;
+        }
+        this._size++;
+        return true;
+      } else
+        return insertStatus === "UPDATED" /* UPDATED */;
     }
     /**
      * Time Complexity: O(log n)
@@ -11479,27 +11402,69 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function returns the predecessor of a given node in a red-black tree.
-     * @param {RedBlackTreeNode} x - The parameter `x` is of type `RedBlackTreeNode`, which represents a node in a
-     * Red-Black Tree.
-     * @returns the predecessor of the given RedBlackTreeNode 'x'.
+     * The function `delete` in a binary tree class deletes a node from the tree and fixes the tree if
+     * necessary.
+     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the
+     * identifier of the node that needs to be deleted from the binary tree. It can be of any type that
+     * is returned by the callback function `C`. It can also be `null` or `undefined` if the node to be
+     * deleted is not found.
+     * @param {C} callback - The `callback` parameter is a function that is used to retrieve a node from
+     * the binary tree based on its identifier. It is an optional parameter and if not provided, the
+     * `_defaultOneParamCallback` function is used as the default callback. The callback function should
+     * return the identifier of the node to
+     * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */
-    getPredecessor(x) {
-      if (this.isRealNode(x.left)) {
-        return this.getRightMost(x.left);
+    delete(identifier, callback = this._defaultOneParamCallback) {
+      if (identifier === null)
+        return [];
+      const results = [];
+      const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
+      if (!nodeToDelete) {
+        return results;
+      }
+      let originalColor = nodeToDelete.color;
+      let replacementNode;
+      if (!this.isRealNode(nodeToDelete.left)) {
+        replacementNode = nodeToDelete.right;
+        this._transplant(nodeToDelete, nodeToDelete.right);
+      } else if (!this.isRealNode(nodeToDelete.right)) {
+        replacementNode = nodeToDelete.left;
+        this._transplant(nodeToDelete, nodeToDelete.left);
+      } else {
+        const successor = this.getLeftMost(nodeToDelete.right);
+        if (successor) {
+          originalColor = successor.color;
+          replacementNode = successor.right;
+          if (successor.parent === nodeToDelete) {
+            if (this.isRealNode(replacementNode)) {
+              replacementNode.parent = successor;
+            }
+          } else {
+            this._transplant(successor, successor.right);
+            successor.right = nodeToDelete.right;
+            if (this.isRealNode(successor.right)) {
+              successor.right.parent = successor;
+            }
+          }
+          this._transplant(nodeToDelete, successor);
+          successor.left = nodeToDelete.left;
+          if (this.isRealNode(successor.left)) {
+            successor.left.parent = successor;
+          }
+          successor.color = nodeToDelete.color;
+        }
       }
-      let y = x.parent;
-      while (this.isRealNode(y) && x === y.left) {
-        x = y;
-        y = y.parent;
+      this._size--;
+      if (originalColor === 0 /* BLACK */) {
+        this._deleteFixup(replacementNode);
       }
-      return y;
+      results.push({ deleted: nodeToDelete, needBalanced: void 0 });
+      return results;
     }
     /**
-     * The function sets the root node of a tree structure and updates the parent property of the new
-     * root node.
-     * @param {NODE} v - The parameter "v" is of type "NODE", which represents a node in a data
-     * structure.
+     * The function sets the root of a tree-like structure and updates the parent property of the new
+     * root.
+     * @param {NODE | undefined} v - v is a parameter of type NODE or undefined.
      */
     _setRoot(v) {
       if (v) {
@@ -11515,28 +11480,61 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function performs a left rotation on a binary tree node.
-     * @param {RedBlackTreeNode} x - The parameter `x` is of type `NODE`, which likely represents a node in a binary tree.
+     * The function replaces an old node with a new node while preserving the color of the old node.
+     * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
+     * the data structure.
+     * @param {NODE} newNode - The `newNode` parameter is the new node that will replace the old node in
+     * the data structure.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, with the `oldNode` and `newNode` parameters.
      */
-    _leftRotate(x) {
-      if (x.right) {
-        const y = x.right;
-        x.right = y.left;
-        if (y.left !== this._Sentinel) {
-          if (y.left)
-            y.left.parent = x;
-        }
-        y.parent = x.parent;
-        if (x.parent === void 0) {
-          this._setRoot(y);
-        } else if (x === x.parent.left) {
-          x.parent.left = y;
+    _replaceNode(oldNode, newNode) {
+      newNode.color = oldNode.color;
+      return super._replaceNode(oldNode, newNode);
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The `_insert` function inserts or updates a node in a binary search tree and performs necessary
+     * fix-ups to maintain the red-black tree properties.
+     * @param {NODE} node - The `node` parameter represents the node that needs to be inserted into a
+     * binary search tree. It contains a `key` property that is used to determine the position of the
+     * node in the tree.
+     * @returns {'inserted' | 'updated'} - The result of the insertion.
+     */
+    _insert(node) {
+      var _a, _b;
+      let current = this.root;
+      let parent = void 0;
+      while (this.isRealNode(current)) {
+        parent = current;
+        if (node.key < current.key) {
+          current = (_a = current.left) != null ? _a : this.SENTINEL;
+        } else if (node.key > current.key) {
+          current = (_b = current.right) != null ? _b : this.SENTINEL;
         } else {
-          x.parent.right = y;
+          this._replaceNode(current, node);
+          return "UPDATED" /* UPDATED */;
         }
-        y.left = x;
-        x.parent = y;
       }
+      node.parent = parent;
+      if (!parent) {
+        this._setRoot(node);
+      } else if (node.key < parent.key) {
+        parent.left = node;
+      } else {
+        parent.right = node;
+      }
+      node.left = this.SENTINEL;
+      node.right = this.SENTINEL;
+      node.color = 1 /* RED */;
+      this._insertFixup(node);
+      return "CREATED" /* CREATED */;
     }
     /**
      * Time Complexity: O(1)
@@ -11546,28 +11544,21 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function performs a right rotation on a red-black tree node.
-     * @param {RedBlackTreeNode} x - x is a RedBlackTreeNode, which represents the node that needs to be right
-     * rotated.
+     * The function `_transplant` is used to replace a node `u` with another node `v` in a binary tree.
+     * @param {NODE} u - The parameter "u" represents a node in a binary tree.
+     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`, which means it can
+     * either be a `NODE` object or `undefined`.
      */
-    _rightRotate(x) {
-      if (x.left) {
-        const y = x.left;
-        x.left = y.right;
-        if (y.right !== this._Sentinel) {
-          if (y.right)
-            y.right.parent = x;
-        }
-        y.parent = x.parent;
-        if (x.parent === void 0) {
-          this._setRoot(y);
-        } else if (x === x.parent.right) {
-          x.parent.right = y;
-        } else {
-          x.parent.left = y;
-        }
-        y.right = x;
-        x.parent = y;
+    _transplant(u, v) {
+      if (!u.parent) {
+        this._setRoot(v);
+      } else if (u === u.parent.left) {
+        u.parent.left = v;
+      } else {
+        u.parent.right = v;
+      }
+      if (v) {
+        v.parent = u.parent;
       }
     }
     /**
@@ -11578,55 +11569,53 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
-     * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
-     * red-black tree.
-     */
-    _fixInsert(k) {
-      let u;
-      while (k.parent && k.parent.color === 1 /* RED */) {
-        if (k.parent.parent && k.parent === k.parent.parent.right) {
-          u = k.parent.parent.left;
-          if (u && u.color === 1 /* RED */) {
-            k.parent.color = 0 /* BLACK */;
-            u.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
-            k = k.parent.parent;
+     * The `_insertFixup` function is used to fix the Red-Black Tree after inserting a new node.
+     * @param {NODE | undefined} z - The parameter `z` represents a node in the Red-Black Tree. It can
+     * either be a valid node object or `undefined`.
+     */
+    _insertFixup(z) {
+      var _a, _b, _c, _d;
+      while (((_a = z == null ? void 0 : z.parent) == null ? void 0 : _a.color) === 1 /* RED */) {
+        if (z.parent === ((_b = z.parent.parent) == null ? void 0 : _b.left)) {
+          const y = z.parent.parent.right;
+          if ((y == null ? void 0 : y.color) === 1 /* RED */) {
+            z.parent.color = 0 /* BLACK */;
+            y.color = 0 /* BLACK */;
+            z.parent.parent.color = 1 /* RED */;
+            z = z.parent.parent;
           } else {
-            if (k === k.parent.left) {
-              k = k.parent;
-              this._rightRotate(k);
+            if (z === z.parent.right) {
+              z = z.parent;
+              this._leftRotate(z);
             }
-            if (k.parent.color === 1 /* RED */) {
-              k.parent.color = 0 /* BLACK */;
-              k.parent.parent.color = 1 /* RED */;
+            if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
+              z.parent.color = 0 /* BLACK */;
+              z.parent.parent.color = 1 /* RED */;
+              this._rightRotate(z.parent.parent);
             }
-            this._leftRotate(k.parent.parent);
           }
         } else {
-          u = k.parent.parent.right;
-          if (u && u.color === 1 /* RED */) {
-            k.parent.color = 0 /* BLACK */;
-            u.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
-            k = k.parent.parent;
+          const y = (_d = (_c = z == null ? void 0 : z.parent) == null ? void 0 : _c.parent) == null ? void 0 : _d.left;
+          if ((y == null ? void 0 : y.color) === 1 /* RED */) {
+            z.parent.color = 0 /* BLACK */;
+            y.color = 0 /* BLACK */;
+            z.parent.parent.color = 1 /* RED */;
+            z = z.parent.parent;
           } else {
-            if (k === k.parent.right) {
-              k = k.parent;
-              this._leftRotate(k);
+            if (z === z.parent.left) {
+              z = z.parent;
+              this._rightRotate(z);
             }
-            if (k.parent.color === 1 /* RED */) {
-              k.parent.color = 0 /* BLACK */;
-              k.parent.parent.color = 1 /* RED */;
+            if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
+              z.parent.color = 0 /* BLACK */;
+              z.parent.parent.color = 1 /* RED */;
+              this._leftRotate(z.parent.parent);
             }
-            this._rightRotate(k.parent.parent);
           }
         }
-        if (k === this.root) {
-          break;
-        }
       }
-      this.root.color = 0 /* BLACK */;
+      if (this.isRealNode(this._root))
+        this._root.color = 0 /* BLACK */;
     }
     /**
      * Time Complexity: O(log n)
@@ -11636,69 +11625,75 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `_fixDelete` is used to fix the red-black tree after a node deletion.
-     * @param {RedBlackTreeNode} x - The parameter `x` represents a node in a Red-Black Tree (RBT).
+     * The `_deleteFixup` function is used to fix the red-black tree after a node deletion by adjusting
+     * the colors and performing rotations.
+     * @param {NODE | undefined} node - The `node` parameter represents a node in a Red-Black Tree data
+     * structure. It can be either a valid node object or `undefined`.
+     * @returns The function does not return any value. It has a return type of `void`.
      */
-    _fixDelete(x) {
-      let s;
-      while (x !== this.root && x.color === 0 /* BLACK */) {
-        if (x.parent && x === x.parent.left) {
-          s = x.parent.right;
-          if (s.color === 1) {
-            s.color = 0 /* BLACK */;
-            x.parent.color = 1 /* RED */;
-            this._leftRotate(x.parent);
-            s = x.parent.right;
+    _deleteFixup(node) {
+      var _a, _b, _c, _d;
+      if (!node || node === this.root || node.color === 0 /* BLACK */) {
+        if (node) {
+          node.color = 0 /* BLACK */;
+        }
+        return;
+      }
+      while (node && node !== this.root && node.color === 0 /* BLACK */) {
+        const parent = node.parent;
+        if (!parent) {
+          break;
+        }
+        if (node === parent.left) {
+          let sibling = parent.right;
+          if ((sibling == null ? void 0 : sibling.color) === 1 /* RED */) {
+            sibling.color = 0 /* BLACK */;
+            parent.color = 1 /* RED */;
+            this._leftRotate(parent);
+            sibling = parent.right;
           }
-          if (s.left !== void 0 && s.left.color === 0 /* BLACK */ && s.right && s.right.color === 0 /* BLACK */) {
-            s.color = 1 /* RED */;
-            x = x.parent;
+          if (((_b = (_a = sibling == null ? void 0 : sibling.left) == null ? void 0 : _a.color) != null ? _b : 0 /* BLACK */) === 0 /* BLACK */) {
+            if (sibling)
+              sibling.color = 1 /* RED */;
+            node = parent;
           } else {
-            if (s.right && s.right.color === 0 /* BLACK */) {
-              if (s.left)
-                s.left.color = 0 /* BLACK */;
-              s.color = 1 /* RED */;
-              this._rightRotate(s);
-              s = x.parent.right;
-            }
-            if (s)
-              s.color = x.parent.color;
-            x.parent.color = 0 /* BLACK */;
-            if (s && s.right)
-              s.right.color = 0 /* BLACK */;
-            this._leftRotate(x.parent);
-            x = this.root;
+            if (sibling == null ? void 0 : sibling.left)
+              sibling.left.color = 0 /* BLACK */;
+            if (sibling)
+              sibling.color = parent.color;
+            parent.color = 0 /* BLACK */;
+            this._rightRotate(parent);
+            node = this.root;
           }
         } else {
-          s = x.parent.left;
-          if (s.color === 1) {
-            s.color = 0 /* BLACK */;
-            x.parent.color = 1 /* RED */;
-            this._rightRotate(x.parent);
-            s = x.parent.left;
+          let sibling = parent.left;
+          if ((sibling == null ? void 0 : sibling.color) === 1 /* RED */) {
+            sibling.color = 0 /* BLACK */;
+            if (parent)
+              parent.color = 1 /* RED */;
+            this._rightRotate(parent);
+            if (parent)
+              sibling = parent.left;
           }
-          if (s && s.right && s.right.color === 0 /* BLACK */ && s.right.color === 0 /* BLACK */) {
-            s.color = 1 /* RED */;
-            x = x.parent;
+          if (((_d = (_c = sibling == null ? void 0 : sibling.right) == null ? void 0 : _c.color) != null ? _d : 0 /* BLACK */) === 0 /* BLACK */) {
+            if (sibling)
+              sibling.color = 1 /* RED */;
+            node = parent;
           } else {
-            if (s && s.left && s.left.color === 0 /* BLACK */) {
-              if (s.right)
-                s.right.color = 0 /* BLACK */;
-              s.color = 1 /* RED */;
-              this._leftRotate(s);
-              s = x.parent.left;
-            }
-            if (s)
-              s.color = x.parent.color;
-            x.parent.color = 0 /* BLACK */;
-            if (s && s.left)
-              s.left.color = 0 /* BLACK */;
-            this._rightRotate(x.parent);
-            x = this.root;
+            if (sibling == null ? void 0 : sibling.right)
+              sibling.right.color = 0 /* BLACK */;
+            if (sibling)
+              sibling.color = parent.color;
+            if (parent)
+              parent.color = 0 /* BLACK */;
+            this._leftRotate(parent);
+            node = this.root;
           }
         }
       }
-      x.color = 0 /* BLACK */;
+      if (node) {
+        node.color = 0 /* BLACK */;
+      }
     }
     /**
      * Time Complexity: O(1)
@@ -11708,32 +11703,63 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_rbTransplant` replaces one node in a red-black tree with another node.
-     * @param {RedBlackTreeNode} u - The parameter "u" represents a RedBlackTreeNode object.
-     * @param {RedBlackTreeNode} v - The parameter "v" is a RedBlackTreeNode object.
+     * The `_leftRotate` function performs a left rotation on a given node in a binary tree.
+     * @param {NODE | undefined} x - The parameter `x` is of type `NODE | undefined`. It represents a
+     * node in a binary tree or `undefined` if there is no node.
+     * @returns void, which means it does not return any value.
      */
-    _rbTransplant(u, v) {
-      if (u.parent === void 0) {
-        this._setRoot(v);
-      } else if (u === u.parent.left) {
-        u.parent.left = v;
+    _leftRotate(x) {
+      if (!x || !x.right) {
+        return;
+      }
+      const y = x.right;
+      x.right = y.left;
+      if (this.isRealNode(y.left)) {
+        y.left.parent = x;
+      }
+      y.parent = x.parent;
+      if (!x.parent) {
+        this._setRoot(y);
+      } else if (x === x.parent.left) {
+        x.parent.left = y;
       } else {
-        u.parent.right = v;
+        x.parent.right = y;
       }
-      v.parent = u.parent;
+      y.left = x;
+      x.parent = y;
     }
     /**
-     * The function replaces an old node with a new node while preserving the color of the old node.
-     * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in a
-     * data structure. It is of type `NODE`, which is the type of the nodes in the data structure.
-     * @param {NODE} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
-     * data structure.
-     * @returns The method is returning the result of calling the `_replaceNode` method from the
-     * superclass, passing in the `oldNode` and `newNode` as arguments.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
-    _replaceNode(oldNode, newNode) {
-      newNode.color = oldNode.color;
-      return super._replaceNode(oldNode, newNode);
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `_rightRotate` function performs a right rotation on a given node in a binary tree.
+     * @param {NODE | undefined} y - The parameter `y` is of type `NODE | undefined`. It represents a
+     * node in a binary tree or `undefined` if there is no node.
+     * @returns void, which means it does not return any value.
+     */
+    _rightRotate(y) {
+      if (!y || !y.left) {
+        return;
+      }
+      const x = y.left;
+      y.left = x.right;
+      if (this.isRealNode(x.right)) {
+        x.right.parent = y;
+      }
+      x.parent = y.parent;
+      if (!y.parent) {
+        this._setRoot(x);
+      } else if (y === y.parent.left) {
+        y.parent.left = x;
+      } else {
+        y.parent.right = x;
+      }
+      x.right = y;
+      y.parent = x;
     }
   };
 
@@ -11784,6 +11810,9 @@ var dataStructureTyped = (() => {
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count() {
+      return this._count;
+    }
+    getMutableCount() {
       let sum = 0;
       this.dfs((node) => sum += node.count);
       return sum;
@@ -12140,6 +12169,9 @@ var dataStructureTyped = (() => {
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count() {
+      return this._count;
+    }
+    getMutableCount() {
       let sum = 0;
       this.dfs((node) => sum += node.count);
       return sum;
@@ -12232,14 +12264,14 @@ var dataStructureTyped = (() => {
      */
     add(keyOrNodeOrEntry, value, count = 1) {
       const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
-      if (newNode === void 0)
+      const orgCount = (newNode == null ? void 0 : newNode.count) || 0;
+      const isSuccessAdded = super.add(newNode);
+      if (isSuccessAdded) {
+        this._count += orgCount;
+        return true;
+      } else {
         return false;
-      const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
-      const inserted = super.add(newNode);
-      if (inserted) {
-        this._count += orgNodeCount;
       }
-      return true;
     }
     /**
      * Time Complexity: O(log n)
@@ -12266,63 +12298,83 @@ var dataStructureTyped = (() => {
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */
     delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
-      const deleteResults = [];
       if (identifier === null)
-        return deleteResults;
-      const deleteHelper = (node) => {
-        let targetNode = this._Sentinel;
-        let currentNode;
-        while (node !== this._Sentinel) {
-          if (node && callback(node) === identifier) {
-            targetNode = node;
-          }
-          if (node && identifier && callback(node) <= identifier) {
-            node = node.right;
-          } else {
-            node = node == null ? void 0 : node.left;
-          }
-        }
-        if (targetNode === this._Sentinel) {
-          return;
+        return [];
+      const results = [];
+      const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
+      if (!nodeToDelete) {
+        return results;
+      }
+      let originalColor = nodeToDelete.color;
+      let replacementNode;
+      if (!this.isRealNode(nodeToDelete.left)) {
+        replacementNode = nodeToDelete.right;
+        if (ignoreCount || nodeToDelete.count <= 1) {
+          this._transplant(nodeToDelete, nodeToDelete.right);
+          this._count -= nodeToDelete.count;
+        } else {
+          nodeToDelete.count--;
+          this._count--;
+          results.push({ deleted: nodeToDelete, needBalanced: void 0 });
+          return results;
+        }
+      } else if (!this.isRealNode(nodeToDelete.right)) {
+        replacementNode = nodeToDelete.left;
+        if (ignoreCount || nodeToDelete.count <= 1) {
+          this._transplant(nodeToDelete, nodeToDelete.left);
+          this._count -= nodeToDelete.count;
+        } else {
+          nodeToDelete.count--;
+          this._count--;
+          results.push({ deleted: nodeToDelete, needBalanced: void 0 });
+          return results;
         }
-        if (ignoreCount || targetNode.count <= 1) {
-          let parentNode = targetNode;
-          let parentNodeOriginalColor = parentNode.color;
-          if (targetNode.left === this._Sentinel) {
-            currentNode = targetNode.right;
-            this._rbTransplant(targetNode, targetNode.right);
-          } else if (targetNode.right === this._Sentinel) {
-            currentNode = targetNode.left;
-            this._rbTransplant(targetNode, targetNode.left);
+      } else {
+        const successor = this.getLeftMost(nodeToDelete.right);
+        if (successor) {
+          originalColor = successor.color;
+          replacementNode = successor.right;
+          if (successor.parent === nodeToDelete) {
+            if (this.isRealNode(replacementNode)) {
+              replacementNode.parent = successor;
+            }
           } else {
-            parentNode = this.getLeftMost(targetNode.right);
-            parentNodeOriginalColor = parentNode.color;
-            currentNode = parentNode.right;
-            if (parentNode.parent === targetNode) {
-              currentNode.parent = parentNode;
+            if (ignoreCount || nodeToDelete.count <= 1) {
+              this._transplant(successor, successor.right);
+              this._count -= nodeToDelete.count;
             } else {
-              this._rbTransplant(parentNode, parentNode.right);
-              parentNode.right = targetNode.right;
-              parentNode.right.parent = parentNode;
+              nodeToDelete.count--;
+              this._count--;
+              results.push({ deleted: nodeToDelete, needBalanced: void 0 });
+              return results;
+            }
+            successor.right = nodeToDelete.right;
+            if (this.isRealNode(successor.right)) {
+              successor.right.parent = successor;
             }
-            this._rbTransplant(targetNode, parentNode);
-            parentNode.left = targetNode.left;
-            parentNode.left.parent = parentNode;
-            parentNode.color = targetNode.color;
           }
-          if (parentNodeOriginalColor === 0 /* BLACK */) {
-            this._fixDelete(currentNode);
+          if (ignoreCount || nodeToDelete.count <= 1) {
+            this._transplant(nodeToDelete, successor);
+            this._count -= nodeToDelete.count;
+          } else {
+            nodeToDelete.count--;
+            this._count--;
+            results.push({ deleted: nodeToDelete, needBalanced: void 0 });
+            return results;
           }
-          this._size--;
-          this._count -= targetNode.count;
-          deleteResults.push({ deleted: targetNode, needBalanced: void 0 });
-        } else {
-          targetNode.count--;
-          this._count--;
+          successor.left = nodeToDelete.left;
+          if (this.isRealNode(successor.left)) {
+            successor.left.parent = successor;
+          }
+          successor.color = nodeToDelete.color;
         }
-      };
-      deleteHelper(this.root);
-      return deleteResults;
+      }
+      this._size--;
+      if (originalColor === 0 /* BLACK */) {
+        this._deleteFixup(replacementNode);
+      }
+      results.push({ deleted: nodeToDelete, needBalanced: void 0 });
+      return results;
     }
     /**
      * Time Complexity: O(1)