priority-queue-typed 1.50.8 → 1.50.9

package/dist/data-structures/binary-tree/avl-tree-multi-map.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry } from '../../types';
+import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
@@ -45,7 +45,19 @@ export declare class AVLTreeMultiMap<K = any, V = any, NODE extends AVLTreeMulti
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count(): number;
-    getMutableCount(): number;
+    /**
+     * 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(): number;
     /**
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
@@ -156,7 +168,7 @@ export declare class AVLTreeMultiMap<K = any, V = any, NODE extends AVLTreeMulti
      * values:
      * @returns a boolean value.
      */
-    perfectlyBalance(iterationType?: import("../../types").IterationType): boolean;
+    perfectlyBalance(iterationType?: IterationType): boolean;
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)

package/dist/data-structures/binary-tree/avl-tree-multi-map.js

@@ -54,7 +54,19 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
     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;
@@ -270,7 +282,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * @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();

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -139,7 +139,7 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * @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: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: string): NODE | null | undefined;
+    ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
     /**
      * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,NODE>`.
@@ -248,7 +248,7 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * @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: K, iterationType?: string): NODE | undefined;
+    getNodeByKey(key: K, iterationType?: IterationType): NODE | undefined;
     get<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
     get<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
     get<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;

package/dist/data-structures/binary-tree/binary-tree.js

@@ -1110,7 +1110,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * `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', includeNull = false) {
+    dfs(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE', includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
@@ -1118,7 +1118,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         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);
@@ -1134,7 +1134,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                                 _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))
@@ -1150,7 +1150,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                                 _traverse(node.right);
                         }
                         break;
-                    case 'post':
+                    case 'POST':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
@@ -1190,17 +1190,17 @@ class BinaryTree extends base_1.IterableEntryBase {
                 }
                 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 });
@@ -1390,7 +1390,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * `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 [];
@@ -1417,7 +1417,7 @@ class BinaryTree extends base_1.IterableEntryBase {
             _reverseEdge(tail);
         };
         switch (pattern) {
-            case 'in':
+            case 'IN':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);
@@ -1434,7 +1434,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                     cur = cur.right;
                 }
                 break;
-            case 'pre':
+            case 'PRE':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);
@@ -1454,7 +1454,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                     cur = cur.right;
                 }
                 break;
-            case 'post':
+            case 'POST':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);

package/dist/data-structures/binary-tree/bst.d.ts

@@ -112,7 +112,7 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * type of iteration to be performed. It has a default value of `'ITERATIVE'`.
      * @returns either a node object (NODE) or undefined.
      */
