data-structure-typed 1.48.2 → 1.48.4

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

@@ -108,6 +108,7 @@ var dataStructureTyped = (() => {
     AbstractVertex: () => AbstractVertex,
     BST: () => BST,
     BSTNode: () => BSTNode,
+    BSTVariant: () => BSTVariant,
     BinaryIndexedTree: () => BinaryIndexedTree,
     BinaryTree: () => BinaryTree,
     BinaryTreeNode: () => BinaryTreeNode,
@@ -5472,6 +5473,10 @@ var dataStructureTyped = (() => {
         return this._addVertexOnly(newVertex);
       }
     }
+    isVertexKey(potentialKey) {
+      const potentialKeyType = typeof potentialKey;
+      return potentialKeyType === "string" || potentialKeyType === "number";
+    }
     /**
      * Time Complexity: O(1) - Constant time for Map operations.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -6597,34 +6602,77 @@ var dataStructureTyped = (() => {
       return removed;
     }
     /**
-     * Time Complexity: O(|E|) where |E| is the number of edges
+     * Time Complexity: O(E) where E is the number of edges
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(|E|) where |E| is the number of edges
+     * Time Complexity: O(E) where E is the number of edges
      * Space Complexity: O(1)
      *
-     * The function removes an edge from a graph and returns the removed edge, or undefined if the edge was not found.
-     * @param {EO} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
-     * and `dest`, which represent the source and destination vertices of the edge, respectively.
-     * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `undefined` if the edge does not exist.
+     * The `deleteEdge` function removes an edge from a graph and returns the removed edge.
+     * @param {EO | VertexKey} edgeOrSrcVertexKey - The `edge` parameter can be either an `EO` object (edge object) or
+     * a `VertexKey` (key of a vertex).
+     * @param {VertexKey} [destVertexKey] - The `destVertexKey` parameter is an optional parameter that
+     * represents the key of the destination vertex of the edge. It is used to specify the destination
+     * vertex when the `edge` parameter is a vertex key. If `destVertexKey` is not provided, the function
+     * assumes that the `edge`
+     * @returns the removed edge (EO) or undefined if no edge was removed.
      */
-    deleteEdge(edge) {
+    deleteEdge(edgeOrSrcVertexKey, destVertexKey) {
       let removed = void 0;
-      const src = this._getVertex(edge.src);
-      const dest = this._getVertex(edge.dest);
+      let src, dest;
+      if (this.isVertexKey(edgeOrSrcVertexKey)) {
+        if (this.isVertexKey(destVertexKey)) {
+          src = this._getVertex(edgeOrSrcVertexKey);
+          dest = this._getVertex(destVertexKey);
+        } else {
+          return;
+        }
+      } else {
+        src = this._getVertex(edgeOrSrcVertexKey.src);
+        dest = this._getVertex(edgeOrSrcVertexKey.dest);
+      }
       if (src && dest) {
         const srcOutEdges = this._outEdgeMap.get(src);
         if (srcOutEdges && srcOutEdges.length > 0) {
-          arrayRemove(srcOutEdges, (edge2) => edge2.src === src.key);
+          arrayRemove(srcOutEdges, (edge) => edge.src === src.key && edge.dest === (dest == null ? void 0 : dest.key));
         }
         const destInEdges = this._inEdgeMap.get(dest);
         if (destInEdges && destInEdges.length > 0) {
-          removed = arrayRemove(destInEdges, (edge2) => edge2.dest === dest.key)[0];
+          removed = arrayRemove(destInEdges, (edge) => edge.src === src.key && edge.dest === dest.key)[0];
         }
       }
       return removed;
     }
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     *
+     * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+     * (`VertexKey`).
+     * @returns The method is returning a boolean value.
+     */
+    deleteVertex(vertexOrKey) {
+      let vertexKey;
+      let vertex;
+      if (this.isVertexKey(vertexOrKey)) {
+        vertex = this.getVertex(vertexOrKey);
+        vertexKey = vertexOrKey;
+      } else {
+        vertex = vertexOrKey;
+        vertexKey = this._getVertexKey(vertexOrKey);
+      }
+      if (vertex) {
+        this._outEdgeMap.delete(vertex);
+        this._inEdgeMap.delete(vertex);
+      }
+      return this._vertices.delete(vertexKey);
+    }
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
@@ -7092,19 +7140,78 @@ var dataStructureTyped = (() => {
       return removed;
     }
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The deleteEdge function removes an edge between two vertices in a graph.
-     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
-     * @returns The method is returning either the removed edge (of type EO) or undefined if the edge was not found.
+     * The function `deleteEdge` deletes an edge between two vertices in a graph.
+     * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
+     * either an edge object or a vertex key.
+     * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
+     * parameter that represents the key of the vertex on the other side of the edge. It is used when the
+     * `edgeOrOneSideVertexKey` parameter is a vertex key, and it specifies the key of the vertex on the
+     * other side of the
+     * @returns The `deleteEdge` function returns either the deleted edge object (EO) or `undefined`.
      */
-    deleteEdge(edge) {
-      return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
+    deleteEdge(edgeOrOneSideVertexKey, otherSideVertexKey) {
+      let oneSide, otherSide;
+      if (this.isVertexKey(edgeOrOneSideVertexKey)) {
+        if (this.isVertexKey(otherSideVertexKey)) {
+          oneSide = this._getVertex(edgeOrOneSideVertexKey);
+          otherSide = this._getVertex(otherSideVertexKey);
+        } else {
+          return;
+        }
+      } else {
+        oneSide = this._getVertex(edgeOrOneSideVertexKey.vertices[0]);
+        otherSide = this._getVertex(edgeOrOneSideVertexKey.vertices[1]);
+      }
+      if (oneSide && otherSide) {
+        return this.deleteEdgeBetween(oneSide, otherSide);
+      } else {
+        return;
+      }
+    }
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     *
+     * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+     * (`VertexKey`).
+     * @returns The method is returning a boolean value.
+     */
+    deleteVertex(vertexOrKey) {
+      let vertexKey;
+      let vertex;
+      if (this.isVertexKey(vertexOrKey)) {
+        vertex = this.getVertex(vertexOrKey);
+        vertexKey = vertexOrKey;
+      } else {
+        vertex = vertexOrKey;
+        vertexKey = this._getVertexKey(vertexOrKey);
+      }
+      const neighbors = this.getNeighbors(vertexOrKey);
+      if (vertex) {
+        neighbors.forEach((neighbor) => {
+          const neighborEdges = this._edges.get(neighbor);
+          if (neighborEdges) {
+            const restEdges = neighborEdges.filter((edge) => {
+              return !edge.vertices.includes(vertexKey);
+            });
+            this._edges.set(neighbor, restEdges);
+          }
+        });
+        this._edges.delete(vertex);
+      }
+      return this._vertices.delete(vertexKey);
     }
     /**
      * Time Complexity: O(1)
@@ -7369,6 +7476,11 @@ var dataStructureTyped = (() => {
   })(RBTNColor || {});
 
   // src/types/common.ts
+  var BSTVariant = /* @__PURE__ */ ((BSTVariant2) => {
+    BSTVariant2["MIN"] = "MIN";
+    BSTVariant2["MAX"] = "MAX";
+    return BSTVariant2;
+  })(BSTVariant || {});
   var CP = /* @__PURE__ */ ((CP2) => {
     CP2["lt"] = "lt";
     CP2["eq"] = "eq";
@@ -7435,19 +7547,26 @@ var dataStructureTyped = (() => {
     constructor(elements, options) {
       super();
       __publicField(this, "iterationType", "ITERATIVE" /* ITERATIVE */);
+      __publicField(this, "_extractor", (key) => Number(key));
       __publicField(this, "_root");
       __publicField(this, "_size");
       __publicField(this, "_defaultOneParamCallback", (node) => node.key);
       if (options) {
-        const { iterationType } = options;
+        const { iterationType, extractor } = options;
         if (iterationType) {
           this.iterationType = iterationType;
         }
+        if (extractor) {
+          this._extractor = extractor;
+        }
       }
       this._size = 0;
       if (elements)
         this.addMany(elements);
     }
+    get extractor() {
+      return this._extractor;
+    }
     get root() {
       return this._root;
     }
@@ -7456,7 +7575,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
-     * @param {BTNKey} key - The key for the new node.
+     * @param {K} key - The key for the new node.
      * @param {V} value - The value for the new node.
      * @returns {N} - The newly created BinaryTreeNode.
      */
@@ -7475,7 +7594,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V,N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the class N.
      */
     isNode(exemplar) {
@@ -7484,7 +7603,7 @@ var dataStructureTyped = (() => {
     /**
      * The function `exemplarToNode` converts an exemplar of a binary tree node into an actual node
      * object.
-     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing the exemplar parameter of the
+     * @param exemplar - BTNodeExemplar<K, V,N> - A generic type representing the exemplar parameter of the
      * function. It can be any type.
      * @returns a value of type `N` (which represents a node), or `null`, or `undefined`.
      */
@@ -7505,7 +7624,7 @@ var dataStructureTyped = (() => {
         }
       } else if (this.isNode(exemplar)) {
         node = exemplar;
-      } else if (this.isNodeKey(exemplar)) {
+      } else if (this.isNotNodeInstance(exemplar)) {
         node = this.createNode(exemplar);
       } else {
         return;
@@ -7514,7 +7633,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param kne - BTNodeExemplar<V, N> - A generic type representing a node in a binary tree. It has
+     * @param kne - BTNodeExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
      * two type parameters V and N, representing the value and node type respectively.
      * @returns a boolean value.
      */
@@ -7580,7 +7699,7 @@ var dataStructureTyped = (() => {
      * The function `addMany` takes in an iterable of `BTNodeExemplar` objects, adds each object to the
      * current instance, and returns an array of the inserted nodes.
      * @param nodes - The `nodes` parameter is an iterable (such as an array or a set) of
-     * `BTNodeExemplar<V, N>` objects.
+     * `BTNodeExemplar<K, V,N>` objects.
      * @returns The function `addMany` returns an array of values, where each value is either of type
      * `N`, `null`, or `undefined`.
      */
@@ -7675,11 +7794,11 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function calculates the depth of a given node in a binary tree.
-     * @param {BTNKey | N | null | undefined} distNode - The `distNode` parameter represents the node in
-     * the binary tree whose depth we want to find. It can be of type `BTNKey`, `N`, `null`, or
+     * @param {K | N | null | undefined} distNode - The `distNode` parameter represents the node in
+     * the binary tree whose depth we want to find. It can be of type `K`, `N`, `null`, or
      * `undefined`.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
-     * from which we want to calculate the depth. It can be either a `BTNKey` (binary tree node key) or
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
      * `N` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
      * @returns the depth of the `distNode` relative to the `beginRoot`.
      */
@@ -7706,9 +7825,9 @@ var dataStructureTyped = (() => {
      *
      * The function `getHeight` calculates the maximum height of a binary tree using either recursive or
      * iterative traversal.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node of the binary tree from which we want to calculate the height. It can be of type
-     * `BTNKey`, `N`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
+     * `K`, `N`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
      * @param iterationType - The `iterationType` parameter is used to determine whether to calculate the
      * height of the tree using a recursive approach or an iterative approach. It can have two possible
      * values:
@@ -7752,9 +7871,9 @@ var dataStructureTyped = (() => {
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node of the binary tree from which we want to calculate the minimum height. It can be of
-     * type `BTNKey`, `N`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
+     * type `K`, `N`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
      * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
@@ -7812,8 +7931,8 @@ var dataStructureTyped = (() => {
      *
      * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
      * height of the tree.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for calculating the height and minimum height of a binary tree. It can be either a `BTNKey` (a key
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for calculating the height and minimum height of a binary tree. It can be either a `K` (a key
      * value of a binary tree node), `N` (a node of a binary tree), `null`, or `undefined`. If
      * @returns a boolean value.
      */
@@ -7838,7 +7957,7 @@ var dataStructureTyped = (() => {
      * matches the identifier. If set to true, the function will stop iterating once it finds a matching
      * node and return that node. If set to false (default), the function will continue iterating and
      * return all nodes that match the identifier.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node for the traversal. It can be either a key, a node object, or `null`/`undefined`. If
      * it is `null` or `undefined`, an empty array will be returned.
      * @param iterationType - The `iterationType` parameter determines the type of iteration used to
@@ -7894,8 +8013,8 @@ var dataStructureTyped = (() => {
      * the binary tree. It is used to filter the nodes based on certain conditions. The `callback`
      * function should return a boolean value indicating whether the node should be included in the
      * result or not.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for the search in the binary tree. It can be specified as a `BTNKey` (a unique identifier for a
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
      * node in the binary tree), a node object (`N`), or `null`/`undefined` to start the search from
      * @param iterationType - The `iterationType` parameter is a variable that determines the type of
      * iteration to be performed on the binary tree. It is used to specify whether the iteration should
@@ -7920,7 +8039,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
      * function should take a single parameter of type `N` (the type of the nodes in the binary tree) and
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
      * for searching the binary tree. It can be either a key value, a node object, or `null`/`undefined`.
      * If `null` or `undefined` is passed, the search will start from the root of the binary tree.
      * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
@@ -7944,7 +8063,7 @@ var dataStructureTyped = (() => {
      *
      * The function `getNodeByKey` searches for a node in a binary tree by its key, using either
      * recursive or iterative iteration.
-     * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
      * It is used to find the node with the matching key value.
      * @param iterationType - The `iterationType` parameter is used to determine whether the search for
      * the node with the given key should be performed iteratively or recursively. It has two possible
@@ -7987,7 +8106,7 @@ var dataStructureTyped = (() => {
     /**
      * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
-     * @param {BTNKey | N | null | undefined} key - The `key` parameter can be of type `BTNKey`, `N`,
+     * @param {K | N | null | undefined} key - The `key` parameter can be of type `K`, `N`,
      * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be used when searching for a node by key. It has a default value of
@@ -7996,7 +8115,7 @@ var dataStructureTyped = (() => {
      * itself if it is not a valid node key.
      */
     ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
-      return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
+      return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
      * Time Complexity: O(n)
@@ -8011,8 +8130,8 @@ var dataStructureTyped = (() => {
      * the binary tree. It is used to determine whether a node matches the given identifier. The callback
      * function should return a value that can be compared to the identifier to determine if it is a
      * match.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for the search in the binary tree. It can be specified as a `BTNKey` (a unique identifier for a
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
      * node), a node object of type `N`, or `null`/`undefined` to start the search from the root of
      * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
      * be performed when searching for a node in the binary tree. It is an optional parameter with a
@@ -8050,8 +8169,8 @@ var dataStructureTyped = (() => {
      *
      * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
      * structure, with the option to reverse the order of the nodes.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node from which you want to find the path to the root. It can be of type `BTNKey`, `N`,
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node from which you want to find the path to the root. It can be of type `K`, `N`,
      * `null`, or `undefined`.
      * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
      * resulting path should be reversed or not. If `isReverse` is set to `true`, the path will be
@@ -8080,8 +8199,8 @@ var dataStructureTyped = (() => {
      *
      * The function `getLeftMost` returns the leftmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for finding the leftmost node in a binary tree. It can be either a `BTNKey` (a key value), `N` (a
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for finding the leftmost node in a binary tree. It can be either a `K` (a key value), `N` (a
      * node), `null`, or `undefined`. If not provided, it defaults to `this.root`,
      * @param iterationType - The `iterationType` parameter is used to determine the type of iteration to
      * be performed when finding the leftmost node in a binary tree. It can have two possible values:
@@ -8118,8 +8237,8 @@ var dataStructureTyped = (() => {
      *
      * The function `getRightMost` returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node from which we want to find the rightmost node. It can be of type `BTNKey`, `N`,
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node from which we want to find the rightmost node. It can be of type `K`, `N`,
      * `null`, or `undefined`. If not provided, it defaults to `this.root`, which is a property of the
      * current object.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
@@ -8156,7 +8275,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `isSubtreeBST` checks if a given binary tree is a valid binary search tree.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the root
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the root
      * node of the binary search tree (BST) that you want to check if it is a subtree of another BST.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when checking if a subtree is a binary search tree (BST). It can have two
@@ -8171,9 +8290,10 @@ var dataStructureTyped = (() => {
         const dfs = (cur, min, max) => {
           if (!cur)
             return true;
-          if (cur.key <= min || cur.key >= max)
+          const numKey = this.extractor(cur.key);
+          if (numKey <= min || numKey >= max)
             return false;
-          return dfs(cur.left, min, cur.key) && dfs(cur.right, cur.key, max);
+          return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
         };
         return dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
       } else {
@@ -8185,9 +8305,10 @@ var dataStructureTyped = (() => {
             curr = curr.left;
           }
           curr = stack.pop();
-          if (!curr || prev >= curr.key)
+          const numKey = this.extractor(curr.key);
+          if (!curr || prev >= numKey)
             return false;
-          prev = curr.key;
+          prev = numKey;
           curr = curr.right;
         }
         return true;
@@ -8222,8 +8343,8 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the subtree traversal. It takes a single parameter, which is the current node being traversed, and
      * returns a value of any type.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node or key from which the subtree traversal should begin. It can be of type `BTNKey`,
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node or key from which the subtree traversal should begin. It can be of type `K`,
      * `N`, `null`, or `undefined`. If not provided, the `root` property of the current object is used as
      * the default value.
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
@@ -8302,13 +8423,13 @@ var dataStructureTyped = (() => {
       return this.isRealNode(node) || node === null;
     }
     /**
-     * The function "isNodeKey" checks if a potential key is a number.
+     * The function "isNotNodeInstance" checks if a potential key is a number.
      * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
-    isNodeKey(potentialKey) {
-      return typeof potentialKey === "number";
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof BinaryTreeNode);
     }
     /**
      * Time complexity: O(n)
@@ -8322,7 +8443,7 @@ var dataStructureTyped = (() => {
      * `null`, or `undefined`, and returns a value of any type. The default value for this parameter is
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
      * nodes are traversed during the depth-first search. It can have one of the following values:
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
      * for the depth-first search traversal. It can be specified as a key, a node object, or
      * `null`/`undefined`. If not provided, the `beginRoot` will default to the root node of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
@@ -8441,7 +8562,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the breadth-first search traversal. It takes a single parameter, which is the current node being
      * visited, and returns a value of any type.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node for the breadth-first search traversal. It can be specified as a key, a node object,
      * or `null`/`undefined` to indicate the root of the tree. If not provided, the `root` property of
      * the class is used as
@@ -8512,9 +8633,9 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the tree. It takes a single parameter, which can be of type `N`, `null`, or `undefined`, and
      * returns a value of any type.
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node for traversing the tree. It can be either a node object (`N`), a key value
-     * (`BTNKey`), `null`, or `undefined`. If not provided, it defaults to the root node of the tree.
+     * (`K`), `null`, or `undefined`. If not provided, it defaults to the root node of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
      * performed on the tree. It can have two possible values:
      * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
@@ -8571,7 +8692,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function `getPredecessor` returns the predecessor node of a given node in a binary tree.
-     * @param {BTNKey | N | null | undefined} node - The `node` parameter can be of type `BTNKey`, `N`,
+     * @param {K | N | null | undefined} node - The `node` parameter can be of type `K`, `N`,
      * `null`, or `undefined`.
      * @returns The function `getPredecessor` returns a value of type `N | undefined`.
      */
@@ -8593,7 +8714,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function `getSuccessor` returns the next node in a binary tree given a current node.
-     * @param {BTNKey | N | null} [x] - The parameter `x` can be of type `BTNKey`, `N`, or `null`.
+     * @param {K | N | null} [x] - The parameter `x` can be of type `K`, `N`, or `null`.
      * @returns the successor of the given node or key. The successor is the node that comes immediately
      * after the given node in the inorder traversal of the binary tree.
      */
@@ -8622,7 +8743,7 @@ var dataStructureTyped = (() => {
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
      * determines the order in which the nodes of a binary tree are traversed. It can have one of the
      * following values:
-     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
      * for the traversal. It can be specified as a key, a node object, or `null`/`undefined` to indicate
      * the root of the tree. If no value is provided, the default value is the root of the tree.
      * @returns The function `morris` returns an array of values that are the result of invoking the
@@ -8784,7 +8905,7 @@ var dataStructureTyped = (() => {
       return newTree;
     }
     // // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-    // // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
+    // // map<NV>(callback: (entry: [K, V | undefined], tree: this) => NV) {
     // //   const newTree = this.createTree();
     // //   for (const [key, value] of this) {
     // //     newTree.add(key, callback([key, value], this));
@@ -8794,7 +8915,7 @@ var dataStructureTyped = (() => {
     //
     /**
      * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {BTNKey | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `BTNKey | N | null |
+     * @param {K | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * following types:
      * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
@@ -8828,22 +8949,22 @@ var dataStructureTyped = (() => {
         const stack = [];
         let current = node;
         while (current || stack.length > 0) {
-          while (current && !isNaN(current.key)) {
+          while (current && !isNaN(this.extractor(current.key))) {
             stack.push(current);
             current = current.left;
           }
           current = stack.pop();
-          if (current && !isNaN(current.key)) {
+          if (current && !isNaN(this.extractor(current.key))) {
             yield [current.key, current.value];
             current = current.right;
           }
         }
       } else {
-        if (node.left && !isNaN(node.key)) {
+        if (node.left && !isNaN(this.extractor(node.key))) {
           yield* __yieldStar(this[Symbol.iterator](node.left));
         }
         yield [node.key, node.value];
-        if (node.right && !isNaN(node.key)) {
+        if (node.right && !isNaN(this.extractor(node.key))) {
           yield* __yieldStar(this[Symbol.iterator](node.right));
         }
       }
@@ -8855,10 +8976,10 @@ var dataStructureTyped = (() => {
         return emptyDisplayLayout;
       } else if (node === void 0 && !isShowUndefined) {
         return emptyDisplayLayout;
-      } else if (node !== null && node !== void 0 && isNaN(node.key) && !isShowRedBlackNIL) {
+      } else if (node !== null && node !== void 0 && isNaN(this.extractor(node.key)) && !isShowRedBlackNIL) {
         return emptyDisplayLayout;
       } else if (node !== null && node !== void 0) {
-        const key = node.key, line = isNaN(key) ? "S" : key.toString(), width = line.length;
+        const key = node.key, line = isNaN(this.extractor(key)) ? "S" : this.extractor(key).toString(), width = line.length;
         return _buildNodeDisplay(line, width, this._displayAux(node.left, options), this._displayAux(node.right, options));
       } else {
         const line = node === void 0 ? "U" : "N", width = line.length;
@@ -8936,7 +9057,7 @@ var dataStructureTyped = (() => {
      * If the parent node is null, the function also returns undefined.
      */
     _addTo(newNode, parent) {
-      if (this.isNodeKey(parent))
+      if (this.isNotNodeInstance(parent))
         parent = this.getNode(parent);
       if (parent) {
         if (parent.left === void 0) {
@@ -9028,11 +9149,11 @@ var dataStructureTyped = (() => {
     constructor(elements, options) {
       super([], options);
       __publicField(this, "_root");
-      __publicField(this, "comparator", (a, b) => a - b);
+      __publicField(this, "_variant", "MIN" /* MIN */);
       if (options) {
-        const { comparator } = options;
-        if (comparator) {
-          this.comparator = comparator;
+        const { variant } = options;
+        if (variant) {
+          this._variant = variant;
         }
       }
       this._root = void 0;
@@ -9042,9 +9163,12 @@ var dataStructureTyped = (() => {
     get root() {
       return this._root;
     }
+    get variant() {
+      return this._variant;
+    }
     /**
      * The function creates a new binary search tree node with the given key and value.
-     * @param {BTNKey} key - The key parameter is the key value that will be associated with
+     * @param {K} key - The key parameter is the key value that will be associated with
      * the new node. It is used to determine the position of the node in the binary search tree.
      * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It
      * represents the value associated with the node in a binary search tree.
@@ -9063,12 +9187,12 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _BST([], __spreadValues({
         iterationType: this.iterationType,
-        comparator: this.comparator
+        variant: this.variant
       }, options));
     }
     /**
      * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
      */
     isNode(exemplar) {
@@ -9077,7 +9201,7 @@ var dataStructureTyped = (() => {
     /**
      * The function `exemplarToNode` takes an exemplar and returns a corresponding node if the exemplar
      * is valid, otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a variable `node` which is of type `N` or `undefined`.
      */
     exemplarToNode(exemplar) {
@@ -9093,7 +9217,7 @@ var dataStructureTyped = (() => {
         } else {
           node = this.createNode(key, value);
         }
-      } else if (this.isNodeKey(exemplar)) {
+      } else if (this.isNotNodeInstance(exemplar)) {
         node = this.createNode(exemplar);
       } else {
         return;
@@ -9190,17 +9314,17 @@ var dataStructureTyped = (() => {
       sorted = realBTNExemplars.sort((a, b) => {
         let aR, bR;
         if (this.isEntry(a))
-          aR = a[0];
+          aR = this.extractor(a[0]);
         else if (this.isRealNode(a))
-          aR = a.key;
+          aR = this.extractor(a.key);
         else
-          aR = a;
+          aR = this.extractor(a);
         if (this.isEntry(b))
-          bR = b[0];
+          bR = this.extractor(b[0]);
         else if (this.isRealNode(b))
-          bR = b.key;
+          bR = this.extractor(b.key);
         else
-          bR = b;
+          bR = this.extractor(b);
         return aR - bR;
       });
       const _dfs = (arr) => {
@@ -9236,34 +9360,31 @@ var dataStructureTyped = (() => {
       }
       return inserted;
     }
-    /**
-     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
-     */
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
-     *
-     * 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 {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `BTNKey`, `N`, 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`).
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed. It can have one of the following values:
-     * @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, iterationType = this.iterationType) {
-      var _a, _b, _c, _d, _e, _f;
-      if (this._compare(0, 1) === "lt" /* lt */)
-        return (_b = (_a = this.getRightMost(beginRoot, iterationType)) == null ? void 0 : _a.key) != null ? _b : 0;
-      else if (this._compare(0, 1) === "gt" /* gt */)
-        return (_d = (_c = this.getLeftMost(beginRoot, iterationType)) == null ? void 0 : _c.key) != null ? _d : 0;
-      else
-        return (_f = (_e = this.getRightMost(beginRoot, iterationType)) == null ? void 0 : _e.key) != null ? _f : 0;
-    }
+    // /**
+    //  * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
+    //  * Space Complexity: O(n) - Additional space is required for the sorted array.
+    //  */
+    //
+    // /**
+    //  * Time Complexity: O(log n) - Average case for a balanced tree.
+    //  * Space Complexity: O(1) - Constant space is used.
+    //  *
+    //  * 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 | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
+    //  * type `K`, `N`, 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`).
+    //  * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+    //  * be performed. It can have one of the following values:
+    //  * @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: BSTNodeKeyOrNode<K,N> = this.root, iterationType = this.iterationType): K {
+    //   if (this._compare(0, 1) === CP.lt) return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
+    //   else if (this._compare(0, 1) === CP.gt) return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
+    //   else return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
+    // }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.
@@ -9274,7 +9395,7 @@ var dataStructureTyped = (() => {
      *
      * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
      * either recursive or iterative methods.
-     * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+     * @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
@@ -9319,14 +9440,14 @@ var dataStructureTyped = (() => {
     /**
      * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
      * otherwise it returns the key itself.
-     * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
+     * @param {K | N | undefined} key - The `key` parameter can be of type `K`, `N`, or
      * `undefined`.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
     ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
-      return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
+      return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
@@ -9344,7 +9465,7 @@ var dataStructureTyped = (() => {
      * first node that matches the identifier. If set to true, the function will return an array
      * containing only the first matching node. If set to false (default), the function will continue
      * searching for all nodes that match the identifier and return an array containing
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
      * for the traversal. It can be either a key value or a node object. If it is undefined, the
      * traversal will start from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
@@ -9419,7 +9540,7 @@ var dataStructureTyped = (() => {
      * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It is of type
      * `CP`, which is a custom type representing the comparison operator. The possible values for
      * `lesserOrGreater` are
-     * @param {BTNKey | N | undefined} targetNode - The `targetNode` parameter represents the node in the
+     * @param {K | N | undefined} targetNode - The `targetNode` parameter represents the node in the
      * binary tree that you want to traverse from. It can be specified either by its key, by the node
      * object itself, or it can be left undefined to start the traversal from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
@@ -9591,19 +9712,16 @@ var dataStructureTyped = (() => {
     /**
      * 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 {BTNKey} a - The parameter "a" is of type BTNKey.
-     * @param {BTNKey} b - The parameter "b" in the above code represents a BTNKey.
+     * @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 CP.gt (greater
      * than), CP.lt (less than), or CP.eq (equal).
      */
     _compare(a, b) {
-      const compared = this.comparator(a, b);
-      if (compared > 0)
-        return "gt" /* gt */;
-      else if (compared < 0)
-        return "lt" /* lt */;
-      else
-        return "eq" /* eq */;
+      const extractedA = this.extractor(a);
+      const extractedB = this.extractor(b);
+      const compared = this.variant === "MIN" /* MIN */ ? extractedA - extractedB : extractedB - extractedA;
+      return compared > 0 ? "gt" /* gt */ : compared < 0 ? "lt" /* lt */ : "eq" /* eq */;
     }
   };
 
@@ -10044,7 +10162,7 @@ var dataStructureTyped = (() => {
   var AVLTree = class _AVLTree extends BST {
     /**
      * The constructor function initializes an AVLTree object with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
      * objects. It represents a collection of elements that will be added to the AVL tree during
      * initialization.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
@@ -10058,7 +10176,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
-     * @param {BTNKey} key - The key parameter is the key value that will be associated with
+     * @param {K} key - The key parameter is the key value that will be associated with
      * the new node. It is used to determine the position of the node in the binary search tree.
      * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It is of
      * type `V`, which means it can be any value that is assignable to the `value` property of the
@@ -10078,12 +10196,12 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _AVLTree([], __spreadValues({
         iterationType: this.iterationType,
-        comparator: this.comparator
+        variant: this.variant
       }, options));
     }
     /**
      * The function checks if an exemplar is an instance of AVLTreeNode.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
      */
     isNode(exemplar) {
@@ -10144,9 +10262,9 @@ var dataStructureTyped = (() => {
     /**
      * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
      * tree.
-     * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node that
-     * needs to be swapped with the destination node. It can be of type `BTNKey`, `N`, or `undefined`.
-     * @param {BTNKey | N  | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node that
+     * needs to be swapped with the destination node. It can be of type `K`, `N`, or `undefined`.
+     * @param {K | N  | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
@@ -10458,7 +10576,7 @@ var dataStructureTyped = (() => {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -10483,7 +10601,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
-     * @param {BTNKey} key - The key parameter is the key value associated with the node. It is used to
+     * @param {K} key - The key parameter is the key value associated with the node. It is used to
      * identify and compare nodes in the Red-Black Tree.
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
      * associated with the node. It is of type `V`, which is a generic type that can be replaced with any
@@ -10506,12 +10624,12 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _RedBlackTree([], __spreadValues({
         iterationType: this.iterationType,
-        comparator: this.comparator
+        variant: this.variant
       }, options));
     }
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
@@ -10521,7 +10639,7 @@ var dataStructureTyped = (() => {
     /**
      * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
      * otherwise it returns undefined.
-     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing an exemplar of a binary tree
+     * @param exemplar - BTNodeExemplar<K, V, N> - A generic type representing an exemplar of a binary tree
      * node. It can be either a node itself, an entry (key-value pair), a node key, or any other value
      * that is not a valid exemplar.
      * @returns a variable `node` which is of type `N | undefined`.
@@ -10539,7 +10657,7 @@ var dataStructureTyped = (() => {
         } else {
           node = this.createNode(key, value, 1 /* RED */);
         }
-      } else if (this.isNodeKey(exemplar)) {
+      } else if (this.isNotNodeInstance(exemplar)) {
         node = this.createNode(exemplar, void 0, 1 /* RED */);
       } else {
         return;
@@ -10695,7 +10813,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
      * function should take a single parameter of type `N` (the type of the nodes in the binary tree) and
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter is the starting point for
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is the starting point for
      * searching for a node in a binary tree. It can be either a key value or a node object. If it is not
      * provided, the search will start from the root of the binary tree.
      * @param iterationType - The `iterationType` parameter is a variable that determines the type of
@@ -11002,7 +11120,7 @@ var dataStructureTyped = (() => {
   var TreeMultimapNode = class extends AVLTreeNode {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
-     * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
+     * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
      * of the binary tree node.
      * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
      * tree node. If no value is provided, it will be `undefined`.
@@ -11031,7 +11149,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function creates a new BSTNode with the given key, value, and count.
-     * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
+     * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
      * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
@@ -11044,12 +11162,12 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _TreeMultimap([], __spreadValues({
         iterationType: this.iterationType,
-        comparator: this.comparator
+        variant: this.variant
       }, options));
     }
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
@@ -11058,7 +11176,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`, where `V` represents
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where `V` represents
      * the value type and `N` represents the node type.
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
      * times the node should be created. If not provided, it defaults to 1.
@@ -11077,7 +11195,7 @@ var dataStructureTyped = (() => {
         } else {
           node = this.createNode(key, value, count);
         }
-      } else if (this.isNodeKey(exemplar)) {
+      } else if (this.isNotNodeInstance(exemplar)) {
         node = this.createNode(exemplar, void 0, count);
       } else {
         return;
@@ -11289,9 +11407,9 @@ var dataStructureTyped = (() => {
      * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
      * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
      * `undefined` if there is no node to add.
-     * @param {BTNKey | N | undefined} parent - The `parent` parameter represents the parent node to
+     * @param {K | N | undefined} parent - The `parent` parameter represents the parent node to
      * which the new node will be added as a child. It can be either a node object (`N`) or a key value
-     * (`BTNKey`).
+     * (`K`).
      * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
      * added, or `undefined` if no node was added.
      */
@@ -11321,9 +11439,9 @@ var dataStructureTyped = (() => {
     }
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-     * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
-     * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
-     * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
+     * which the values will be swapped. It can be of type `K`, `N`, or `undefined`.
+     * @param {K | N | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.