heap-typed 1.50.7 → 1.50.9

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,9 +192,7 @@ class RedBlackTree extends bst_1.BST {
      */
     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 ? _a : undefined;
+        return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
      * Time Complexity: O(1)
@@ -234,10 +231,10 @@ class RedBlackTree extends bst_1.BST {
         if (!this.isRealNode(newNode))
             return false;
         const insertStatus = this._insert(newNode);
-        if (insertStatus === types_1.CRUD.CREATED) {
+        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;
@@ -246,7 +243,7 @@ class RedBlackTree extends bst_1.BST {
             return true;
         }
         else
-            return insertStatus === types_1.CRUD.UPDATED;
+            return insertStatus === 'UPDATED';
     }
     /**
      * Time Complexity: O(log n)
@@ -313,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 });
@@ -379,7 +376,7 @@ class RedBlackTree extends bst_1.BST {
             }
             else {
                 this._replaceNode(current, node);
-                return types_1.CRUD.UPDATED;
+                return 'UPDATED';
             }
         }
         node.parent = parent;
@@ -394,9 +391,9 @@ 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 types_1.CRUD.CREATED;
+        return 'CREATED';
     }
     /**
      * Time Complexity: O(1)
@@ -440,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;
                 }
@@ -463,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);
                     }
                 }
@@ -473,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 {
@@ -485,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);
                     }
                 }
@@ -494,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)
@@ -513,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
@@ -527,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;
                 }
@@ -554,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;
                 }
@@ -583,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';
         }
     }
     /**

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

@@ -5,22 +5,24 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
-import { IterationType } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
+import { RBTNColor } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
 export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
     /**
-     * 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: K, value?: V, count?: number);
+     * 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: K, value?: V, count?: number, color?: RBTNColor);
     protected _count: number;
     /**
      * The function returns the value of the private variable _count.
@@ -51,19 +53,34 @@ export declare class TreeMultiMap<K = any, V = any, NODE extends TreeMultiMapNod
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count(): number;
-    getMutableCount(): number;
     /**
-     * The function creates a new TreeMultiMapNode object with the specified key, value, 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.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
-    createNode(key: K, value?: V, count?: number): NODE;
+    /**
+     * 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 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 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: K, value?: V, color?: RBTNColor, count?: number): NODE;
     /**
      * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
      * @param [options] - The `options` parameter is an optional object that contains additional

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

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeMultiMap = exports.TreeMultiMapNode = void 0;
-const types_1 = require("../../types");
 const rb_tree_1 = require("./rb-tree");
 class TreeMultiMapNode extends rb_tree_1.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.
+     * 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) {
-        super(key, value);
+    constructor(key, value, count = 1, color = 'BLACK') {
+        super(key, value, color);
         this._count = 1;
         this.count = count;
     }
@@ -60,24 +61,39 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
     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.
@@ -115,11 +131,11 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
                 return;
             }
             else {
-                node = this.createNode(key, value, count);
+                node = this.createNode(key, value, 'BLACK', count);
             }
         }
         else if (!this.isNode(keyOrNodeOrEntry)) {
-            node = this.createNode(keyOrNodeOrEntry, value, count);
+            node = this.createNode(keyOrNodeOrEntry, value, 'BLACK', count);
         }
         else {
             return;
@@ -271,7 +287,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
         }
         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 });
@@ -308,11 +324,11 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * @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 === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -375,7 +391,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
         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;

package/dist/data-structures/heap/heap.d.ts

@@ -159,7 +159,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * 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?: DFSOrderPattern): E[];

package/dist/data-structures/heap/heap.js

@@ -229,26 +229,26 @@ class Heap extends base_1.IterableElementBase {
      * 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 = [];
         // Auxiliary recursive function, traverses the binary heap according to the traversal order
         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]);

package/dist/types/common.d.ts

@@ -1,33 +1,15 @@
-export declare enum BSTVariant {
-    STANDARD = "STANDARD",
-    INVERSE = "INVERSE"
-}
-export declare enum CP {
-    lt = "lt",
-    eq = "eq",
-    gt = "gt"
-}
+export type BSTVariant = 'STANDARD' | 'INVERSE';
+export type CP = 'LT' | 'EQ' | 'GT';
 /**
  * Enum representing different loop types.
  *
  * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
  * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
  */
-export declare enum IterationType {
-    ITERATIVE = "ITERATIVE",
-    RECURSIVE = "RECURSIVE"
-}
-export declare enum FamilyPosition {
-    ROOT = "ROOT",
-    LEFT = "LEFT",
-    RIGHT = "RIGHT",
-    ROOT_LEFT = "ROOT_LEFT",
-    ROOT_RIGHT = "ROOT_RIGHT",
-    ISOLATED = "ISOLATED",
-    MAL_NODE = "MAL_NODE"
-}
+export type IterationType = 'ITERATIVE' | 'RECURSIVE';
+export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
 export type Comparator<K> = (a: K, b: K) => number;
-export type DFSOrderPattern = 'pre' | 'in' | 'post';
+export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 export type NodeDisplayLayout = [string[], number, number, number];
 export type BTNCallback<N, D = any> = (node: N) => D;
 export interface IterableWithSize<T> extends Iterable<T> {
@@ -52,9 +34,4 @@ export type BinaryTreeDeleteResult<N> = {
     deleted: N | null | undefined;
     needBalanced: N | null | undefined;
 };
-export declare enum CRUD {
-    CREATED = "CREATED",
-    READ = "READ",
-    UPDATED = "UPDATED",
-    DELETED = "DELETED"
-}
+export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';