-    ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: string): NODE | undefined;
+    ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | undefined;
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, NODE>`.
@@ -179,7 +179,7 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * @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: K, iterationType?: string): NODE | undefined;
+    getNodeByKey(key: K, iterationType?: IterationType): NODE | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
@@ -376,6 +376,23 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * than), 'LT' (less than), or 'EQ' (equal).
      */
     protected _compare(a: K, b: K): CP;
+    /**
+     * 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.
+     */
     protected _lt(a: K, b: K): boolean;
+    /**
+     * 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.
+     */
     protected _gt(a: K, b: K): boolean;
 }

package/dist/data-structures/binary-tree/bst.js

@@ -361,6 +361,7 @@ class BST extends binary_tree_1.BinaryTree {
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key, iterationType = 'ITERATIVE') {
+        // return this.getNodes(key, this._defaultOneParamCallback, true, this.root, iterationType)[0];
         if (!this.isRealNode(this.root))
             return undefined;
         if (iterationType === 'RECURSIVE') {
@@ -504,7 +505,7 @@ class BST extends binary_tree_1.BinaryTree {
      * 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') {
+    dfs(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE') {
         return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
@@ -670,7 +671,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @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;
@@ -798,6 +799,15 @@ class BST extends binary_tree_1.BinaryTree {
         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);
@@ -806,6 +816,14 @@ class BST extends binary_tree_1.BinaryTree {
         // return extractedA < extractedB;
         // return a < b;
     }
+    /**
+     * 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);

package/dist/data-structures/binary-tree/rb-tree.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
@@ -12,7 +12,7 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
      * 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: K, value?: V, color?: RBTNColor);
     protected _color: RBTNColor;
@@ -58,8 +58,8 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * @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.
      */
@@ -140,7 +140,7 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * its default value is taken from the `iterationType` property of the class.
      * @returns The method is returning a value of type `NODE | null | undefined`.
      */
-    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: BSTNKeyOrNode<K, NODE>, iterationType?: import("../../types").IterationType): NODE | null | undefined;
+    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: BSTNKeyOrNode<K, NODE>, iterationType?: IterationType): NODE | null | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/binary-tree/rb-tree.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedBlackTree = exports.RedBlackTreeNode = void 0;
-const types_1 = require("../../types");
 const bst_1 = require("./bst");
 class RedBlackTreeNode extends bst_1.BSTNode {
     /**
@@ -13,9 +12,9 @@ class RedBlackTreeNode extends bst_1.BSTNode {
      * 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 = types_1.RBTNColor.BLACK) {
+    constructor(key, value, color = 'BLACK') {
         super(key, value);
         this._color = color;
     }
@@ -75,12 +74,12 @@ class RedBlackTree extends bst_1.BST {
      * @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 = types_1.RBTNColor.BLACK) {
+    createNode(key, value, color = 'BLACK') {
         return new RedBlackTreeNode(key, value, color);
     }
     /**
@@ -121,11 +120,11 @@ class RedBlackTree extends bst_1.BST {
                 return;
             }
             else {
-                node = this.createNode(key, value, types_1.RBTNColor.RED);
+                node = this.createNode(key, value, 'RED');
             }
         }
         else if (!this.isNode(keyOrNodeOrEntry)) {
-            node = this.createNode(keyOrNodeOrEntry, value, types_1.RBTNColor.RED);
+            node = this.createNode(keyOrNodeOrEntry, value, 'RED');
         }
         else {
             return;
@@ -193,7 +192,6 @@ class RedBlackTree extends bst_1.BST {
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
-        // if ((identifier as any) instanceof RedBlackTreeNode) callback = (node => node) as C;
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
@@ -236,7 +234,7 @@ class RedBlackTree extends bst_1.BST {
         if (insertStatus === 'CREATED') {
             // Ensure the root is black
             if (this.isRealNode(this._root)) {
-                this._root.color = types_1.RBTNColor.BLACK;
+                this._root.color = 'BLACK';
             }
             else {
                 return false;
@@ -312,7 +310,7 @@ class RedBlackTree extends bst_1.BST {
         }
         this._size--;
         // If the original color was black, fix the tree
-        if (originalColor === types_1.RBTNColor.BLACK) {
+        if (originalColor === 'BLACK') {
             this._deleteFixup(replacementNode);
         }
         results.push({ deleted: nodeToDelete, needBalanced: undefined });
@@ -393,7 +391,7 @@ class RedBlackTree extends bst_1.BST {
         }
         node.left = this.SENTINEL;
         node.right = this.SENTINEL;
-        node.color = types_1.RBTNColor.RED;
+        node.color = 'RED';
         this._insertFixup(node);
         return 'CREATED';
     }
@@ -439,16 +437,16 @@ class RedBlackTree extends bst_1.BST {
     _insertFixup(z) {
         var _a, _b, _c, _d;
         // Continue fixing the tree as long as the parent of z is red
-        while (((_a = z === null || z === void 0 ? void 0 : z.parent) === null || _a === void 0 ? void 0 : _a.color) === types_1.RBTNColor.RED) {
+        while (((_a = z === null || z === void 0 ? void 0 : z.parent) === null || _a === void 0 ? void 0 : _a.color) === 'RED') {
             // Check if the parent of z is the left child of its parent
             if (z.parent === ((_b = z.parent.parent) === null || _b === void 0 ? void 0 : _b.left)) {
                 // Case 1: The uncle (y) of z is red
                 const y = z.parent.parent.right;
-                if ((y === null || y === void 0 ? void 0 : y.color) === types_1.RBTNColor.RED) {
+                if ((y === null || y === void 0 ? void 0 : y.color) === 'RED') {
                     // Set colors to restore properties of Red-Black Tree
-                    z.parent.color = types_1.RBTNColor.BLACK;
-                    y.color = types_1.RBTNColor.BLACK;
-                    z.parent.parent.color = types_1.RBTNColor.RED;
+                    z.parent.color = 'BLACK';
+                    y.color = 'BLACK';
+                    z.parent.parent.color = 'RED';
                     // Move up the tree to continue fixing
                     z = z.parent.parent;
                 }
@@ -462,8 +460,8 @@ class RedBlackTree extends bst_1.BST {
                     // Case 3: The uncle (y) of z is black, and z is a left child
                     // Adjust colors and perform a right rotation
                     if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-                        z.parent.color = types_1.RBTNColor.BLACK;
-                        z.parent.parent.color = types_1.RBTNColor.RED;
+                        z.parent.color = 'BLACK';
+                        z.parent.parent.color = 'RED';
                         this._rightRotate(z.parent.parent);
                     }
                 }
@@ -472,10 +470,10 @@ class RedBlackTree extends bst_1.BST {
                 // Symmetric case for the right child (left and right exchanged)
                 // Follow the same logic as above with left and right exchanged
                 const y = (_d = (_c = z === null || z === void 0 ? void 0 : z.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.left;
-                if ((y === null || y === void 0 ? void 0 : y.color) === types_1.RBTNColor.RED) {
-                    z.parent.color = types_1.RBTNColor.BLACK;
-                    y.color = types_1.RBTNColor.BLACK;
-                    z.parent.parent.color = types_1.RBTNColor.RED;
+                if ((y === null || y === void 0 ? void 0 : y.color) === 'RED') {
+                    z.parent.color = 'BLACK';
+                    y.color = 'BLACK';
+                    z.parent.parent.color = 'RED';
                     z = z.parent.parent;
                 }
                 else {
@@ -484,8 +482,8 @@ class RedBlackTree extends bst_1.BST {
                         this._rightRotate(z);
                     }
                     if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-                        z.parent.color = types_1.RBTNColor.BLACK;
-                        z.parent.parent.color = types_1.RBTNColor.RED;
+                        z.parent.color = 'BLACK';
+                        z.parent.parent.color = 'RED';
                         this._leftRotate(z.parent.parent);
                     }
                 }
@@ -493,7 +491,7 @@ class RedBlackTree extends bst_1.BST {
         }
         // Ensure that the root is black after fixing
         if (this.isRealNode(this._root))
-            this._root.color = types_1.RBTNColor.BLACK;
+            this._root.color = 'BLACK';
     }
     /**
      * Time Complexity: O(log n)
@@ -512,13 +510,13 @@ class RedBlackTree extends bst_1.BST {
     _deleteFixup(node) {
         var _a, _b, _c, _d;
         // Early exit condition
-        if (!node || node === this.root || node.color === types_1.RBTNColor.BLACK) {
+        if (!node || node === this.root || node.color === 'BLACK') {
             if (node) {
-                node.color = types_1.RBTNColor.BLACK; // Ensure the final node is black
+                node.color = 'BLACK'; // Ensure the final node is black
             }
             return;
         }
-        while (node && node !== this.root && node.color === types_1.RBTNColor.BLACK) {
+        while (node && node !== this.root && node.color === 'BLACK') {
             const parent = node.parent;
             if (!parent) {
                 break; // Ensure the loop terminates if there's an issue with the tree structure
@@ -526,25 +524,25 @@ class RedBlackTree extends bst_1.BST {
             if (node === parent.left) {
                 let sibling = parent.right;
                 // Cases 1 and 2: Sibling is red or both children of sibling are black
-                if ((sibling === null || sibling === void 0 ? void 0 : sibling.color) === types_1.RBTNColor.RED) {
-                    sibling.color = types_1.RBTNColor.BLACK;
-                    parent.color = types_1.RBTNColor.RED;
+                if ((sibling === null || sibling === void 0 ? void 0 : sibling.color) === 'RED') {
+                    sibling.color = 'BLACK';
+                    parent.color = 'RED';
                     this._leftRotate(parent);
                     sibling = parent.right;
                 }
                 // Case 3: Sibling's left child is black
-                if (((_b = (_a = sibling === null || sibling === void 0 ? void 0 : sibling.left) === null || _a === void 0 ? void 0 : _a.color) !== null && _b !== void 0 ? _b : types_1.RBTNColor.BLACK) === types_1.RBTNColor.BLACK) {
+                if (((_b = (_a = sibling === null || sibling === void 0 ? void 0 : sibling.left) === null || _a === void 0 ? void 0 : _a.color) !== null && _b !== void 0 ? _b : 'BLACK') === 'BLACK') {
                     if (sibling)
-                        sibling.color = types_1.RBTNColor.RED;
+                        sibling.color = 'RED';
                     node = parent;
                 }
                 else {
                     // Case 4: Adjust colors and perform a right rotation
                     if (sibling === null || sibling === void 0 ? void 0 : sibling.left)
-                        sibling.left.color = types_1.RBTNColor.BLACK;
+                        sibling.left.color = 'BLACK';
                     if (sibling)
                         sibling.color = parent.color;
-                    parent.color = types_1.RBTNColor.BLACK;
+                    parent.color = 'BLACK';
                     this._rightRotate(parent);
                     node = this.root;
                 }
@@ -553,28 +551,28 @@ class RedBlackTree extends bst_1.BST {
                 // Symmetric case for the right child (left and right exchanged)
                 let sibling = parent.left;
                 // Cases 1 and 2: Sibling is red or both children of sibling are black
-                if ((sibling === null || sibling === void 0 ? void 0 : sibling.color) === types_1.RBTNColor.RED) {
-                    sibling.color = types_1.RBTNColor.BLACK;
+                if ((sibling === null || sibling === void 0 ? void 0 : sibling.color) === 'RED') {
+                    sibling.color = 'BLACK';
                     if (parent)
-                        parent.color = types_1.RBTNColor.RED;
+                        parent.color = 'RED';
                     this._rightRotate(parent);
                     if (parent)
                         sibling = parent.left;
                 }
                 // Case 3: Sibling's left child is black
-                if (((_d = (_c = sibling === null || sibling === void 0 ? void 0 : sibling.right) === null || _c === void 0 ? void 0 : _c.color) !== null && _d !== void 0 ? _d : types_1.RBTNColor.BLACK) === types_1.RBTNColor.BLACK) {
+                if (((_d = (_c = sibling === null || sibling === void 0 ? void 0 : sibling.right) === null || _c === void 0 ? void 0 : _c.color) !== null && _d !== void 0 ? _d : 'BLACK') === 'BLACK') {
                     if (sibling)
-                        sibling.color = types_1.RBTNColor.RED;
+                        sibling.color = 'RED';
                     node = parent;
                 }
                 else {
                     // Case 4: Adjust colors and perform a left rotation
                     if (sibling === null || sibling === void 0 ? void 0 : sibling.right)
-                        sibling.right.color = types_1.RBTNColor.BLACK;
+                        sibling.right.color = 'BLACK';
                     if (sibling)
                         sibling.color = parent.color;
                     if (parent)
-                        parent.color = types_1.RBTNColor.BLACK;
+                        parent.color = 'BLACK';
                     this._leftRotate(parent);
                     node = this.root;
                 }
@@ -582,7 +580,7 @@ class RedBlackTree extends bst_1.BST {
         }
         // Ensure that the final node (possibly the root) is black
         if (node) {
-            node.color = types_1.RBTNColor.BLACK;
+            node.color = 'BLACK';
         }
     }
     /**