data-structure-typed 1.51.6 → 1.51.8

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

@@ -160,6 +160,7 @@ var dataStructureTyped = (() => {
     arrayRemove: () => arrayRemove,
     calcMinUnitsRequired: () => calcMinUnitsRequired,
     getMSB: () => getMSB,
+    isComparable: () => isComparable,
     isThunk: () => isThunk,
     isWeakKey: () => isWeakKey,
     rangeCheck: () => rangeCheck,
@@ -711,6 +712,33 @@ var dataStructureTyped = (() => {
     const multiplier = Math.pow(10, digit);
     return Math.round(num * multiplier) / multiplier;
   };
+  function isComparable(key) {
+    const keyType = typeof key;
+    if (keyType === "number")
+      return isNaN(key);
+    if (keyType === "string")
+      return true;
+    if (keyType === "bigint")
+      return true;
+    if (keyType === "boolean")
+      return true;
+    if (keyType === "symbol")
+      return false;
+    if (keyType === "undefined")
+      return false;
+    if (keyType === "function")
+      return isComparable(key());
+    if (keyType === "object") {
+      if (key === null)
+        return true;
+      if (typeof key.valueOf === "function")
+        return isComparable(key.valueOf());
+      if (typeof key.toString === "function")
+        return isComparable(key.toString());
+      return false;
+    }
+    return false;
+  }
 
   // src/utils/number.ts
   function toBinaryString(num, digit = 32) {
@@ -7745,29 +7773,19 @@ var dataStructureTyped = (() => {
     constructor(keysOrNodesOrEntries = [], options) {
       super();
       __publicField(this, "iterationType", "ITERATIVE");
-      __publicField(this, "_extractor", (key) => typeof key === "number" ? key : Number(key));
       __publicField(this, "_root");
       __publicField(this, "_size");
       __publicField(this, "_NIL", new BinaryTreeNode(NaN));
       __publicField(this, "_DEFAULT_CALLBACK", (node) => node ? node.key : void 0);
       if (options) {
-        const { iterationType, extractor } = options;
+        const { iterationType } = options;
         if (iterationType)
           this.iterationType = iterationType;
-        if (extractor)
-          this._extractor = extractor;
       }
       this._size = 0;
       if (keysOrNodesOrEntries)
         this.addMany(keysOrNodesOrEntries);
     }
-    /**
-     * The function returns the value of the `_extractor` property.
-     * @returns The `_extractor` property is being returned.
-     */
-    get extractor() {
-      return this._extractor;
-    }
     /**
      * The function returns the root node, which can be of type NODE, null, or undefined.
      * @returns The method is returning the value of the `_root` property, which can be of type `NODE`,
@@ -7860,21 +7878,24 @@ var dataStructureTyped = (() => {
      * itself if it is not a valid node key.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE") {
+      if (keyOrNodeOrEntry === this.NIL)
+        return;
       if (this.isRealNode(keyOrNodeOrEntry)) {
         return keyOrNodeOrEntry;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        if (keyOrNodeOrEntry[0] === null)
-          return null;
-        if (keyOrNodeOrEntry[0] === void 0)
-          return;
-        return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
-      } else {
-        if (keyOrNodeOrEntry === null)
+      }
+      if (this.isEntry(keyOrNodeOrEntry)) {
+        const key = keyOrNodeOrEntry[0];
+        if (key === null)
           return null;
-        if (keyOrNodeOrEntry === void 0)
+        if (key === void 0)
           return;
-        return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+        return this.getNodeByKey(key, iterationType);
       }
+      if (keyOrNodeOrEntry === null)
+        return null;
+      if (keyOrNodeOrEntry === void 0)
+        return;
+      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
     /**
      * The function checks if a given node is a real node or null.
@@ -8052,8 +8073,7 @@ var dataStructureTyped = (() => {
       const deletedResult = [];
       if (!this.root)
         return deletedResult;
-      if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
-        callback = (node) => node;
+      callback = this._ensureCallback(identifier, callback);
       const curr = this.getNode(identifier, callback);
       if (!curr)
         return deletedResult;
@@ -8121,11 +8141,10 @@ var dataStructureTyped = (() => {
      * @returns an array of nodes of type `NODE`.
      */
     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 [];
+      callback = this._ensureCallback(identifier, callback);
       const ans = [];
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
@@ -8205,32 +8224,7 @@ var dataStructureTyped = (() => {
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key, iterationType = "ITERATIVE") {
-      if (!this.root)
-        return void 0;
-      if (iterationType === "RECURSIVE") {
-        const dfs = (cur) => {
-          if (cur.key === key)
-            return cur;
-          if (!cur.left && !cur.right)
-            return;
-          if (cur.left)
-            return dfs(cur.left);
-          if (cur.right)
-            return dfs(cur.right);
-        };
-        return dfs(this.root);
-      } else {
-        const stack = [this.root];
-        while (stack.length > 0) {
-          const cur = stack.pop();
-          if (cur) {
-            if (cur.key === key)
-              return cur;
-            cur.left && stack.push(cur.left);
-            cur.right && stack.push(cur.right);
-          }
-        }
-      }
+      return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
     }
     /**
      * Time Complexity: O(n)
@@ -8259,8 +8253,8 @@ var dataStructureTyped = (() => {
      * found, `undefined` is returned.
      */
     get(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
-      var _a, _b;
-      return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) == null ? void 0 : _a.value) != null ? _b : void 0;
+      var _a;
+      return (_a = this.getNode(identifier, callback, beginRoot, iterationType)) == null ? void 0 : _a.value;
     }
     /**
      * Time Complexity: O(n)
@@ -8288,8 +8282,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     has(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
-      if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
-        callback = (node) => node;
+      callback = this._ensureCallback(identifier, callback);
       return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
     /**
@@ -8362,7 +8355,7 @@ var dataStructureTyped = (() => {
         const dfs = (cur, min, max) => {
           if (!this.isRealNode(cur))
             return true;
-          const numKey = this.extractor(cur.key);
+          const numKey = Number(cur.key);
           if (numKey <= min || numKey >= max)
             return false;
           return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
@@ -8381,7 +8374,7 @@ var dataStructureTyped = (() => {
               curr = curr.left;
             }
             curr = stack.pop();
-            const numKey = this.extractor(curr.key);
+            const numKey = Number(curr.key);
             if (!this.isRealNode(curr) || !checkMax && prev >= numKey || checkMax && prev <= numKey)
               return false;
             prev = numKey;
@@ -8411,15 +8404,15 @@ var dataStructureTyped = (() => {
      * @returns the depth of the `dist` relative to the `beginRoot`.
      */
     getDepth(dist, beginRoot = this.root) {
-      dist = this.ensureNode(dist);
-      beginRoot = this.ensureNode(beginRoot);
+      let distEnsured = this.ensureNode(dist);
+      const beginRootEnsured = this.ensureNode(beginRoot);
       let depth = 0;
-      while (dist == null ? void 0 : dist.parent) {
-        if (dist === beginRoot) {
+      while (distEnsured == null ? void 0 : distEnsured.parent) {
+        if (distEnsured === beginRootEnsured) {
           return depth;
         }
         depth++;
-        dist = dist.parent;
+        distEnsured = distEnsured.parent;
       }
       return depth;
     }
@@ -8548,14 +8541,14 @@ var dataStructureTyped = (() => {
        */
     getPathToRoot(beginNode, isReverse = true) {
       const result = [];
-      beginNode = this.ensureNode(beginNode);
-      if (!beginNode)
+      let beginNodeEnsured = this.ensureNode(beginNode);
+      if (!beginNodeEnsured)
         return result;
-      while (beginNode.parent) {
-        result.push(beginNode);
-        beginNode = beginNode.parent;
+      while (beginNodeEnsured.parent) {
+        result.push(beginNodeEnsured);
+        beginNodeEnsured = beginNodeEnsured.parent;
       }
-      result.push(beginNode);
+      result.push(beginNodeEnsured);
       return isReverse ? result.reverse() : result;
     }
     /**
@@ -9183,10 +9176,10 @@ var dataStructureTyped = (() => {
         console.log(`U for undefined
       `);
       if (opts.isShowNull)
-        console.log(`NODE for null
+        console.log(`N for null
       `);
       if (opts.isShowRedBlackNIL)
-        console.log(`S for Sentinel Node
+        console.log(`S for Sentinel Node(NIL)
       `);
       const display = (root) => {
         const [lines, , ,] = this._displayAux(root, opts);
@@ -9212,22 +9205,22 @@ var dataStructureTyped = (() => {
         const stack = [];
         let current = node;
         while (current || stack.length > 0) {
-          while (current && !isNaN(this.extractor(current.key))) {
+          while (this.isRealNode(current)) {
             stack.push(current);
             current = current.left;
           }
           current = stack.pop();
-          if (current && !isNaN(this.extractor(current.key))) {
+          if (this.isRealNode(current)) {
             yield [current.key, current.value];
             current = current.right;
           }
         }
       } else {
-        if (node.left && !isNaN(this.extractor(node.key))) {
+        if (node.left && this.isRealNode(node)) {
           yield* __yieldStar(this[Symbol.iterator](node.left));
         }
         yield [node.key, node.value];
-        if (node.right && !isNaN(this.extractor(node.key))) {
+        if (node.right && this.isRealNode(node)) {
           yield* __yieldStar(this[Symbol.iterator](node.right));
         }
       }
@@ -9253,10 +9246,10 @@ var dataStructureTyped = (() => {
         return emptyDisplayLayout;
       } else if (node === void 0 && !isShowUndefined) {
         return emptyDisplayLayout;
-      } else if (node !== null && node !== void 0 && isNaN(this.extractor(node.key)) && !isShowRedBlackNIL) {
+      } else if (this.isNIL(node) && !isShowRedBlackNIL) {
         return emptyDisplayLayout;
       } else if (node !== null && node !== void 0) {
-        const key = node.key, line = isNaN(this.extractor(key)) ? "S" : this.extractor(key).toString(), width = line.length;
+        const key = node.key, line = this.isNIL(node) ? "S" : key.toString(), width = line.length;
         return _buildNodeDisplay(
           line,
           width,
@@ -9344,6 +9337,12 @@ var dataStructureTyped = (() => {
       }
       this._root = v;
     }
+    _ensureCallback(identifier, callback = this._DEFAULT_CALLBACK) {
+      if ((!callback || callback === this._DEFAULT_CALLBACK) && this.isNode(identifier)) {
+        callback = (node) => node;
+      }
+      return callback;
+    }
   };
 
   // src/data-structures/binary-tree/bst.ts
@@ -9397,23 +9396,29 @@ var dataStructureTyped = (() => {
   };
   var BST = class _BST extends BinaryTree {
     /**
-     * This is the constructor function for a TypeScript class that initializes a binary search tree with
-     * optional keys or nodes or entries and options.
-     * @param keysOrNodesOrEntries - An iterable object that contains keys, nodes, or entries. It is used
-     * to initialize the binary search tree with the provided keys, nodes, or entries.
+     * This is the constructor function for a Binary Search Tree class in TypeScript, which initializes
+     * the tree with keys, nodes, or entries and optional options.
+     * @param keysOrNodesOrEntries - The `keysOrNodesOrEntries` parameter is an iterable object that can
+     * contain keys, nodes, or entries. It is used to initialize the binary search tree with the provided
+     * keys, nodes, or entries.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
     constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
       __publicField(this, "_root");
-      __publicField(this, "_variant", "STANDARD");
+      __publicField(this, "_comparator", (a, b) => {
+        if (a > b)
+          return 1;
+        if (a < b)
+          return -1;
+        return 0;
+      });
       if (options) {
-        const { variant } = options;
-        if (variant)
-          this._variant = variant;
+        const { comparator } = options;
+        if (comparator)
+          this._comparator = comparator;
       }
-      this._root = void 0;
       if (keysOrNodesOrEntries)
         this.addMany(keysOrNodesOrEntries);
     }
@@ -9425,11 +9430,11 @@ var dataStructureTyped = (() => {
       return this._root;
     }
     /**
-     * The function returns the value of the _variant property.
-     * @returns The value of the `_variant` property.
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
      */
-    get variant() {
-      return this._variant;
+    get comparator() {
+      return this._comparator;
     }
     /**
      * The function creates a new BSTNode with the given key and value and returns it.
@@ -9453,7 +9458,7 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _BST([], __spreadValues({
         iterationType: this.iterationType,
-        variant: this.variant
+        comparator: this.comparator
       }, options));
     }
     /**
@@ -9501,17 +9506,21 @@ var dataStructureTyped = (() => {
      * @returns either a node object (NODE) or undefined.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE") {
+      if (keyOrNodeOrEntry === this.NIL)
+        return;
       if (this.isRealNode(keyOrNodeOrEntry)) {
         return keyOrNodeOrEntry;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        if (keyOrNodeOrEntry[0] === null || keyOrNodeOrEntry[0] === void 0)
-          return;
-        return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
-      } else {
-        if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0)
+      }
+      if (this.isEntry(keyOrNodeOrEntry)) {
+        const key2 = keyOrNodeOrEntry[0];
+        if (key2 === null || key2 === void 0)
           return;
-        return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+        return this.getNodeByKey(key2, iterationType);
       }
+      const key = keyOrNodeOrEntry;
+      if (key === null || key === void 0)
+        return;
+      return this.getNodeByKey(key, iterationType);
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
@@ -9529,13 +9538,11 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `add` function adds a new node to a binary tree, updating the value if the key already exists
-     * or inserting a new node if the key is unique.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
-     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-     * being added to the binary tree.
-     * @returns The method `add` returns either the newly added node (`newNode`) or `undefined` if the
-     * node was not added.
+     * The `add` function in TypeScript adds a new node to a binary search tree based on the key value,
+     * updating the value if the key already exists.
+     * @param keyOrNodeOrEntry - It is a parameter that can accept three types of values:
+     * @param {V} [value] - The value to be added to the binary search tree.
+     * @returns The method returns a boolean value.
      */
     add(keyOrNodeOrEntry, value) {
       const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
@@ -9548,10 +9555,10 @@ var dataStructureTyped = (() => {
       }
       let current = this.root;
       while (current !== void 0) {
-        if (this._compare(current.key, newNode.key) === "EQ") {
+        if (this.comparator(current.key, newNode.key) === 0) {
           this._replaceNode(current, newNode);
           return true;
-        } else if (this._compare(current.key, newNode.key) === "GT") {
+        } else if (this.comparator(current.key, newNode.key) > 0) {
           if (current.left === void 0) {
             current.left = newNode;
             this._size++;
@@ -9577,21 +9584,24 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(k log n)
      * Space Complexity: O(k + log n)
      *
-     * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
-     * balancing the tree after each addition.
-     * @param keysOrNodesOrEntries - An iterable containing the keys, nodes, or entries to be added to
-     * the binary tree.
+     * The `addMany` function in TypeScript adds multiple keys or nodes to a data structure, balancing
+     * the structure if specified, and returns an array indicating whether each key or node was
+     * successfully inserted.
+     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries to be added to the
+     * data structure.
      * @param [values] - An optional iterable of values to be associated with the keys or nodes being
      * added. If provided, the values will be assigned to the corresponding keys or nodes in the same
      * order. If not provided, undefined will be assigned as the value for each key or node.
-     * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
-     * balanced or not. If set to true, the add operation will be balanced using a binary search tree
-     * algorithm. If set to false, the add operation will not be balanced and the nodes will be added
-     * in the order they appear in the input.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when adding multiple keys or nodes. It has a default value of
-     * `this.iterationType`, which suggests that it is a property of the current object.
-     * @returns The function `addMany` returns an array of nodes (`NODE`) or `undefined` values.
+     * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
+     * adding the elements. If set to true, the tree will be balanced using a binary search tree
+     * algorithm. If set to false, the elements will be added without balancing the tree. The default
+     * value is true.
+     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
+     * specifies the type of iteration to use when adding multiple keys or nodes to the binary tree. It
+     * has a default value of `this.iterationType`, which means it will use the iteration type specified
+     * in the binary tree instance.
+     * @returns The function `addMany` returns an array of booleans indicating whether each key or node
+     * or entry was successfully inserted into the data structure.
      */
     addMany(keysOrNodesOrEntries, values, isBalanceAdd = true, iterationType = this.iterationType) {
       const inserted = [];
@@ -9618,20 +9628,23 @@ var dataStructureTyped = (() => {
       }
       let sorted = [];
       sorted = realBTNExemplars.sort((a, b) => {
-        let aR, bR;
-        if (this.isEntry(a))
-          aR = this.extractor(a[0]);
-        else if (this.isRealNode(a))
-          aR = this.extractor(a.key);
+        let keyA, keyB;
+        if (this.isEntry(a)) {
+          keyA = a[0];
+        } else if (this.isRealNode(a))
+          keyA = a.key;
         else
-          aR = this.extractor(a);
+          keyA = a;
         if (this.isEntry(b))
-          bR = this.extractor(b[0]);
+          keyB = b[0];
         else if (this.isRealNode(b))
-          bR = this.extractor(b.key);
+          keyB = b.key;
         else
-          bR = this.extractor(b);
-        return aR - bR;
+          keyB = b;
+        if (keyA !== void 0 && keyA !== null && keyB !== void 0 && keyB !== null) {
+          return this.comparator(keyA, keyB);
+        }
+        return 0;
       });
       const _dfs = (arr) => {
         if (arr.length === 0)
@@ -9666,54 +9679,6 @@ var dataStructureTyped = (() => {
       }
       return inserted;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
-     * either recursive or iterative methods.
-     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
-     * It is used to identify the node that we want to retrieve.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when searching for a node in the binary tree. It can have two possible
-     * values:
-     * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
-     * found in the binary tree. If no node is found, it returns `undefined`.
-     */
-    getNodeByKey(key, iterationType = "ITERATIVE") {
-      if (!this.isRealNode(this.root))
-        return;
-      if (iterationType === "RECURSIVE") {
-        const dfs = (cur) => {
-          if (cur.key === key)
-            return cur;
-          if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
-            return;
-          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);
-      } else {
-        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.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);
-          }
-        }
-      }
-    }
     /**
        * Time Complexity: O(log n)
        * Space Complexity: O(k + log n)
@@ -9746,6 +9711,7 @@ var dataStructureTyped = (() => {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
+      callback = this._ensureCallback(identifier, callback);
       const ans = [];
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
@@ -9758,9 +9724,9 @@ var dataStructureTyped = (() => {
           if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return;
           if (callback === this._DEFAULT_CALLBACK) {
-            if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === "GT")
+            if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier) > 0)
               dfs(cur.left);
-            if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === "LT")
+            if (this.isRealNode(cur.right) && this.comparator(cur.key, identifier) < 0)
               dfs(cur.right);
           } else {
             this.isRealNode(cur.left) && dfs(cur.left);
@@ -9772,22 +9738,20 @@ var dataStructureTyped = (() => {
         const stack = [beginRoot];
         while (stack.length > 0) {
           const cur = stack.pop();
-          if (this.isRealNode(cur)) {
-            const callbackResult = callback(cur);
-            if (callbackResult === identifier) {
-              ans.push(cur);
-              if (onlyOne)
-                return ans;
-            }
-            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")
-                stack.push(cur.left);
-            } else {
-              this.isRealNode(cur.right) && stack.push(cur.right);
-              this.isRealNode(cur.left) && stack.push(cur.left);
-            }
+          const callbackResult = callback(cur);
+          if (callbackResult === identifier) {
+            ans.push(cur);
+            if (onlyOne)
+              return ans;
+          }
+          if (callback === this._DEFAULT_CALLBACK) {
+            if (this.isRealNode(cur.right) && this.comparator(cur.key, identifier) < 0)
+              stack.push(cur.right);
+            if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier) > 0)
+              stack.push(cur.left);
+          } else {
+            this.isRealNode(cur.right) && stack.push(cur.right);
+            this.isRealNode(cur.left) && stack.push(cur.left);
           }
         }
       }
@@ -9822,6 +9786,27 @@ var dataStructureTyped = (() => {
       var _a;
       return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
+     * either recursive or iterative methods.
+     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
+     * It is used to identify the node that we want to retrieve.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when searching for a node in the binary tree. It can have two possible
+     * values:
+     * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
+     * found in the binary tree. If no node is found, it returns `undefined`.
+     */
+    getNodeByKey(key, iterationType = "ITERATIVE") {
+      return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -9897,38 +9882,6 @@ var dataStructureTyped = (() => {
     listLevels(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
       return super.listLevels(callback, beginRoot, iterationType, false);
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
-     * leftmost node if the comparison result is greater than.
-     * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `K`, `NODE`, or `undefined`. It represents the starting point for finding the last key in
-     * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
-     * the key of the leftmost node if the comparison result is greater than, and the key of the
-     * rightmost node otherwise. If no node is found, it returns 0.
-     */
-    lastKey(beginRoot = this.root) {
-      let current = this.ensureNode(beginRoot);
-      if (!current)
-        return void 0;
-      if (this._variant === "STANDARD") {
-        while (current.right !== void 0) {
-          current = current.right;
-        }
-      } else {
-        while (current.left !== void 0) {
-          current = current.left;
-        }
-      }
-      return current.key;
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -9954,18 +9907,18 @@ 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._DEFAULT_CALLBACK, lesserOrGreater = "LT", targetNode = this.root, iterationType = this.iterationType) {
-      targetNode = this.ensureNode(targetNode);
+    lesserOrGreaterTraverse(callback = this._DEFAULT_CALLBACK, lesserOrGreater = -1, targetNode = this.root, iterationType = this.iterationType) {
+      const targetNodeEnsured = this.ensureNode(targetNode);
       const ans = [];
-      if (!targetNode)
+      if (!targetNodeEnsured)
         return ans;
       if (!this.root)
         return ans;
-      const targetKey = targetNode.key;
+      const targetKey = targetNodeEnsured.key;
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
-          const compared = this._compare(cur.key, targetKey);
-          if (compared === lesserOrGreater)
+          const compared = this.comparator(cur.key, targetKey);
+          if (Math.sign(compared) === lesserOrGreater)
             ans.push(callback(cur));
           if (this.isRealNode(cur.left))
             dfs(cur.left);
@@ -9979,8 +9932,8 @@ var dataStructureTyped = (() => {
         while (queue.size > 0) {
           const cur = queue.shift();
           if (this.isRealNode(cur)) {
-            const compared = this._compare(cur.key, targetKey);
-            if (compared === lesserOrGreater)
+            const compared = this.comparator(cur.key, targetKey);
+            if (Math.sign(compared) === lesserOrGreater)
               ans.push(callback(cur));
             if (this.isRealNode(cur.left))
               queue.push(cur.left);
@@ -10117,47 +10070,6 @@ var dataStructureTyped = (() => {
       }
       this._root = v;
     }
-    /**
-     * The function compares two values using a comparator function and returns whether the first value
-     * is greater than, less than, or equal to the second value.
-     * @param {K} a - The parameter "a" is of type K.
-     * @param {K} b - The parameter "b" in the above code represents a K.
-     * @returns a value of type CP (ComparisonResult). The possible return values are 'GT' (greater
-     * than), 'LT' (less than), or 'EQ' (equal).
-     */
-    _compare(a, b) {
-      const extractedA = this.extractor(a);
-      const extractedB = this.extractor(b);
-      const compared = this.variant === "STANDARD" ? extractedA - extractedB : extractedB - extractedA;
-      return compared > 0 ? "GT" : compared < 0 ? "LT" : "EQ";
-    }
-    /**
-     * The function `_lt` compares two values `a` and `b` using an extractor function and returns true if
-     * `a` is less than `b` based on the specified variant.
-     * @param {K} a - The parameter "a" is of type "K", which means it can be any type. It represents the
-     * first value to be compared in the function.
-     * @param {K} b - The parameter `b` is of type `K`, which means it can be any type. It is used as one
-     * of the arguments for the comparison in the `_lt` function.
-     * @returns a boolean value.
-     */
-    _lt(a, b) {
-      const extractedA = this.extractor(a);
-      const extractedB = this.extractor(b);
-      return this.variant === "STANDARD" ? extractedA < extractedB : extractedA > extractedB;
-    }
-    /**
-     * The function compares two values using a custom extractor function and returns true if the first
-     * value is greater than the second value.
-     * @param {K} a - The parameter "a" is of type K, which means it can be any type.
-     * @param {K} b - The parameter "b" is of type K, which means it can be any type. It is used as one
-     * of the arguments for the comparison in the function.
-     * @returns a boolean value.
-     */
-    _gt(a, b) {
-      const extractedA = this.extractor(a);
-      const extractedB = this.extractor(b);
-      return this.variant === "STANDARD" ? extractedA > extractedB : extractedA < extractedB;
-    }
   };
 
   // src/data-structures/binary-tree/binary-indexed-tree.ts
@@ -10793,7 +10705,7 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _AVLTree([], __spreadValues({
         iterationType: this.iterationType,
-        variant: this.variant
+        comparator: this.comparator
       }, options));
     }
     /**
@@ -10849,8 +10761,6 @@ var dataStructureTyped = (() => {
      * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
      */
     delete(identifier, callback = this._DEFAULT_CALLBACK) {
-      if (identifier instanceof AVLTreeNode)
-        callback = (node) => node;
       const deletedResults = super.delete(identifier, callback);
       for (const { needBalanced } of deletedResults) {
         if (needBalanced) {
@@ -10870,21 +10780,21 @@ var dataStructureTyped = (() => {
      * if either `srcNode` or `destNode` is undefined.
      */
     _swapProperties(srcNode, destNode) {
-      srcNode = this.ensureNode(srcNode);
-      destNode = this.ensureNode(destNode);
-      if (srcNode && destNode) {
-        const { key, value, height } = destNode;
+      const srcNodeEnsured = this.ensureNode(srcNode);
+      const destNodeEnsured = this.ensureNode(destNode);
+      if (srcNodeEnsured && destNodeEnsured) {
+        const { key, value, height } = destNodeEnsured;
         const tempNode = this.createNode(key, value);
         if (tempNode) {
           tempNode.height = height;
-          destNode.key = srcNode.key;
-          destNode.value = srcNode.value;
-          destNode.height = srcNode.height;
-          srcNode.key = tempNode.key;
-          srcNode.value = tempNode.value;
-          srcNode.height = tempNode.height;
+          destNodeEnsured.key = srcNodeEnsured.key;
+          destNodeEnsured.value = srcNodeEnsured.value;
+          destNodeEnsured.height = srcNodeEnsured.height;
+          srcNodeEnsured.key = tempNode.key;
+          srcNodeEnsured.value = tempNode.value;
+          srcNodeEnsured.height = tempNode.height;
         }
-        return destNode;
+        return destNodeEnsured;
       }
       return void 0;
     }
@@ -11383,6 +11293,7 @@ var dataStructureTyped = (() => {
       if (identifier === null)
         return [];
       const results = [];
+      callback = this._ensureCallback(identifier, callback);
       const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
       if (!nodeToDelete) {
         return results;
@@ -11478,9 +11389,10 @@ var dataStructureTyped = (() => {
       let parent = void 0;
       while (this.isRealNode(current)) {
         parent = current;
-        if (node.key < current.key) {
+        const compared = this.comparator(node.key, current.key);
+        if (compared < 0) {
           current = (_a = current.left) != null ? _a : this.NIL;
-        } else if (node.key > current.key) {
+        } else if (compared > 0) {
           current = (_b = current.right) != null ? _b : this.NIL;
         } else {
           this._replaceNode(current, node);
@@ -11806,19 +11718,10 @@ var dataStructureTyped = (() => {
     createNode(key, value, count) {
       return new AVLTreeMultiMapNode(key, value, count);
     }
-    /**
-     * The function creates a new AVLTreeMultiMap object with the specified options and returns it.
-     * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the `AVLTreeMultiMap` object. It can include properties such as
-     * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
-     * the tree, respectively. These properties can be
-     * @returns a new instance of the `AVLTreeMultiMap` class, with the provided options merged with the
-     * default options. The returned value is casted as `TREE`.
-     */
     createTree(options) {
       return new _AVLTreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
-        variant: this.variant
+        comparator: this.comparator
       }, options));
     }
     /**
@@ -11920,6 +11823,7 @@ var dataStructureTyped = (() => {
       const deletedResult = [];
       if (!this.root)
         return deletedResult;
+      callback = this._ensureCallback(identifier, callback);
       const curr = (_a = this.getNode(identifier, callback)) != null ? _a : void 0;
       if (!curr)
         return deletedResult;
@@ -12295,6 +12199,7 @@ var dataStructureTyped = (() => {
       if (identifier === null)
         return [];
       const results = [];
+      callback = this._ensureCallback(identifier, callback);
       const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
       if (!nodeToDelete) {
         return results;