data-structure-typed 1.50.7 → 1.50.9

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

@@ -110,12 +110,9 @@ var dataStructureTyped = (() => {
     AbstractVertex: () => AbstractVertex,
     BST: () => BST,
     BSTNode: () => BSTNode,
-    BSTVariant: () => BSTVariant,
     BinaryIndexedTree: () => BinaryIndexedTree,
     BinaryTree: () => BinaryTree,
     BinaryTreeNode: () => BinaryTreeNode,
-    CP: () => CP,
-    CRUD: () => CRUD,
     Character: () => Character,
     Deque: () => Deque,
     DirectedEdge: () => DirectedEdge,
@@ -123,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,
@@ -144,7 +139,6 @@ var dataStructureTyped = (() => {
     Navigator: () => Navigator,
     PriorityQueue: () => PriorityQueue,
     Queue: () => Queue,
-    RBTNColor: () => RBTNColor,
     RedBlackTree: () => RedBlackTree,
     RedBlackTreeNode: () => RedBlackTreeNode,
     SegmentTree: () => SegmentTree,
@@ -4836,23 +4830,23 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(log n)
      *
      * Depth-first search (DFS) method, different traversal orders can be selected。
-     * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+     * @param order - Traverse order parameter: 'IN' (in-order), 'PRE' (pre-order) or 'POST' (post-order).
      * @returns An array containing elements traversed in the specified order.
      */
-    dfs(order = "pre") {
+    dfs(order = "PRE") {
       const result = [];
       const _dfs = (index) => {
         const left = 2 * index + 1, right = left + 1;
         if (index < this.size) {
-          if (order === "in") {
+          if (order === "IN") {
             _dfs(left);
             result.push(this.elements[index]);
             _dfs(right);
-          } else if (order === "pre") {
+          } else if (order === "PRE") {
             result.push(this.elements[index]);
             _dfs(left);
             _dfs(right);
-          } else if (order === "post") {
+          } else if (order === "POST") {
             _dfs(left);
             _dfs(right);
             result.push(this.elements[index]);
@@ -7656,48 +7650,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 || {});
-  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 {
     /**
@@ -7762,14 +7714,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 {
@@ -7784,8 +7736,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);
@@ -7887,11 +7839,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;
@@ -8107,9 +8059,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;
@@ -8157,7 +8109,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);
@@ -8236,10 +8188,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;
@@ -8392,7 +8344,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;
@@ -8479,7 +8431,7 @@ var dataStructureTyped = (() => {
       beginRoot = this.ensureNode(beginRoot);
       if (!this.isRealNode(beginRoot))
         return -1;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const _getMaxHeight = (cur) => {
           if (!this.isRealNode(cur))
             return -1;
@@ -8524,7 +8476,7 @@ var dataStructureTyped = (() => {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return -1;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const _getMinHeight = (cur) => {
           if (!this.isRealNode(cur))
             return 0;
@@ -8616,7 +8568,7 @@ var dataStructureTyped = (() => {
       beginRoot = this.ensureNode(beginRoot);
       if (!this.isRealNode(beginRoot))
         return beginRoot;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const _traverse = (cur) => {
           if (!this.isRealNode(cur.left))
             return cur;
@@ -8657,7 +8609,7 @@ var dataStructureTyped = (() => {
       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;
@@ -8754,15 +8706,15 @@ 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":
+            case "IN":
               if (includeNull) {
                 if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                   _traverse(node.left);
@@ -8777,7 +8729,7 @@ var dataStructureTyped = (() => {
                   _traverse(node.right);
               }
               break;
-            case "pre":
+            case "PRE":
               if (includeNull) {
                 this.isNodeOrNull(node) && ans.push(callback(node));
                 if (this.isRealNode(node) && this.isNodeOrNull(node.left))
@@ -8792,7 +8744,7 @@ var dataStructureTyped = (() => {
                   _traverse(node.right);
               }
               break;
-            case "post":
+            case "POST":
               if (includeNull) {
                 if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                   _traverse(node.left);
@@ -8827,17 +8779,17 @@ var dataStructureTyped = (() => {
             ans.push(callback(cur.node));
           } else {
             switch (pattern) {
-              case "in":
+              case "IN":
                 cur.node && stack.push({ opt: 0, node: cur.node.right });
                 stack.push({ opt: 1, node: cur.node });
                 cur.node && stack.push({ opt: 0, node: cur.node.left });
                 break;
-              case "pre":
+              case "PRE":
                 cur.node && stack.push({ opt: 0, node: cur.node.right });
                 cur.node && stack.push({ opt: 0, node: cur.node.left });
                 stack.push({ opt: 1, node: cur.node });
                 break;
-              case "post":
+              case "POST":
                 stack.push({ opt: 1, node: cur.node });
                 cur.node && stack.push({ opt: 0, node: cur.node.right });
                 cur.node && stack.push({ opt: 0, node: cur.node.left });
@@ -8883,7 +8835,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)
@@ -8957,7 +8909,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] = [];
@@ -9021,7 +8973,7 @@ var dataStructureTyped = (() => {
      * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
-    morris(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root) {
+    morris(callback = this._defaultOneParamCallback, pattern = "IN", beginRoot = this.root) {
       beginRoot = this.ensureNode(beginRoot);
       if (beginRoot === null)
         return [];
@@ -9048,7 +9000,7 @@ var dataStructureTyped = (() => {
         _reverseEdge(tail);
       };
       switch (pattern) {
-        case "in":
+        case "IN":
           while (cur) {
             if (cur.left) {
               const predecessor = this.getPredecessor(cur);
@@ -9064,7 +9016,7 @@ var dataStructureTyped = (() => {
             cur = cur.right;
           }
           break;
-        case "pre":
+        case "PRE":
           while (cur) {
             if (cur.left) {
               const predecessor = this.getPredecessor(cur);
@@ -9082,7 +9034,7 @@ var dataStructureTyped = (() => {
             cur = cur.right;
           }
           break;
-        case "post":
+        case "POST":
           while (cur) {
             if (cur.left) {
               const predecessor = this.getPredecessor(cur);
@@ -9242,7 +9194,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) {
@@ -9441,7 +9393,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)
@@ -9531,10 +9483,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;
@@ -9582,10 +9534,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++;
@@ -9693,7 +9645,7 @@ var dataStructureTyped = (() => {
           }
         }
       };
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         _dfs(sorted);
       } else {
         _iterate();
@@ -9718,18 +9670,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 */) {
+    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 (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return;
-          if (this._compare(cur.key, key) === "gt" /* gt */ && this.isRealNode(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 */ && this.isRealNode(cur.right))
+          if (this._compare(cur.key, key) === "LT" && this.isRealNode(cur.right))
             return _dfs(cur.right);
         };
         return _dfs(this.root);
@@ -9738,11 +9690,11 @@ var dataStructureTyped = (() => {
         while (queue.size > 0) {
           const cur = queue.shift();
           if (this.isRealNode(cur)) {
-            if (this._compare(cur.key, key) === "eq" /* eq */)
+            if (this._compare(cur.key, key) === "EQ")
               return cur;
-            if (this._compare(cur.key, key) === "gt" /* gt */)
+            if (this._compare(cur.key, key) === "GT")
               this.isRealNode(cur.left) && queue.push(cur.left);
-            if (this._compare(cur.key, key) === "lt" /* lt */)
+            if (this._compare(cur.key, key) === "LT")
               this.isRealNode(cur.right) && queue.push(cur.right);
           }
         }
@@ -9781,7 +9733,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) {
@@ -9792,10 +9744,10 @@ var dataStructureTyped = (() => {
           if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return;
           if (callback === this._defaultOneParamCallback) {
-            if (this._compare(cur.key, identifier) === "gt" /* gt */)
-              this.isRealNode(cur.left) && _traverse(cur.left);
-            if (this._compare(cur.key, identifier) === "lt" /* lt */)
-              this.isRealNode(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 {
             this.isRealNode(cur.left) && _traverse(cur.left);
             this.isRealNode(cur.right) && _traverse(cur.right);
@@ -9803,9 +9755,9 @@ var dataStructureTyped = (() => {
         };
         _traverse(beginRoot);
       } else {
-        const queue = new Queue([beginRoot]);
-        while (queue.size > 0) {
-          const cur = queue.shift();
+        const stack = [beginRoot];
+        while (stack.length > 0) {
+          const cur = stack.pop();
           if (this.isRealNode(cur)) {
             const callbackResult = callback(cur);
             if (callbackResult === identifier) {
@@ -9814,13 +9766,13 @@ var dataStructureTyped = (() => {
                 return ans;
             }
             if (callback === this._defaultOneParamCallback) {
-              if (this._compare(cur.key, identifier) === "gt" /* gt */)
-                this.isRealNode(cur.left) && queue.push(cur.left);
-              if (this._compare(cur.key, identifier) === "lt" /* lt */)
-                this.isRealNode(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 {
-              this.isRealNode(cur.left) && queue.push(cur.left);
-              this.isRealNode(cur.right) && queue.push(cur.right);
+              this.isRealNode(cur.right) && stack.push(cur.right);
+              this.isRealNode(cur.left) && stack.push(cur.left);
             }
           }
         }
@@ -9850,7 +9802,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);
     }
     /**
@@ -9923,7 +9875,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;
         }
@@ -9959,7 +9911,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)
@@ -9967,7 +9919,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)
@@ -10012,11 +9964,11 @@ var dataStructureTyped = (() => {
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
     perfectlyBalance(iterationType = this.iterationType) {
-      const sorted = this.dfs((node) => node, "in"), n = sorted.length;
+      const sorted = this.dfs((node) => node, "IN"), n = sorted.length;
       this.clear();
       if (sorted.length < 1)
         return false;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const buildBalanceBST = (l, r) => {
           if (l > r)
             return;
@@ -10073,7 +10025,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;
@@ -10127,14 +10079,41 @@ 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";
+    }
+    /**
+     * The function `_lt` compares two values `a` and `b` using an extractor function and returns true if
+     * `a` is less than `b` based on the specified variant.
+     * @param {K} a - The parameter "a" is of type "K", which means it can be any type. It represents the
+     * first value to be compared in the function.
+     * @param {K} b - The parameter `b` is of type `K`, which means it can be any type. It is used as one
+     * of the arguments for the comparison in the `_lt` function.
+     * @returns a boolean value.
+     */
+    _lt(a, b) {
+      const extractedA = this.extractor(a);
+      const extractedB = this.extractor(b);
+      return this.variant === "STANDARD" ? extractedA < extractedB : extractedA > extractedB;
+    }
+    /**
+     * The function compares two values using a custom extractor function and returns true if the first
+     * value is greater than the second value.
+     * @param {K} a - The parameter "a" is of type K, which means it can be any type.
+     * @param {K} b - The parameter "b" is of type K, which means it can be any type. It is used as one
+     * of the arguments for the comparison in the function.
+     * @returns a boolean value.
+     */
+    _gt(a, b) {
+      const extractedA = this.extractor(a);
+      const extractedB = this.extractor(b);
+      return this.variant === "STANDARD" ? extractedA > extractedB : extractedA < extractedB;
     }
   };
 
@@ -11164,9 +11143,9 @@ var dataStructureTyped = (() => {
      * associated with the key in the Red-Black Tree Node. It is not required and can be omitted when
      * creating a new instance of the Red-Black Tree Node.
      * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
-     * Tree Node. It is an optional parameter with a default value of `RBTNColor.BLACK`.
+     * Tree Node. It is an optional parameter with a default value of `'BLACK'`.
      */
-    constructor(key, value, color = 0 /* BLACK */) {
+    constructor(key, value, color = "BLACK") {
       super(key, value);
       __publicField(this, "_color");
       this._color = color;
@@ -11227,12 +11206,12 @@ var dataStructureTyped = (() => {
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
      * 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 is an optional parameter with a default value of "RBTNColor.BLACK". The color
-     * can be either "RBTNColor.RED" or "RBTNColor.BLACK".
+     * Red-Black Tree. It is an optional parameter with a default value of "'BLACK'". The color
+     * can be either "'RED'" or "'BLACK'".
      * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
      * value, and color.
      */
-    createNode(key, value, color = 0 /* BLACK */) {
+    createNode(key, value, color = "BLACK") {
       return new RedBlackTreeNode(key, value, color);
     }
     /**
@@ -11272,10 +11251,10 @@ var dataStructureTyped = (() => {
         if (key === void 0 || key === null) {
           return;
         } else {
-          node = this.createNode(key, value2, 1 /* RED */);
+          node = this.createNode(key, value2, "RED");
         }
       } else if (!this.isNode(keyOrNodeOrEntry)) {
-        node = this.createNode(keyOrNodeOrEntry, value, 1 /* RED */);
+        node = this.createNode(keyOrNodeOrEntry, value, "RED");
       } else {
         return;
       }
@@ -11342,9 +11321,7 @@ var dataStructureTyped = (() => {
      */
     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;
+      return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
     }
     /**
      * Time Complexity: O(1)
@@ -11383,16 +11360,16 @@ var dataStructureTyped = (() => {
       if (!this.isRealNode(newNode))
         return false;
       const insertStatus = this._insert(newNode);
-      if (insertStatus === "CREATED" /* CREATED */) {
+      if (insertStatus === "CREATED") {
         if (this.isRealNode(this._root)) {
-          this._root.color = 0 /* BLACK */;
+          this._root.color = "BLACK";
         } else {
           return false;
         }
         this._size++;
         return true;
       } else
-        return insertStatus === "UPDATED" /* UPDATED */;
+        return insertStatus === "UPDATED";
     }
     /**
      * Time Complexity: O(log n)
@@ -11455,7 +11432,7 @@ var dataStructureTyped = (() => {
         }
       }
       this._size--;
-      if (originalColor === 0 /* BLACK */) {
+      if (originalColor === "BLACK") {
         this._deleteFixup(replacementNode);
       }
       results.push({ deleted: nodeToDelete, needBalanced: void 0 });
@@ -11519,7 +11496,7 @@ var dataStructureTyped = (() => {
           current = (_b = current.right) != null ? _b : this.SENTINEL;
         } else {
           this._replaceNode(current, node);
-          return "UPDATED" /* UPDATED */;
+          return "UPDATED";
         }
       }
       node.parent = parent;
@@ -11532,9 +11509,9 @@ var dataStructureTyped = (() => {
       }
       node.left = this.SENTINEL;
       node.right = this.SENTINEL;
-      node.color = 1 /* RED */;
+      node.color = "RED";
       this._insertFixup(node);
-      return "CREATED" /* CREATED */;
+      return "CREATED";
     }
     /**
      * Time Complexity: O(1)
@@ -11575,13 +11552,13 @@ var dataStructureTyped = (() => {
      */
     _insertFixup(z) {
       var _a, _b, _c, _d;
-      while (((_a = z == null ? void 0 : z.parent) == null ? void 0 : _a.color) === 1 /* RED */) {
+      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;
-          if ((y == null ? void 0 : y.color) === 1 /* RED */) {
-            z.parent.color = 0 /* BLACK */;
-            y.color = 0 /* BLACK */;
-            z.parent.parent.color = 1 /* RED */;
+          if ((y == null ? void 0 : y.color) === "RED") {
+            z.parent.color = "BLACK";
+            y.color = "BLACK";
+            z.parent.parent.color = "RED";
             z = z.parent.parent;
           } else {
             if (z === z.parent.right) {
@@ -11589,17 +11566,17 @@ var dataStructureTyped = (() => {
               this._leftRotate(z);
             }
             if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-              z.parent.color = 0 /* BLACK */;
-              z.parent.parent.color = 1 /* RED */;
+              z.parent.color = "BLACK";
+              z.parent.parent.color = "RED";
               this._rightRotate(z.parent.parent);
             }
           }
         } else {
           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 */;
+          if ((y == null ? void 0 : y.color) === "RED") {
+            z.parent.color = "BLACK";
+            y.color = "BLACK";
+            z.parent.parent.color = "RED";
             z = z.parent.parent;
           } else {
             if (z === z.parent.left) {
@@ -11607,15 +11584,15 @@ var dataStructureTyped = (() => {
               this._rightRotate(z);
             }
             if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-              z.parent.color = 0 /* BLACK */;
-              z.parent.parent.color = 1 /* RED */;
+              z.parent.color = "BLACK";
+              z.parent.parent.color = "RED";
               this._leftRotate(z.parent.parent);
             }
           }
         }
       }
       if (this.isRealNode(this._root))
-        this._root.color = 0 /* BLACK */;
+        this._root.color = "BLACK";
     }
     /**
      * Time Complexity: O(log n)
@@ -11633,66 +11610,66 @@ var dataStructureTyped = (() => {
      */
     _deleteFixup(node) {
       var _a, _b, _c, _d;
-      if (!node || node === this.root || node.color === 0 /* BLACK */) {
+      if (!node || node === this.root || node.color === "BLACK") {
         if (node) {
-          node.color = 0 /* BLACK */;
+          node.color = "BLACK";
         }
         return;
       }
-      while (node && node !== this.root && node.color === 0 /* BLACK */) {
+      while (node && node !== this.root && node.color === "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 */;
+          if ((sibling == null ? void 0 : sibling.color) === "RED") {
+            sibling.color = "BLACK";
+            parent.color = "RED";
             this._leftRotate(parent);
             sibling = parent.right;
           }
-          if (((_b = (_a = sibling == null ? void 0 : sibling.left) == null ? void 0 : _a.color) != null ? _b : 0 /* BLACK */) === 0 /* BLACK */) {
+          if (((_b = (_a = sibling == null ? void 0 : sibling.left) == null ? void 0 : _a.color) != null ? _b : "BLACK") === "BLACK") {
             if (sibling)
-              sibling.color = 1 /* RED */;
+              sibling.color = "RED";
             node = parent;
           } else {
             if (sibling == null ? void 0 : sibling.left)
-              sibling.left.color = 0 /* BLACK */;
+              sibling.left.color = "BLACK";
             if (sibling)
               sibling.color = parent.color;
-            parent.color = 0 /* BLACK */;
+            parent.color = "BLACK";
             this._rightRotate(parent);
             node = this.root;
           }
         } else {
           let sibling = parent.left;
-          if ((sibling == null ? void 0 : sibling.color) === 1 /* RED */) {
-            sibling.color = 0 /* BLACK */;
+          if ((sibling == null ? void 0 : sibling.color) === "RED") {
+            sibling.color = "BLACK";
             if (parent)
-              parent.color = 1 /* RED */;
+              parent.color = "RED";
             this._rightRotate(parent);
             if (parent)
               sibling = parent.left;
           }
-          if (((_d = (_c = sibling == null ? void 0 : sibling.right) == null ? void 0 : _c.color) != null ? _d : 0 /* BLACK */) === 0 /* BLACK */) {
+          if (((_d = (_c = sibling == null ? void 0 : sibling.right) == null ? void 0 : _c.color) != null ? _d : "BLACK") === "BLACK") {
             if (sibling)
-              sibling.color = 1 /* RED */;
+              sibling.color = "RED";
             node = parent;
           } else {
             if (sibling == null ? void 0 : sibling.right)
-              sibling.right.color = 0 /* BLACK */;
+              sibling.right.color = "BLACK";
             if (sibling)
               sibling.color = parent.color;
             if (parent)
-              parent.color = 0 /* BLACK */;
+              parent.color = "BLACK";
             this._leftRotate(parent);
             node = this.root;
           }
         }
       }
       if (node) {
-        node.color = 0 /* BLACK */;
+        node.color = "BLACK";
       }
     }
     /**
@@ -11812,7 +11789,19 @@ var dataStructureTyped = (() => {
     get count() {
       return this._count;
     }
-    getMutableCount() {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    getComputedCount() {
       let sum = 0;
       this.dfs((node) => sum += node.count);
       return sum;
@@ -11958,9 +11947,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;
@@ -12020,11 +12009,11 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     perfectlyBalance(iterationType = this.iterationType) {
-      const sorted = this.dfs((node) => node, "in"), n = sorted.length;
+      const sorted = this.dfs((node) => node, "IN"), n = sorted.length;
       if (sorted.length < 1)
         return false;
       this.clear();
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const buildBalanceBST = (l, r) => {
           if (l > r)
             return;
@@ -12117,17 +12106,19 @@ var dataStructureTyped = (() => {
   // src/data-structures/binary-tree/tree-multi-map.ts
   var TreeMultiMapNode = class extends RedBlackTreeNode {
     /**
-     * The constructor function initializes an instance of a class with a key, value, and count.
-     * @param {K} key - The key parameter is of type K, which represents the type of the key for the
-     * constructor. It is required and must be provided when creating an instance of the class.
-     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
-     * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
-     * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
-     * 1.
-     */
-    constructor(key, value, count = 1) {
-      super(key, value);
+     * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
+     * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
+     * used to identify and locate the node within the tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
+     * creating a new node.
+     * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
+     * in the Red-Black Tree. It is an optional parameter with a default value of 1.
+     * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
+     * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
+     */
+    constructor(key, value, count = 1, color = "BLACK") {
+      super(key, value, color);
       __publicField(this, "_count", 1);
       this.count = count;
     }
@@ -12171,24 +12162,39 @@ var dataStructureTyped = (() => {
     get count() {
       return this._count;
     }
-    getMutableCount() {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    getComputedCount() {
       let sum = 0;
       this.dfs((node) => sum += node.count);
       return sum;
     }
     /**
-     * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
+     * The function creates a new TreeMultiMapNode with the specified key, value, color, and count.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
-     * which is a generic type that can be replaced with any specific type when using the function.
-     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the key in the node. It is of type `V`, which can be any data type.
-     * @param {number} [count] - The `count` parameter represents the number of occurrences of a
-     * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
-     * default to 1.
-     * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+     * which is a generic type representing the key type of the node.
+     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+     * node. It is an optional parameter, which means it can be omitted when calling the `createNode`
+     * function. If provided, it should be of type `V`.
+     * @param {RBTNColor} [color=BLACK] - The color parameter is used to specify the color of the node in
+     * a Red-Black Tree. It can have two possible values: 'RED' or 'BLACK'. The default value is 'BLACK'.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
+     * the tree. It is an optional parameter and is used to keep track of the number of values associated
+     * with a key in the tree.
+     * @returns A new instance of the TreeMultiMapNode class is being returned.
      */
-    createNode(key, value, count) {
-      return new TreeMultiMapNode(key, value, count);
+    createNode(key, value, color = "BLACK", count) {
+      return new TreeMultiMapNode(key, value, count, color);
     }
     /**
      * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
@@ -12225,10 +12231,10 @@ var dataStructureTyped = (() => {
         if (key === void 0 || key === null) {
           return;
         } else {
-          node = this.createNode(key, value2, count);
+          node = this.createNode(key, value2, "BLACK", count);
         }
       } else if (!this.isNode(keyOrNodeOrEntry)) {
-        node = this.createNode(keyOrNodeOrEntry, value, count);
+        node = this.createNode(keyOrNodeOrEntry, value, "BLACK", count);
       } else {
         return;
       }
@@ -12370,7 +12376,7 @@ var dataStructureTyped = (() => {
         }
       }
       this._size--;
-      if (originalColor === 0 /* BLACK */) {
+      if (originalColor === "BLACK") {
         this._deleteFixup(replacementNode);
       }
       results.push({ deleted: nodeToDelete, needBalanced: void 0 });
@@ -12407,11 +12413,11 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     perfectlyBalance(iterationType = this.iterationType) {
-      const sorted = this.dfs((node) => node, "in"), n = sorted.length;
+      const sorted = this.dfs((node) => node, "IN"), n = sorted.length;
       if (sorted.length < 1)
         return false;
       this.clear();
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+      if (iterationType === "RECURSIVE") {
         const buildBalanceBST = (l, r) => {
           if (l > r)
             return;
@@ -12473,7 +12479,7 @@ var dataStructureTyped = (() => {
       destNode = this.ensureNode(destNode);
       if (srcNode && destNode) {
         const { key, value, count, color } = destNode;
-        const tempNode = this.createNode(key, value, count);
+        const tempNode = this.createNode(key, value, color, count);
         if (tempNode) {
           tempNode.color = color;
           destNode.key = srcNode.key;