data-structure-typed 1.50.8 → 1.50.9

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

@@ -1,9 +1,6 @@
 import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
 import type { BSTOptions } from "./bst";
-export declare enum RBTNColor {
-    RED = 1,
-    BLACK = 0
-}
+export type RBTNColor = 'RED' | 'BLACK';
 export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RedBlackTreeNested<K, V, N extends RedBlackTreeNode<K, V, N>> = RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RBTreeOptions<K> = Omit<BSTOptions<K>, 'variant'> & {};

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

@@ -1,9 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBTNColor = void 0;
-var RBTNColor;
-(function (RBTNColor) {
-    RBTNColor[RBTNColor["RED"] = 1] = "RED";
-    RBTNColor[RBTNColor["BLACK"] = 0] = "BLACK";
-})(RBTNColor || (exports.RBTNColor = RBTNColor = {}));
 //# sourceMappingURL=rb-tree.js.map

package/dist/cjs/types/data-structures/binary-tree/rb-tree.js.map

@@ -1 +1 @@
-{"version":3,"file":"rb-tree.js","sourceRoot":"","sources":["../../../../../src/types/data-structures/binary-tree/rb-tree.ts"],"names":[],"mappings":";;;AAGA,IAAY,SAA+B;AAA3C,WAAY,SAAS;IAAG,uCAAO,CAAA;IAAE,2CAAS,CAAA;AAAA,CAAC,EAA/B,SAAS,yBAAT,SAAS,QAAsB"}
+{"version":3,"file":"rb-tree.js","sourceRoot":"","sources":["../../../../../src/types/data-structures/binary-tree/rb-tree.ts"],"names":[],"mappings":""}

package/dist/mjs/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/mjs/data-structures/binary-tree/avl-tree-multi-map.js

@@ -50,7 +50,19 @@ export class AVLTreeMultiMap extends 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;
@@ -269,7 +281,7 @@ export class AVLTreeMultiMap extends 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/mjs/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/mjs/data-structures/binary-tree/binary-tree.js

@@ -1109,7 +1109,7 @@ export class BinaryTree extends 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 [];
@@ -1117,7 +1117,7 @@ export class BinaryTree extends 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);
@@ -1133,7 +1133,7 @@ export class BinaryTree extends 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))
@@ -1149,7 +1149,7 @@ export class BinaryTree extends IterableEntryBase {
                                 _traverse(node.right);
                         }
                         break;
-                    case 'post':
+                    case 'POST':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
@@ -1189,17 +1189,17 @@ export class BinaryTree extends 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 });
@@ -1389,7 +1389,7 @@ export class BinaryTree extends 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 [];
@@ -1416,7 +1416,7 @@ export class BinaryTree extends IterableEntryBase {
             _reverseEdge(tail);
         };
         switch (pattern) {
-            case 'in':
+            case 'IN':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);
@@ -1433,7 +1433,7 @@ export class BinaryTree extends IterableEntryBase {
                     cur = cur.right;
                 }
                 break;
-            case 'pre':
+            case 'PRE':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);
@@ -1453,7 +1453,7 @@ export class BinaryTree extends IterableEntryBase {
                     cur = cur.right;
                 }
                 break;
-            case 'post':
+            case 'POST':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);

package/dist/mjs/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/mjs/data-structures/binary-tree/bst.js

