data-structure-typed 1.51.0 → 1.51.2

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

@@ -7740,7 +7740,8 @@ var dataStructureTyped = (() => {
       __publicField(this, "_extractor", (key) => typeof key === "number" ? key : Number(key));
       __publicField(this, "_root");
       __publicField(this, "_size");
-      __publicField(this, "_defaultOneParamCallback", (node) => node ? node.key : void 0);
+      __publicField(this, "_NIL", new BinaryTreeNode(NaN));
+      __publicField(this, "_DEFAULT_CALLBACK", (node) => node ? node.key : void 0);
       if (options) {
         const { iterationType, extractor } = options;
         if (iterationType)
@@ -7774,6 +7775,13 @@ var dataStructureTyped = (() => {
     get size() {
       return this._size;
     }
+    /**
+     * The function returns the value of the _NIL property.
+     * @returns The method is returning the value of the `_NIL` property.
+     */
+    get NIL() {
+      return this._NIL;
+    }
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {K} key - The key for the new node.
@@ -7844,21 +7852,29 @@ var dataStructureTyped = (() => {
      * itself if it is not a valid node key.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE") {
-      let res;
       if (this.isRealNode(keyOrNodeOrEntry)) {
-        res = keyOrNodeOrEntry;
+        return keyOrNodeOrEntry;
       } else if (this.isEntry(keyOrNodeOrEntry)) {
         if (keyOrNodeOrEntry[0] === null)
-          res = null;
-        else if (keyOrNodeOrEntry[0] !== void 0)
-          res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+          return null;
+        if (keyOrNodeOrEntry[0] === void 0)
+          return;
+        return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
       } else {
         if (keyOrNodeOrEntry === null)
-          res = null;
-        else if (keyOrNodeOrEntry !== void 0)
-          res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+          return null;
+        if (keyOrNodeOrEntry === void 0)
+          return;
+        return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
       }
-      return res;
+    }
+    /**
+     * The function checks if a given node is a real node or null.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNodeOrNull(node) {
+      return this.isRealNode(node) || node === null;
     }
     /**
      * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
@@ -7868,15 +7884,6 @@ var dataStructureTyped = (() => {
     isNode(keyOrNodeOrEntry) {
       return keyOrNodeOrEntry instanceof BinaryTreeNode;
     }
-    /**
-     * The function checks if a given value is an entry in a binary tree node.
-     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
-     * two type parameters V and NODE, representing the value and node type respectively.
-     * @returns a boolean value.
-     */
-    isEntry(keyOrNodeOrEntry) {
-      return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
-    }
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
@@ -7884,7 +7891,9 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     isRealNode(node) {
-      return node instanceof BinaryTreeNode && String(node.key) !== "NaN";
+      if (!this.isNode(node))
+        return false;
+      return node !== this.NIL;
     }
     /**
      * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
@@ -7892,15 +7901,16 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     isNIL(node) {
-      return node instanceof BinaryTreeNode && String(node.key) === "NaN";
+      return node === this.NIL;
     }
     /**
-     * The function checks if a given node is a real node or null.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * The function checks if a given value is an entry in a binary tree node.
+     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
+     * two type parameters V and NODE, representing the value and node type respectively.
      * @returns a boolean value.
      */
-    isNodeOrNull(node) {
-      return this.isRealNode(node) || node === null;
+    isEntry(keyOrNodeOrEntry) {
+      return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
     }
     /**
      * Time Complexity O(n)
@@ -8027,14 +8037,14 @@ var dataStructureTyped = (() => {
        * specific node based on its value or object.
        * @param {C} callback - The `callback` parameter is a function that is used to determine the
        * identifier of the node to be deleted. It is optional and has a default value of
-       * `this._defaultOneParamCallback`. The `callback` function should return the identifier of the node.
+       * `this._DEFAULT_CALLBACK`. The `callback` function should return the identifier of the node.
        * @returns an array of `BinaryTreeDeleteResult<NODE>`.
        */
-    delete(identifier, callback = this._defaultOneParamCallback) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK) {
       const deletedResult = [];
       if (!this.root)
         return deletedResult;
-      if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+      if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
       const curr = this.getNode(identifier, callback);
       if (!curr)
@@ -8089,7 +8099,7 @@ var dataStructureTyped = (() => {
      * specific value.
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
      * input and returns a value of type `C`. It is used to determine if a node matches the given
-     * identifier. If no callback is provided, the `_defaultOneParamCallback` function is used as the
+     * identifier. If no callback is provided, the `_DEFAULT_CALLBACK` function is used as the
      * default
      * @param [onlyOne=false] - A boolean value indicating whether to only return the first node that
      * matches the identifier. If set to true, the function will stop iterating once it finds a matching
@@ -8102,38 +8112,38 @@ var dataStructureTyped = (() => {
      * traverse the binary tree. It can have two possible values:
      * @returns an array of nodes of type `NODE`.
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
-      if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+    getNodes(identifier, callback = this._DEFAULT_CALLBACK, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+      if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
       if (iterationType === "RECURSIVE") {
-        const _traverse = (cur) => {
+        const dfs = (cur) => {
           if (callback(cur) === identifier) {
             ans.push(cur);
             if (onlyOne)
               return;
           }
-          if (!cur.left && !cur.right)
+          if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return;
-          cur.left && _traverse(cur.left);
-          cur.right && _traverse(cur.right);
+          this.isRealNode(cur.left) && dfs(cur.left);
+          this.isRealNode(cur.right) && dfs(cur.right);
         };
-        _traverse(beginRoot);
+        dfs(beginRoot);
       } else {
-        const queue = new Queue([beginRoot]);
-        while (queue.size > 0) {
-          const cur = queue.shift();
-          if (cur) {
+        const stack = [beginRoot];
+        while (stack.length > 0) {
+          const cur = stack.pop();
+          if (this.isRealNode(cur)) {
             if (callback(cur) === identifier) {
               ans.push(cur);
               if (onlyOne)
                 return ans;
             }
-            cur.left && queue.push(cur.left);
-            cur.right && queue.push(cur.right);
+            this.isRealNode(cur.left) && stack.push(cur.left);
+            this.isRealNode(cur.right) && stack.push(cur.right);
           }
         }
       }
@@ -8164,10 +8174,8 @@ var dataStructureTyped = (() => {
      * nodes are visited during the search.
      * @returns a value of type `NODE | null | undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
       var _a;
-      if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
-        callback = (node) => node;
       return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : null;
     }
     /**
@@ -8192,26 +8200,26 @@ var dataStructureTyped = (() => {
       if (!this.root)
         return void 0;
       if (iterationType === "RECURSIVE") {
-        const _dfs = (cur) => {
+        const dfs = (cur) => {
           if (cur.key === key)
             return cur;
           if (!cur.left && !cur.right)
             return;
           if (cur.left)
-            return _dfs(cur.left);
+            return dfs(cur.left);
           if (cur.right)
-            return _dfs(cur.right);
+            return dfs(cur.right);
         };
-        return _dfs(this.root);
+        return dfs(this.root);
       } else {
-        const queue = new Queue([this.root]);
-        while (queue.size > 0) {
-          const cur = queue.shift();
+        const stack = [this.root];
+        while (stack.length > 0) {
+          const cur = stack.pop();
           if (cur) {
             if (cur.key === key)
               return cur;
-            cur.left && queue.push(cur.left);
-            cur.right && queue.push(cur.right);
+            cur.left && stack.push(cur.left);
+            cur.right && stack.push(cur.right);
           }
         }
       }
@@ -8242,10 +8250,8 @@ var dataStructureTyped = (() => {
      * @returns The value of the node with the given identifier is being returned. If the node is not
      * found, `undefined` is returned.
      */
-    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    get(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
       var _a, _b;
-      if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
-        callback = (node) => node;
       return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) == null ? void 0 : _a.value) != null ? _b : void 0;
     }
     /**
@@ -8273,8 +8279,8 @@ var dataStructureTyped = (() => {
      * be performed in a pre-order, in-order, or post-order manner.
      * @returns a boolean value.
      */
-    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-      if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+    has(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
+      if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
       return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
@@ -8569,19 +8575,19 @@ var dataStructureTyped = (() => {
       if (!this.isRealNode(beginRoot))
         return beginRoot;
       if (iterationType === "RECURSIVE") {
-        const _traverse = (cur) => {
+        const dfs = (cur) => {
           if (!this.isRealNode(cur.left))
             return cur;
-          return _traverse(cur.left);
+          return dfs(cur.left);
         };
-        return _traverse(beginRoot);
+        return dfs(beginRoot);
       } else {
-        const _traverse = trampoline((cur) => {
+        const dfs = trampoline((cur) => {
           if (!this.isRealNode(cur.left))
             return cur;
-          return _traverse.cont(cur.left);
+          return dfs.cont(cur.left);
         });
-        return _traverse(beginRoot);
+        return dfs(beginRoot);
       }
     }
     /**
@@ -8610,19 +8616,19 @@ var dataStructureTyped = (() => {
       if (!beginRoot)
         return beginRoot;
       if (iterationType === "RECURSIVE") {
-        const _traverse = (cur) => {
+        const dfs = (cur) => {
           if (!this.isRealNode(cur.right))
             return cur;
-          return _traverse(cur.right);
+          return dfs(cur.right);
         };
-        return _traverse(beginRoot);
+        return dfs(beginRoot);
       } else {
-        const _traverse = trampoline((cur) => {
+        const dfs = trampoline((cur) => {
           if (!this.isRealNode(cur.right))
             return cur;
-          return _traverse.cont(cur.right);
+          return dfs.cont(cur.right);
         });
-        return _traverse(beginRoot);
+        return dfs(beginRoot);
       }
     }
     /**
@@ -8706,62 +8712,62 @@ var dataStructureTyped = (() => {
        * `false`, null or undefined
        * @returns an array of values that are the return values of the callback function.
        */
-    dfs(callback = this._defaultOneParamCallback, pattern = "IN", beginRoot = this.root, iterationType = "ITERATIVE", includeNull = false) {
+    dfs(callback = this._DEFAULT_CALLBACK, pattern = "IN", beginRoot = this.root, iterationType = "ITERATIVE", includeNull = false) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
       if (iterationType === "RECURSIVE") {
-        const _traverse = (node) => {
+        const dfs = (node) => {
           switch (pattern) {
             case "IN":
               if (includeNull) {
                 if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                  _traverse(node.left);
+                  dfs(node.left);
                 this.isNodeOrNull(node) && ans.push(callback(node));
                 if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                  _traverse(node.right);
+                  dfs(node.right);
               } else {
                 if (this.isRealNode(node) && this.isRealNode(node.left))
-                  _traverse(node.left);
+                  dfs(node.left);
                 this.isRealNode(node) && ans.push(callback(node));
                 if (this.isRealNode(node) && this.isRealNode(node.right))
-                  _traverse(node.right);
+                  dfs(node.right);
               }
               break;
             case "PRE":
               if (includeNull) {
                 this.isNodeOrNull(node) && ans.push(callback(node));
                 if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                  _traverse(node.left);
+                  dfs(node.left);
                 if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                  _traverse(node.right);
+                  dfs(node.right);
               } else {
                 this.isRealNode(node) && ans.push(callback(node));
                 if (this.isRealNode(node) && this.isRealNode(node.left))
-                  _traverse(node.left);
+                  dfs(node.left);
                 if (this.isRealNode(node) && this.isRealNode(node.right))
-                  _traverse(node.right);
+                  dfs(node.right);
               }
               break;
             case "POST":
               if (includeNull) {
                 if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                  _traverse(node.left);
+                  dfs(node.left);
                 if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                  _traverse(node.right);
+                  dfs(node.right);
                 this.isNodeOrNull(node) && ans.push(callback(node));
               } else {
                 if (this.isRealNode(node) && this.isRealNode(node.left))
-                  _traverse(node.left);
+                  dfs(node.left);
                 if (this.isRealNode(node) && this.isRealNode(node.right))
-                  _traverse(node.right);
+                  dfs(node.right);
                 this.isRealNode(node) && ans.push(callback(node));
               }
               break;
           }
         };
-        _traverse(beginRoot);
+        dfs(beginRoot);
       } else {
         const stack = [{ opt: 0, node: beginRoot }];
         while (stack.length > 0) {
@@ -8830,14 +8836,14 @@ var dataStructureTyped = (() => {
      * @returns an array of values that are the result of invoking the callback function on each node in
      * the breadth-first traversal of a binary tree.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    bfs(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
       if (iterationType === "RECURSIVE") {
         const queue = new Queue([beginRoot]);
-        const traverse = (level) => {
+        const dfs = (level) => {
           if (queue.size === 0)
             return;
           const current = queue.shift();
@@ -8853,9 +8859,9 @@ var dataStructureTyped = (() => {
             if (this.isRealNode(current.right))
               queue.push(current.right);
           }
-          traverse(level + 1);
+          dfs(level + 1);
         };
-        traverse(0);
+        dfs(0);
       } else {
         const queue = new Queue([beginRoot]);
         while (queue.size > 0) {
@@ -8904,7 +8910,7 @@ var dataStructureTyped = (() => {
      * be excluded
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    listLevels(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
       beginRoot = this.ensureNode(beginRoot);
       const levelsNodes = [];
       if (!beginRoot)
@@ -8973,7 +8979,7 @@ var dataStructureTyped = (() => {
      * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
-    morris(callback = this._defaultOneParamCallback, pattern = "IN", beginRoot = this.root) {
+    morris(callback = this._DEFAULT_CALLBACK, pattern = "IN", beginRoot = this.root) {
       beginRoot = this.ensureNode(beginRoot);
       if (beginRoot === null)
         return [];
@@ -9487,17 +9493,17 @@ var dataStructureTyped = (() => {
      * @returns either a node object (NODE) or undefined.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE") {
-      let res;
       if (this.isRealNode(keyOrNodeOrEntry)) {
-        res = keyOrNodeOrEntry;
+        return keyOrNodeOrEntry;
       } else if (this.isEntry(keyOrNodeOrEntry)) {
-        if (keyOrNodeOrEntry[0])
-          res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+        if (keyOrNodeOrEntry[0] === null || keyOrNodeOrEntry[0] === void 0)
+          return;
+        return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
       } else {
-        if (keyOrNodeOrEntry)
-          res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+        if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0)
+          return;
+        return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
       }
-      return res;
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
@@ -9672,30 +9678,30 @@ var dataStructureTyped = (() => {
      */
     getNodeByKey(key, iterationType = "ITERATIVE") {
       if (!this.isRealNode(this.root))
-        return void 0;
+        return;
       if (iterationType === "RECURSIVE") {
-        const _dfs = (cur) => {
+        const dfs = (cur) => {
           if (cur.key === key)
             return cur;
           if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return;
-          if (this._compare(cur.key, key) === "GT" && this.isRealNode(cur.left))
-            return _dfs(cur.left);
-          if (this._compare(cur.key, key) === "LT" && this.isRealNode(cur.right))
-            return _dfs(cur.right);
+          if (this.isRealNode(cur.left) && this._compare(cur.key, key) === "GT")
+            return dfs(cur.left);
+          if (this.isRealNode(cur.right) && this._compare(cur.key, key) === "LT")
+            return dfs(cur.right);
         };
-        return _dfs(this.root);
+        return dfs(this.root);
       } else {
-        const queue = new Queue([this.root]);
-        while (queue.size > 0) {
-          const cur = queue.shift();
+        const stack = [this.root];
+        while (stack.length > 0) {
+          const cur = stack.pop();
           if (this.isRealNode(cur)) {
             if (this._compare(cur.key, key) === "EQ")
               return cur;
-            if (this._compare(cur.key, key) === "GT")
-              this.isRealNode(cur.left) && queue.push(cur.left);
-            if (this._compare(cur.key, key) === "LT")
-              this.isRealNode(cur.right) && queue.push(cur.right);
+            if (this.isRealNode(cur.left) && this._compare(cur.key, key) === "GT")
+              stack.push(cur.left);
+            if (this.isRealNode(cur.right) && this._compare(cur.key, key) === "LT")
+              stack.push(cur.right);
           }
         }
       }
@@ -9728,13 +9734,13 @@ var dataStructureTyped = (() => {
        * performed on the binary tree. It can have two possible values:
        * @returns The method returns an array of nodes (`NODE[]`).
        */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this._DEFAULT_CALLBACK, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
       if (iterationType === "RECURSIVE") {
-        const _traverse = (cur) => {
+        const dfs = (cur) => {
           const callbackResult = callback(cur);
           if (callbackResult === identifier) {
             ans.push(cur);
@@ -9743,17 +9749,17 @@ var dataStructureTyped = (() => {
           }
           if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return;
-          if (callback === this._defaultOneParamCallback) {
+          if (callback === this._DEFAULT_CALLBACK) {
             if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === "GT")
-              _traverse(cur.left);
+              dfs(cur.left);
             if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === "LT")
-              _traverse(cur.right);
+              dfs(cur.right);
           } else {
-            this.isRealNode(cur.left) && _traverse(cur.left);
-            this.isRealNode(cur.right) && _traverse(cur.right);
+            this.isRealNode(cur.left) && dfs(cur.left);
+            this.isRealNode(cur.right) && dfs(cur.right);
           }
         };
-        _traverse(beginRoot);
+        dfs(beginRoot);
       } else {
         const stack = [beginRoot];
         while (stack.length > 0) {
@@ -9765,7 +9771,7 @@ var dataStructureTyped = (() => {
               if (onlyOne)
                 return ans;
             }
-            if (callback === this._defaultOneParamCallback) {
+            if (callback === this._DEFAULT_CALLBACK) {
               if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === "LT")
                 stack.push(cur.right);
               if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === "GT")
@@ -9779,6 +9785,35 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
+     * callback function.
+     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
+     * that you want to search for in the binary search tree. It can be of any type that is compatible
+     * with the type of nodes in the tree.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+     * the tree. It is used to determine whether a node matches the given identifier. The `callback`
+     * function should take a node as its parameter and return a value that can be compared to the
+     * `identifier` parameter.
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
+     * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
+     * using the `ensureNode` method. If it is not provided, the `root`
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed when searching for nodes in the binary search tree. It is an optional parameter and
+     * 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(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
+      var _a;
+      return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -9802,7 +9837,7 @@ var dataStructureTyped = (() => {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = "IN", beginRoot = this.root, iterationType = "ITERATIVE") {
+    dfs(callback = this._DEFAULT_CALLBACK, pattern = "IN", beginRoot = this.root, iterationType = "ITERATIVE") {
       return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
@@ -9826,7 +9861,7 @@ var dataStructureTyped = (() => {
      * nodes are visited.
      * @returns The method is returning an array of the return type of the callback function.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    bfs(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
       return super.bfs(callback, beginRoot, iterationType, false);
     }
     /**
@@ -9851,7 +9886,7 @@ var dataStructureTyped = (() => {
      * @returns The method is returning a two-dimensional array of the return type of the callback
      * function.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    listLevels(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
       return super.listLevels(callback, beginRoot, iterationType, false);
     }
     /**
@@ -9911,7 +9946,7 @@ var dataStructureTyped = (() => {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = "LT", targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._DEFAULT_CALLBACK, lesserOrGreater = "LT", targetNode = this.root, iterationType = this.iterationType) {
       targetNode = this.ensureNode(targetNode);
       const ans = [];
       if (!targetNode)
@@ -9920,16 +9955,16 @@ var dataStructureTyped = (() => {
         return ans;
       const targetKey = targetNode.key;
       if (iterationType === "RECURSIVE") {
-        const _traverse = (cur) => {
+        const dfs = (cur) => {
           const compared = this._compare(cur.key, targetKey);
           if (compared === lesserOrGreater)
             ans.push(callback(cur));
           if (this.isRealNode(cur.left))
-            _traverse(cur.left);
+            dfs(cur.left);
           if (this.isRealNode(cur.right))
-            _traverse(cur.right);
+            dfs(cur.right);
         };
-        _traverse(this.root);
+        dfs(this.root);
         return ans;
       } else {
         const queue = new Queue([this.root]);
@@ -10801,11 +10836,11 @@ var dataStructureTyped = (() => {
      * `callback` function.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
-     * default to the `_defaultOneParamCallback` function. The `callback` function should have a single
+     * default to the `_DEFAULT_CALLBACK` function. The `callback` function should have a single
      * parameter of type `NODE
      * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete(identifier, callback = this._defaultOneParamCallback) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK) {
       if (identifier instanceof AVLTreeNode)
         callback = (node) => node;
       const deletedResults = super.delete(identifier, callback);
@@ -11178,20 +11213,12 @@ var dataStructureTyped = (() => {
      */
     constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
-      __publicField(this, "_SENTINEL", new RedBlackTreeNode(NaN));
       __publicField(this, "_root");
-      this._root = this.SENTINEL;
+      this._root = this.NIL;
       if (keysOrNodesOrEntries) {
         this.addMany(keysOrNodesOrEntries);
       }
     }
-    /**
-     * The function returns the value of the _SENTINEL property.
-     * @returns The method is returning the value of the `_SENTINEL` property.
-     */
-    get SENTINEL() {
-      return this._SENTINEL;
-    }
     /**
      * The function returns the root node of a tree or undefined if there is no root.
      * @returns The root node of the tree structure, or undefined if there is no root node.
@@ -11276,53 +11303,6 @@ var dataStructureTyped = (() => {
     isNode(keyOrNodeOrEntry) {
       return keyOrNodeOrEntry instanceof RedBlackTreeNode;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function checks if a given node is a real node in a Red-Black Tree.
-     * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
-     * it can either be of type `NODE` or `undefined`.
-     * @returns a boolean value.
-     */
-    isRealNode(node) {
-      if (node === this.SENTINEL || node === void 0)
-        return false;
-      return node instanceof RedBlackTreeNode;
-    }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
-     * callback function.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
-     * that you want to search for in the binary search tree. It can be of any type that is compatible
-     * with the type of nodes in the tree.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It is used to determine whether a node matches the given identifier. The `callback`
-     * function should take a node as its parameter and return a value that can be compared to the
-     * `identifier` parameter.
-     * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
-     * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
-     * using the `ensureNode` method. If it is not provided, the `root`
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed when searching for nodes in the binary search tree. It is an optional parameter and
-     * 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(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-      var _a;
-      return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -11336,7 +11316,7 @@ var dataStructureTyped = (() => {
      */
     clear() {
       super.clear();
-      this._root = this.SENTINEL;
+      this._root = this.NIL;
     }
     /**
      * Time Complexity: O(log n)
@@ -11387,11 +11367,11 @@ var dataStructureTyped = (() => {
      * deleted is not found.
      * @param {C} callback - The `callback` parameter is a function that is used to retrieve a node from
      * the binary tree based on its identifier. It is an optional parameter and if not provided, the
-     * `_defaultOneParamCallback` function is used as the default callback. The callback function should
+     * `_DEFAULT_CALLBACK` function is used as the default callback. The callback function should
      * return the identifier of the node to
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */
-    delete(identifier, callback = this._defaultOneParamCallback) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK) {
       if (identifier === null)
         return [];
       const results = [];
@@ -11491,9 +11471,9 @@ var dataStructureTyped = (() => {
       while (this.isRealNode(current)) {
         parent = current;
         if (node.key < current.key) {
-          current = (_a = current.left) != null ? _a : this.SENTINEL;
+          current = (_a = current.left) != null ? _a : this.NIL;
         } else if (node.key > current.key) {
-          current = (_b = current.right) != null ? _b : this.SENTINEL;
+          current = (_b = current.right) != null ? _b : this.NIL;
         } else {
           this._replaceNode(current, node);
           return "UPDATED";
@@ -11507,8 +11487,8 @@ var dataStructureTyped = (() => {
       } else {
         parent.right = node;
       }
-      node.left = this.SENTINEL;
-      node.right = this.SENTINEL;
+      node.left = this.NIL;
+      node.right = this.NIL;
       node.color = "RED";
       this._insertFixup(node);
       return "CREATED";
@@ -11927,7 +11907,7 @@ var dataStructureTyped = (() => {
      * decremented by 1 and
      * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK, ignoreCount = false) {
       var _a;
       const deletedResult = [];
       if (!this.root)
@@ -12295,7 +12275,7 @@ var dataStructureTyped = (() => {
      * function. It can also be null or undefined if no node needs to be deleted.
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
      * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
-     * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+     * identifier for deletion. If no callback is provided, the `_DEFAULT_CALLBACK` function is
      * used
      * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
      * node when performing deletion. If set to true, the count of the target node will not be considered
@@ -12303,7 +12283,7 @@ var dataStructureTyped = (() => {
      * target node will be decremented
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */
-    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK, ignoreCount = false) {
       if (identifier === null)
         return [];
       const results = [];