data-structure-typed 1.50.9 → 1.51.1

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

@@ -187,7 +187,7 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * 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.
      */

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

@@ -191,7 +191,7 @@ export class RedBlackTree extends BST {
      * 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) {
+    getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
     }
     /**
@@ -261,11 +261,11 @@ export class RedBlackTree extends BST {
      * 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 = [];

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

@@ -145,7 +145,7 @@ export declare class TreeMultiMap<K = any, V = any, NODE extends TreeMultiMapNod
      * 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

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

@@ -197,7 +197,7 @@ export class TreeMultiMap extends RedBlackTree {
      * 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
@@ -205,7 +205,7 @@ export class TreeMultiMap extends RedBlackTree {
      * 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 = [];

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

@@ -7740,7 +7740,7 @@ 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, "_DEFAULT_CALLBACK", (node) => node ? node.key : void 0);
       if (options) {
         const { iterationType, extractor } = options;
         if (iterationType)
@@ -7844,21 +7844,21 @@ 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 "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
@@ -8027,14 +8027,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 +8089,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,15 +8102,15 @@ 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)
@@ -8118,22 +8118,22 @@ var dataStructureTyped = (() => {
           }
           if (!cur.left && !cur.right)
             return;
-          cur.left && _traverse(cur.left);
-          cur.right && _traverse(cur.right);
+          cur.left && dfs(cur.left);
+          cur.right && dfs(cur.right);
         };
-        _traverse(beginRoot);
+        dfs(beginRoot);
       } else {
-        const queue = new Queue([beginRoot]);
-        while (queue.size > 0) {
-          const cur = queue.shift();
+        const stack = [beginRoot];
+        while (stack.length > 0) {
+          const cur = stack.pop();
           if (cur) {
             if (callback(cur) === identifier) {
               ans.push(cur);
               if (onlyOne)
                 return ans;
             }
-            cur.left && queue.push(cur.left);
-            cur.right && queue.push(cur.right);
+            cur.left && stack.push(cur.left);
+            cur.right && stack.push(cur.right);
           }
         }
       }
@@ -8164,9 +8164,9 @@ 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)
+      if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
       return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : null;
     }
@@ -8192,26 +8192,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,9 +8242,9 @@ 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)
+      if ((!callback || callback === this._DEFAULT_CALLBACK) && 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 +8273,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 +8569,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 +8610,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 +8706,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 +8830,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 +8853,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 +8904,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 +8973,7 @@ var dataStructureTyped = (() => {
      * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
-    morris(callback = this._defaultOneParamCallback, pattern = "IN", beginRoot = this.root) {
+    morris(callback = this._DEFAULT_CALLBACK, pattern = "IN", beginRoot = this.root) {
       beginRoot = this.ensureNode(beginRoot);
       if (beginRoot === null)
         return [];
@@ -9487,17 +9487,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 +9672,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 +9728,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 +9743,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 +9765,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")
@@ -9802,7 +9802,7 @@ var dataStructureTyped = (() => {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = "IN", beginRoot = this.root, iterationType = "ITERATIVE") {
+    dfs(callback = this._DEFAULT_CALLBACK, pattern = "IN", beginRoot = this.root, iterationType = "ITERATIVE") {
       return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
@@ -9826,7 +9826,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 +9851,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 +9911,7 @@ var dataStructureTyped = (() => {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = "LT", 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 +9920,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 +10801,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);
@@ -11319,7 +11319,7 @@ var dataStructureTyped = (() => {
      * 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) {
+    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;
     }
@@ -11387,11 +11387,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 = [];
@@ -11927,7 +11927,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 +12295,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 +12303,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 = [];