@@ -365,6 +365,7 @@ export class BST extends 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') {
@@ -508,7 +509,7 @@ export class BST extends 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);
     }
     /**
@@ -674,7 +675,7 @@ export class BST extends 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;
@@ -801,6 +802,15 @@ export class BST extends 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);
@@ -809,6 +819,14 @@ export class BST extends 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/mjs/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/mjs/data-structures/binary-tree/rb-tree.js

@@ -1,4 +1,3 @@
-import { RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 export class RedBlackTreeNode extends BSTNode {
     /**
@@ -10,9 +9,9 @@ export class RedBlackTreeNode extends 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 = RBTNColor.BLACK) {
+    constructor(key, value, color = 'BLACK') {
         super(key, value);
         this._color = color;
     }
@@ -73,12 +72,12 @@ export class RedBlackTree extends 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 = RBTNColor.BLACK) {
+    createNode(key, value, color = 'BLACK') {
         return new RedBlackTreeNode(key, value, color);
     }
     /**
@@ -122,11 +121,11 @@ export class RedBlackTree extends BST {
                 return;
             }
             else {
-                node = this.createNode(key, value, RBTNColor.RED);
+                node = this.createNode(key, value, 'RED');
             }
         }
         else if (!this.isNode(keyOrNodeOrEntry)) {
-            node = this.createNode(keyOrNodeOrEntry, value, RBTNColor.RED);
+            node = this.createNode(keyOrNodeOrEntry, value, 'RED');
         }
         else {
             return;
@@ -193,7 +192,6 @@ export class RedBlackTree extends BST {
      * @returns The method is returning a value of type `NODE | null | undefined`.
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-        // if ((identifier as any) instanceof RedBlackTreeNode) callback = (node => node) as C;
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
     }
     /**
@@ -236,7 +234,7 @@ export class RedBlackTree extends BST {
         if (insertStatus === 'CREATED') {
             // Ensure the root is black
             if (this.isRealNode(this._root)) {
-                this._root.color = RBTNColor.BLACK;
+                this._root.color = 'BLACK';
             }
             else {
                 return false;
@@ -312,7 +310,7 @@ export class RedBlackTree extends BST {
         }
         this._size--;
         // If the original color was black, fix the tree
-        if (originalColor === RBTNColor.BLACK) {
+        if (originalColor === 'BLACK') {
             this._deleteFixup(replacementNode);
         }
         results.push({ deleted: nodeToDelete, needBalanced: undefined });
@@ -392,7 +390,7 @@ export class RedBlackTree extends BST {
         }
         node.left = this.SENTINEL;
         node.right = this.SENTINEL;
-        node.color = RBTNColor.RED;
+        node.color = 'RED';
         this._insertFixup(node);
         return 'CREATED';
     }
@@ -437,16 +435,16 @@ export class RedBlackTree extends BST {
      */
     _insertFixup(z) {
         // Continue fixing the tree as long as the parent of z is red
-        while (z?.parent?.color === RBTNColor.RED) {
+        while (z?.parent?.color === 'RED') {
             // Check if the parent of z is the left child of its parent
             if (z.parent === z.parent.parent?.left) {
                 // Case 1: The uncle (y) of z is red
                 const y = z.parent.parent.right;
-                if (y?.color === RBTNColor.RED) {
+                if (y?.color === 'RED') {
                     // Set colors to restore properties of Red-Black Tree
-                    z.parent.color = RBTNColor.BLACK;
-                    y.color = RBTNColor.BLACK;
-                    z.parent.parent.color = 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;
                 }
@@ -460,8 +458,8 @@ export class RedBlackTree extends 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 = RBTNColor.BLACK;
-                        z.parent.parent.color = RBTNColor.RED;
+                        z.parent.color = 'BLACK';
+                        z.parent.parent.color = 'RED';
                         this._rightRotate(z.parent.parent);
                     }
                 }
@@ -470,10 +468,10 @@ export class RedBlackTree extends BST {
                 // Symmetric case for the right child (left and right exchanged)
                 // Follow the same logic as above with left and right exchanged
                 const y = z?.parent?.parent?.left;
-                if (y?.color === RBTNColor.RED) {
-                    z.parent.color = RBTNColor.BLACK;
-                    y.color = RBTNColor.BLACK;
-                    z.parent.parent.color = RBTNColor.RED;
+                if (y?.color === 'RED') {
+                    z.parent.color = 'BLACK';
+                    y.color = 'BLACK';
+                    z.parent.parent.color = 'RED';
                     z = z.parent.parent;
                 }
                 else {
@@ -482,8 +480,8 @@ export class RedBlackTree extends BST {
                         this._rightRotate(z);
                     }
                     if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-                        z.parent.color = RBTNColor.BLACK;
-                        z.parent.parent.color = RBTNColor.RED;
+                        z.parent.color = 'BLACK';
+                        z.parent.parent.color = 'RED';
                         this._leftRotate(z.parent.parent);
                     }
                 }
@@ -491,7 +489,7 @@ export class RedBlackTree extends BST {
         }
         // Ensure that the root is black after fixing
         if (this.isRealNode(this._root))
-            this._root.color = RBTNColor.BLACK;
+            this._root.color = 'BLACK';
     }
     /**
      * Time Complexity: O(log n)
@@ -509,13 +507,13 @@ export class RedBlackTree extends BST {
      */
     _deleteFixup(node) {
         // Early exit condition
-        if (!node || node === this.root || node.color === RBTNColor.BLACK) {
+        if (!node || node === this.root || node.color === 'BLACK') {
             if (node) {
-                node.color = 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 === 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
@@ -523,25 +521,25 @@ export class RedBlackTree extends 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?.color === RBTNColor.RED) {
-                    sibling.color = RBTNColor.BLACK;
-                    parent.color = RBTNColor.RED;
+                if (sibling?.color === 'RED') {
+                    sibling.color = 'BLACK';
+                    parent.color = 'RED';
                     this._leftRotate(parent);
                     sibling = parent.right;
                 }
                 // Case 3: Sibling's left child is black
-                if ((sibling?.left?.color ?? RBTNColor.BLACK) === RBTNColor.BLACK) {
+                if ((sibling?.left?.color ?? 'BLACK') === 'BLACK') {
                     if (sibling)
-                        sibling.color = RBTNColor.RED;
+                        sibling.color = 'RED';
                     node = parent;
                 }
                 else {
                     // Case 4: Adjust colors and perform a right rotation
                     if (sibling?.left)
-                        sibling.left.color = RBTNColor.BLACK;
+                        sibling.left.color = 'BLACK';
                     if (sibling)
                         sibling.color = parent.color;
-                    parent.color = RBTNColor.BLACK;
+                    parent.color = 'BLACK';
                     this._rightRotate(parent);
                     node = this.root;
                 }
@@ -550,28 +548,28 @@ export class RedBlackTree extends 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?.color === RBTNColor.RED) {
-                    sibling.color = RBTNColor.BLACK;
+                if (sibling?.color === 'RED') {
+                    sibling.color = 'BLACK';
                     if (parent)
-                        parent.color = RBTNColor.RED;
+                        parent.color = 'RED';
                     this._rightRotate(parent);
                     if (parent)
                         sibling = parent.left;
                 }
                 // Case 3: Sibling's left child is black
-                if ((sibling?.right?.color ?? RBTNColor.BLACK) === RBTNColor.BLACK) {
+                if ((sibling?.right?.color ?? 'BLACK') === 'BLACK') {
                     if (sibling)
-                        sibling.color = RBTNColor.RED;
+                        sibling.color = 'RED';
                     node = parent;
                 }
                 else {
                     // Case 4: Adjust colors and perform a left rotation
                     if (sibling?.right)
-                        sibling.right.color = RBTNColor.BLACK;
+                        sibling.right.color = 'BLACK';
                     if (sibling)
                         sibling.color = parent.color;
                     if (parent)
-                        parent.color = RBTNColor.BLACK;
+                        parent.color = 'BLACK';
                     this._leftRotate(parent);
                     node = this.root;
                 }
@@ -579,7 +577,7 @@ export class RedBlackTree extends BST {
         }
         // Ensure that the final node (possibly the root) is black
         if (node) {
-            node.color = RBTNColor.BLACK;
+            node.color = 'BLACK';
         }
     }
     /**