data-structure-typed 1.50.6 → 1.50.8

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

@@ -110,11 +110,9 @@ var dataStructureTyped = (() => {
     AbstractVertex: () => AbstractVertex,
     BST: () => BST,
     BSTNode: () => BSTNode,
-    BSTVariant: () => BSTVariant,
     BinaryIndexedTree: () => BinaryIndexedTree,
     BinaryTree: () => BinaryTree,
     BinaryTreeNode: () => BinaryTreeNode,
-    CP: () => CP,
     Character: () => Character,
     Deque: () => Deque,
     DirectedEdge: () => DirectedEdge,
@@ -122,14 +120,12 @@ var dataStructureTyped = (() => {
     DirectedVertex: () => DirectedVertex,
     DoublyLinkedList: () => DoublyLinkedList,
     DoublyLinkedListNode: () => DoublyLinkedListNode,
-    FamilyPosition: () => FamilyPosition,
     FibonacciHeap: () => FibonacciHeap,
     FibonacciHeapNode: () => FibonacciHeapNode,
     HashMap: () => HashMap,
     Heap: () => Heap,
     IterableElementBase: () => IterableElementBase,
     IterableEntryBase: () => IterableEntryBase,
-    IterationType: () => IterationType,
     LinkedHashMap: () => LinkedHashMap,
     LinkedListQueue: () => LinkedListQueue,
     MapEdge: () => MapEdge,
@@ -7655,41 +7651,6 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/types/data-structures/binary-tree/rb-tree.ts
-  var RBTNColor = /* @__PURE__ */ ((RBTNColor2) => {
-    RBTNColor2[RBTNColor2["RED"] = 1] = "RED";
-    RBTNColor2[RBTNColor2["BLACK"] = 0] = "BLACK";
-    return RBTNColor2;
-  })(RBTNColor || {});
-
-  // src/types/common.ts
-  var BSTVariant = /* @__PURE__ */ ((BSTVariant2) => {
-    BSTVariant2["STANDARD"] = "STANDARD";
-    BSTVariant2["INVERSE"] = "INVERSE";
-    return BSTVariant2;
-  })(BSTVariant || {});
-  var CP = /* @__PURE__ */ ((CP2) => {
-    CP2["lt"] = "lt";
-    CP2["eq"] = "eq";
-    CP2["gt"] = "gt";
-    return CP2;
-  })(CP || {});
-  var IterationType = /* @__PURE__ */ ((IterationType2) => {
-    IterationType2["ITERATIVE"] = "ITERATIVE";
-    IterationType2["RECURSIVE"] = "RECURSIVE";
-    return IterationType2;
-  })(IterationType || {});
-  var FamilyPosition = /* @__PURE__ */ ((FamilyPosition2) => {
-    FamilyPosition2["ROOT"] = "ROOT";
-    FamilyPosition2["LEFT"] = "LEFT";
-    FamilyPosition2["RIGHT"] = "RIGHT";
-    FamilyPosition2["ROOT_LEFT"] = "ROOT_LEFT";
-    FamilyPosition2["ROOT_RIGHT"] = "ROOT_RIGHT";
-    FamilyPosition2["ISOLATED"] = "ISOLATED";
-    FamilyPosition2["MAL_NODE"] = "MAL_NODE";
-    return FamilyPosition2;
-  })(FamilyPosition || {});
-
   // src/data-structures/binary-tree/binary-tree.ts
   var BinaryTreeNode = class {
     /**
@@ -7754,14 +7715,14 @@ var dataStructureTyped = (() => {
     get familyPosition() {
       const that = this;
       if (!this.parent) {
-        return this.left || this.right ? "ROOT" /* ROOT */ : "ISOLATED" /* ISOLATED */;
+        return this.left || this.right ? "ROOT" : "ISOLATED";
       }
       if (this.parent.left === that) {
-        return this.left || this.right ? "ROOT_LEFT" /* ROOT_LEFT */ : "LEFT" /* LEFT */;
+        return this.left || this.right ? "ROOT_LEFT" : "LEFT";
       } else if (this.parent.right === that) {
-        return this.left || this.right ? "ROOT_RIGHT" /* ROOT_RIGHT */ : "RIGHT" /* RIGHT */;
+        return this.left || this.right ? "ROOT_RIGHT" : "RIGHT";
       }
-      return "MAL_NODE" /* MAL_NODE */;
+      return "MAL_NODE";
     }
   };
   var BinaryTree = class _BinaryTree extends IterableEntryBase {
@@ -7776,8 +7737,8 @@ var dataStructureTyped = (() => {
      */
     constructor(keysOrNodesOrEntries = [], options) {
       super();
-      __publicField(this, "iterationType", "ITERATIVE" /* ITERATIVE */);
-      __publicField(this, "_extractor", (key) => Number(key));
+      __publicField(this, "iterationType", "ITERATIVE");
+      __publicField(this, "_extractor", (key) => typeof key === "number" ? key : Number(key));
       __publicField(this, "_root");
       __publicField(this, "_size");
       __publicField(this, "_defaultOneParamCallback", (node) => node ? node.key : void 0);
@@ -7879,11 +7840,11 @@ var dataStructureTyped = (() => {
      * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be used when searching for a node by key. It has a default value of
-     * `IterationType.ITERATIVE`.
+     * `'ITERATIVE'`.
      * @returns either the node corresponding to the given key if it is a valid node key, or the key
      * itself if it is not a valid node key.
      */
-    ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE" /* ITERATIVE */) {
+    ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE") {
       let res;
       if (this.isRealNode(keyOrNodeOrEntry)) {
         res = keyOrNodeOrEntry;
@@ -8099,9 +8060,9 @@ var dataStructureTyped = (() => {
         }
       } else if (parent) {
         const { familyPosition: fp } = curr;
-        if (fp === "LEFT" /* LEFT */ || fp === "ROOT_LEFT" /* ROOT_LEFT */) {
+        if (fp === "LEFT" || fp === "ROOT_LEFT") {
           parent.left = curr.right;
-        } else if (fp === "RIGHT" /* RIGHT */ || fp === "ROOT_RIGHT" /* ROOT_RIGHT */) {
+        } else if (fp === "RIGHT" || fp === "ROOT_RIGHT") {
           parent.right = curr.right;
         }
         needBalanced = parent;
@@ -8149,7 +8110,7 @@ var dataStructureTyped = (() => {
       if (!beginRoot)
         return [];
       const ans = [];
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const _traverse = (cur) => {
           if (callback(cur) === identifier) {
             ans.push(cur);
@@ -8228,10 +8189,10 @@ var dataStructureTyped = (() => {
      * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
-    getNodeByKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
+    getNodeByKey(key, iterationType = "ITERATIVE") {
       if (!this.root)
         return void 0;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const _dfs = (cur) => {
           if (cur.key === key)
             return cur;
@@ -8384,7 +8345,7 @@ var dataStructureTyped = (() => {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return true;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const dfs = (cur, min, max) => {
           if (!this.isRealNode(cur))
             return true;
@@ -8469,9 +8430,9 @@ 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 */) {
+      if (iterationType === "RECURSIVE") {
         const _getMaxHeight = (cur) => {
           if (!this.isRealNode(cur))
             return -1;
@@ -8516,11 +8477,11 @@ var dataStructureTyped = (() => {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return -1;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "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 +8493,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,10 +8564,12 @@ 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 */) {
+      if (iterationType === "RECURSIVE") {
         const _traverse = (cur) => {
           if (!this.isRealNode(cur.left))
             return cur;
@@ -8642,10 +8605,12 @@ 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;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const _traverse = (cur) => {
           if (!this.isRealNode(cur.right))
             return cur;
@@ -8742,12 +8707,12 @@ var dataStructureTyped = (() => {
        * `false`, null or undefined
        * @returns an array of values that are the return values of the callback function.
        */
-    dfs(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root, iterationType = "ITERATIVE" /* ITERATIVE */, includeNull = false) {
+    dfs(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root, iterationType = "ITERATIVE", includeNull = false) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const _traverse = (node) => {
           switch (pattern) {
             case "in":
@@ -8871,7 +8836,7 @@ var dataStructureTyped = (() => {
       if (!beginRoot)
         return [];
       const ans = [];
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const queue = new Queue([beginRoot]);
         const traverse = (level) => {
           if (queue.size === 0)
@@ -8945,7 +8910,7 @@ var dataStructureTyped = (() => {
       const levelsNodes = [];
       if (!beginRoot)
         return levelsNodes;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const _recursive = (node, level) => {
           if (!levelsNodes[level])
             levelsNodes[level] = [];
@@ -9230,7 +9195,7 @@ var dataStructureTyped = (() => {
     *_getIterator(node = this.root) {
       if (!node)
         return;
-      if (this.iterationType === "ITERATIVE" /* ITERATIVE */) {
+      if (this.iterationType === "ITERATIVE") {
         const stack = [];
         let current = node;
         while (current || stack.length > 0) {
@@ -9429,7 +9394,7 @@ var dataStructureTyped = (() => {
     constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
       __publicField(this, "_root");
-      __publicField(this, "_variant", "STANDARD" /* STANDARD */);
+      __publicField(this, "_variant", "STANDARD");
       if (options) {
         const { variant } = options;
         if (variant)
@@ -9519,10 +9484,10 @@ var dataStructureTyped = (() => {
      * @param {K | NODE | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `NODE`, or
      * `undefined`.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
+     * type of iteration to be performed. It has a default value of `'ITERATIVE'`.
      * @returns either a node object (NODE) or undefined.
      */
-    ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE" /* ITERATIVE */) {
+    ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE") {
       let res;
       if (this.isRealNode(keyOrNodeOrEntry)) {
         res = keyOrNodeOrEntry;
@@ -9570,10 +9535,10 @@ var dataStructureTyped = (() => {
       }
       let current = this.root;
       while (current !== void 0) {
-        if (this._compare(current.key, newNode.key) === "eq" /* eq */) {
+        if (this._compare(current.key, newNode.key) === "EQ") {
           this._replaceNode(current, newNode);
           return true;
-        } else if (this._compare(current.key, newNode.key) === "gt" /* gt */) {
+        } else if (this._compare(current.key, newNode.key) === "GT") {
           if (current.left === void 0) {
             current.left = newNode;
             this._size++;
@@ -9681,7 +9646,7 @@ var dataStructureTyped = (() => {
           }
         }
       };
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         _dfs(sorted);
       } else {
         _iterate();
@@ -9706,18 +9671,18 @@ var dataStructureTyped = (() => {
      * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
-    getNodeByKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
-      if (!this.root)
+    getNodeByKey(key, iterationType = "ITERATIVE") {
+      if (!this.isRealNode(this.root))
         return void 0;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "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" && 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" && this.isRealNode(cur.right))
             return _dfs(cur.right);
         };
         return _dfs(this.root);
@@ -9725,13 +9690,13 @@ var dataStructureTyped = (() => {
         const queue = new Queue([this.root]);
         while (queue.size > 0) {
           const cur = queue.shift();
-          if (cur) {
-            if (this._compare(cur.key, key) === "eq" /* eq */)
+          if (this.isRealNode(cur)) {
+            if (this._compare(cur.key, key) === "EQ")
               return cur;
-            if (this._compare(cur.key, key) === "gt" /* gt */)
-              cur.left && queue.push(cur.left);
-            if (this._compare(cur.key, key) === "lt" /* lt */)
-              cur.right && queue.push(cur.right);
+            if (this._compare(cur.key, key) === "GT")
+              this.isRealNode(cur.left) && queue.push(cur.left);
+            if (this._compare(cur.key, key) === "LT")
+              this.isRealNode(cur.right) && queue.push(cur.right);
           }
         }
       }
@@ -9769,7 +9734,7 @@ var dataStructureTyped = (() => {
       if (!beginRoot)
         return [];
       const ans = [];
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const _traverse = (cur) => {
           const callbackResult = callback(cur);
           if (callbackResult === identifier) {
@@ -9777,24 +9742,24 @@ 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);
-            if (this._compare(cur.key, identifier) === "lt" /* lt */)
-              cur.right && _traverse(cur.right);
+            if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === "GT")
+              _traverse(cur.left);
+            if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === "LT")
+              _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);
       } else {
-        const queue = new Queue([beginRoot]);
-        while (queue.size > 0) {
-          const cur = queue.shift();
-          if (cur) {
+        const stack = [beginRoot];
+        while (stack.length > 0) {
+          const cur = stack.pop();
+          if (this.isRealNode(cur)) {
             const callbackResult = callback(cur);
             if (callbackResult === identifier) {
               ans.push(cur);
@@ -9802,13 +9767,13 @@ var dataStructureTyped = (() => {
                 return ans;
             }
             if (callback === this._defaultOneParamCallback) {
-              if (this._compare(cur.key, identifier) === "gt" /* gt */)
-                cur.left && queue.push(cur.left);
-              if (this._compare(cur.key, identifier) === "lt" /* lt */)
-                cur.right && queue.push(cur.right);
+              if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === "LT")
+                stack.push(cur.right);
+              if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === "GT")
+                stack.push(cur.left);
             } else {
-              cur.left && queue.push(cur.left);
-              cur.right && queue.push(cur.right);
+              this.isRealNode(cur.right) && stack.push(cur.right);
+              this.isRealNode(cur.left) && stack.push(cur.left);
             }
           }
         }
@@ -9838,7 +9803,7 @@ var dataStructureTyped = (() => {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root, iterationType = "ITERATIVE" /* ITERATIVE */) {
+    dfs(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root, iterationType = "ITERATIVE") {
       return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
@@ -9911,7 +9876,7 @@ var dataStructureTyped = (() => {
       let current = this.ensureNode(beginRoot);
       if (!current)
         return void 0;
-      if (this._variant === "STANDARD" /* STANDARD */) {
+      if (this._variant === "STANDARD") {
         while (current.right !== void 0) {
           current = current.right;
         }
@@ -9947,7 +9912,7 @@ var dataStructureTyped = (() => {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = "lt" /* lt */, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = "LT", targetNode = this.root, iterationType = this.iterationType) {
       targetNode = this.ensureNode(targetNode);
       const ans = [];
       if (!targetNode)
@@ -9955,7 +9920,7 @@ var dataStructureTyped = (() => {
       if (!this.root)
         return ans;
       const targetKey = targetNode.key;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const _traverse = (cur) => {
           const compared = this._compare(cur.key, targetKey);
           if (compared === lesserOrGreater)
@@ -10004,7 +9969,7 @@ var dataStructureTyped = (() => {
       this.clear();
       if (sorted.length < 1)
         return false;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const buildBalanceBST = (l, r) => {
           if (l > r)
             return;
@@ -10061,7 +10026,7 @@ var dataStructureTyped = (() => {
       if (!this.root)
         return true;
       let balanced = true;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const _height = (cur) => {
           if (!cur)
             return 0;
@@ -10115,14 +10080,24 @@ var dataStructureTyped = (() => {
      * is greater than, less than, or equal to the second value.
      * @param {K} a - The parameter "a" is of type K.
      * @param {K} b - The parameter "b" in the above code represents a K.
-     * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater
-     * than), CP.lt (less than), or CP.eq (equal).
+     * @returns a value of type CP (ComparisonResult). The possible return values are 'GT' (greater
+     * than), 'LT' (less than), or 'EQ' (equal).
      */
     _compare(a, b) {
       const extractedA = this.extractor(a);
       const extractedB = this.extractor(b);
-      const compared = this.variant === "STANDARD" /* STANDARD */ ? extractedA - extractedB : extractedB - extractedA;
-      return compared > 0 ? "gt" /* gt */ : compared < 0 ? "lt" /* lt */ : "eq" /* eq */;
+      const compared = this.variant === "STANDARD" ? extractedA - extractedB : extractedB - extractedA;
+      return compared > 0 ? "GT" : compared < 0 ? "LT" : "EQ";
+    }
+    _lt(a, b) {
+      const extractedA = this.extractor(a);
+      const extractedB = this.extractor(b);
+      return this.variant === "STANDARD" ? extractedA < extractedB : extractedA > extractedB;
+    }
+    _gt(a, b) {
+      const extractedA = this.extractor(a);
+      const extractedB = this.extractor(b);
+      return this.variant === "STANDARD" ? extractedA > extractedB : extractedA < extractedB;
     }
   };
 
@@ -11141,6 +11116,13 @@ var dataStructureTyped = (() => {
     }
   };
 
+  // src/types/data-structures/binary-tree/rb-tree.ts
+  var RBTNColor = /* @__PURE__ */ ((RBTNColor2) => {
+    RBTNColor2[RBTNColor2["RED"] = 1] = "RED";
+    RBTNColor2[RBTNColor2["BLACK"] = 0] = "BLACK";
+    return RBTNColor2;
+  })(RBTNColor || {});
+
   // src/data-structures/binary-tree/rb-tree.ts
   var RedBlackTreeNode = class extends BSTNode {
     /**
@@ -11189,7 +11171,6 @@ var dataStructureTyped = (() => {
       super([], options);
       __publicField(this, "_SENTINEL", new RedBlackTreeNode(NaN));
       __publicField(this, "_root");
-      __publicField(this, "_size", 0);
       this._root = this.SENTINEL;
       if (keysOrNodesOrEntries) {
         this.addMany(keysOrNodesOrEntries);
@@ -11209,13 +11190,6 @@ var dataStructureTyped = (() => {
     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 represents the key of the node being created. It is of type K,
@@ -11307,7 +11281,7 @@ var dataStructureTyped = (() => {
      * @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;
     }
@@ -11338,9 +11312,6 @@ var dataStructureTyped = (() => {
      */
     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;
     }
     /**
@@ -11355,8 +11326,8 @@ var dataStructureTyped = (() => {
      * size counter to zero.
      */
     clear() {
+      super.clear();
       this._root = this.SENTINEL;
-      this._size = 0;
     }
     /**
      * Time Complexity: O(log n)
@@ -11380,7 +11351,7 @@ var dataStructureTyped = (() => {
       if (!this.isRealNode(newNode))
         return false;
       const insertStatus = this._insert(newNode);
-      if (insertStatus === "inserted") {
+      if (insertStatus === "CREATED") {
         if (this.isRealNode(this._root)) {
           this._root.color = 0 /* BLACK */;
         } else {
@@ -11389,7 +11360,7 @@ var dataStructureTyped = (() => {
         this._size++;
         return true;
       } else
-        return insertStatus === "updated";
+        return insertStatus === "UPDATED";
     }
     /**
      * Time Complexity: O(log n)
@@ -11516,7 +11487,7 @@ var dataStructureTyped = (() => {
           current = (_b = current.right) != null ? _b : this.SENTINEL;
         } else {
           this._replaceNode(current, node);
-          return "updated";
+          return "UPDATED";
         }
       }
       node.parent = parent;
@@ -11531,7 +11502,7 @@ var dataStructureTyped = (() => {
       node.right = this.SENTINEL;
       node.color = 1 /* RED */;
       this._insertFixup(node);
-      return "inserted";
+      return "CREATED";
     }
     /**
      * Time Complexity: O(1)
@@ -11807,6 +11778,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;
@@ -11952,9 +11926,9 @@ var dataStructureTyped = (() => {
               this._setRoot(curr.right);
           } else {
             const { familyPosition: fp } = curr;
-            if (fp === "LEFT" /* LEFT */ || fp === "ROOT_LEFT" /* ROOT_LEFT */) {
+            if (fp === "LEFT" || fp === "ROOT_LEFT") {
               parent.left = curr.right;
-            } else if (fp === "RIGHT" /* RIGHT */ || fp === "ROOT_RIGHT" /* ROOT_RIGHT */) {
+            } else if (fp === "RIGHT" || fp === "ROOT_RIGHT") {
               parent.right = curr.right;
             }
             needBalanced = parent;
@@ -12018,7 +11992,7 @@ var dataStructureTyped = (() => {
       if (sorted.length < 1)
         return false;
       this.clear();
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const buildBalanceBST = (l, r) => {
           if (l > r)
             return;
@@ -12405,7 +12379,7 @@ var dataStructureTyped = (() => {
       if (sorted.length < 1)
         return false;
       this.clear();
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const buildBalanceBST = (l, r) => {
           if (l > r)
             return;