data-structure-typed 1.52.8 → 1.53.0

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

@@ -6946,27 +6946,36 @@ var dataStructureTyped = (() => {
     /**
      * The constructor initializes a binary tree with optional options and adds keys, nodes, entries, or
      * raw data if provided.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter in the constructor
-     * is an iterable that can contain elements of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`. It is
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor
+     * is an iterable that can contain elements of type `BTNRep<K, V, NODE>` or `R`. It is
      * initialized with an empty array `[]` by default.
      * @param [options] - The `options` parameter in the constructor is an object that can contain the
      * following properties:
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
       super();
       __publicField(this, "iterationType", "ITERATIVE");
+      __publicField(this, "_isMapMode", false);
+      __publicField(this, "_store", /* @__PURE__ */ new Map());
       __publicField(this, "_root");
       __publicField(this, "_size", 0);
       __publicField(this, "_NIL", new BinaryTreeNode(NaN));
       __publicField(this, "_toEntryFn");
-      __publicField(this, "_DEFAULT_BTN_CALLBACK", (node) => node ? node.key : void 0);
+      __publicField(this, "_DEFAULT_NODE_CALLBACK", (node) => node ? node.key : void 0);
       if (options) {
-        const { iterationType, toEntryFn } = options;
+        const { iterationType, toEntryFn, isMapMode } = options;
         if (iterationType) this.iterationType = iterationType;
+        if (isMapMode !== void 0) this._isMapMode = isMapMode;
         if (typeof toEntryFn === "function") this._toEntryFn = toEntryFn;
         else if (toEntryFn) throw TypeError("toEntryFn must be a function type");
       }
-      if (keysOrNodesOrEntriesOrRaws) this.addMany(keysOrNodesOrEntriesOrRaws);
+      if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    }
+    get isMapMode() {
+      return this._isMapMode;
+    }
+    get store() {
+      return this._store;
     }
     get root() {
       return this._root;
@@ -7003,41 +7012,46 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _BinaryTree([], __spreadValues({
         iterationType: this.iterationType,
+        isMapMode: this._isMapMode,
         toEntryFn: this._toEntryFn
       }, options));
     }
     /**
-     * The function `keyValueOrEntryOrRawElementToNode` converts various input types into a node object
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
      * or returns null.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
-     * `keyValueOrEntryOrRawElementToNode` function takes in a parameter `keyOrNodeOrEntryOrRaw`, which
-     * can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`. This parameter represents either a key, a
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
+     * can be of type `BTNRep<K, V, NODE>` or `R`. This parameter represents either a key, a
      * node, an entry
-     * @param {V} [value] - The `value` parameter in the `keyValueOrEntryOrRawElementToNode` function is
+     * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
      * an optional parameter of type `V`. It represents the value associated with the key in the node
      * being created. If a `value` is provided, it will be used when creating the node. If
-     * @returns The `keyValueOrEntryOrRawElementToNode` function returns an optional node
-     * (`OptBTNOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
-     * input parameter (`keyOrNodeOrEntryOrRaw`) and processes it accordingly to return a node or null
+     * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
+     * (`OptNodeOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
+     * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
      * value.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value) {
-      if (keyOrNodeOrEntryOrRaw === void 0) return;
-      if (keyOrNodeOrEntryOrRaw === null) return null;
-      if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
-      if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
-        const [key, entryValue] = keyOrNodeOrEntryOrRaw;
-        if (key === void 0) return;
-        else if (key === null) return null;
-        if (this.isKey(key)) return this.createNode(key, value != null ? value : entryValue);
+    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
+      if (keyNodeEntryOrRaw === void 0) return [void 0, void 0];
+      if (keyNodeEntryOrRaw === null) return [null, void 0];
+      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
+      if (this.isEntry(keyNodeEntryOrRaw)) {
+        const [key, entryValue] = keyNodeEntryOrRaw;
+        if (key === void 0) return [void 0, void 0];
+        else if (key === null) return [null, void 0];
+        const finalValue = value != null ? value : entryValue;
+        return [this.createNode(key, finalValue), finalValue];
       }
-      if (this._toEntryFn) {
-        const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw);
-        if (this.isKey(key)) return this.createNode(key, value != null ? value : entryValue);
-        else return;
+      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
+      if (this.isRaw(keyNodeEntryOrRaw)) {
+        if (this._toEntryFn) {
+          const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+          const finalValue = value != null ? value : entryValue;
+          if (this.isKey(key)) return [this.createNode(key, finalValue), finalValue];
+        }
+        return [void 0, void 0];
       }
-      if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.createNode(keyOrNodeOrEntryOrRaw, value);
-      return;
+      return [void 0, void 0];
     }
     /**
      * Time Complexity: O(n)
@@ -7045,8 +7059,8 @@ var dataStructureTyped = (() => {
      *
      * The function `ensureNode` in TypeScript checks if a given input is a node, entry, key, or raw
      * value and returns the corresponding node or null.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `keyOrNodeOrEntryOrRaw`
-     * parameter in the `ensureNode` function can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`. It
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
+     * parameter in the `ensureNode` function can be of type `BTNRep<K, V, NODE>` or `R`. It
      * is used to determine whether the input is a key, node, entry, or raw data. The
      * @param {IterationType} iterationType - The `iterationType` parameter in the `ensureNode` function
      * is used to specify the type of iteration to be performed. It has a default value of
@@ -7054,103 +7068,105 @@ var dataStructureTyped = (() => {
      * @returns The `ensureNode` function returns either a node, `null`, or `undefined` based on the
      * conditions specified in the code snippet.
      */
-    ensureNode(keyOrNodeOrEntryOrRaw, iterationType = this.iterationType) {
-      if (keyOrNodeOrEntryOrRaw === null) return null;
-      if (keyOrNodeOrEntryOrRaw === void 0) return;
-      if (keyOrNodeOrEntryOrRaw === this._NIL) return;
-      if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
-      if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
-        const key = keyOrNodeOrEntryOrRaw[0];
+    ensureNode(keyNodeEntryOrRaw, iterationType = this.iterationType) {
+      if (keyNodeEntryOrRaw === null) return null;
+      if (keyNodeEntryOrRaw === void 0) return;
+      if (keyNodeEntryOrRaw === this._NIL) return;
+      if (this.isNode(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw;
+      if (this.isEntry(keyNodeEntryOrRaw)) {
+        const key = keyNodeEntryOrRaw[0];
         if (key === null) return null;
         if (key === void 0) return;
         return this.getNodeByKey(key, iterationType);
       }
       if (this._toEntryFn) {
-        const [key] = this._toEntryFn(keyOrNodeOrEntryOrRaw);
+        const [key] = this._toEntryFn(keyNodeEntryOrRaw);
         if (this.isKey(key)) return this.getNodeByKey(key);
       }
-      if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.getNodeByKey(keyOrNodeOrEntryOrRaw, iterationType);
+      if (this.isKey(keyNodeEntryOrRaw)) return this.getNodeByKey(keyNodeEntryOrRaw, iterationType);
       return;
     }
     /**
      * The function isNode checks if the input is an instance of BinaryTreeNode.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be either a key, a node, an entry, or raw data. The function is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be either a key, a node, an entry, or raw data. The function is
      * checking if the input is an instance of a `BinaryTreeNode` and returning a boolean value
      * accordingly.
-     * @returns The function `isNode` is checking if the input `keyOrNodeOrEntryOrRaw` is an instance of
+     * @returns The function `isNode` is checking if the input `keyNodeEntryOrRaw` is an instance of
      * `BinaryTreeNode`. If it is, the function returns `true`, indicating that the input is a node. If
      * it is not an instance of `BinaryTreeNode`, the function returns `false`, indicating that the input
      * is not a node.
      */
-    isNode(keyOrNodeOrEntryOrRaw) {
-      return keyOrNodeOrEntryOrRaw instanceof BinaryTreeNode;
+    isNode(keyNodeEntryOrRaw) {
+      return keyNodeEntryOrRaw instanceof BinaryTreeNode;
+    }
+    isRaw(keyNodeEntryOrRaw) {
+      return typeof keyNodeEntryOrRaw === "object";
     }
     /**
      * The function `isRealNode` checks if a given input is a valid node in a binary tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `keyOrNodeOrEntryOrRaw`
-     * parameter in the `isRealNode` function can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
+     * parameter in the `isRealNode` function can be of type `BTNRep<K, V, NODE>` or `R`.
      * The function checks if the input parameter is a `NODE` type by verifying if it is not equal
-     * @returns The function `isRealNode` is checking if the input `keyOrNodeOrEntryOrRaw` is a valid
+     * @returns The function `isRealNode` is checking if the input `keyNodeEntryOrRaw` is a valid
      * node by comparing it to `this._NIL`, `null`, and `undefined`. If the input is not one of these
      * values, it then calls the `isNode` method to further determine if the input is a node. The
      * function will return a boolean value indicating whether the
      */
-    isRealNode(keyOrNodeOrEntryOrRaw) {
-      if (keyOrNodeOrEntryOrRaw === this._NIL || keyOrNodeOrEntryOrRaw === null || keyOrNodeOrEntryOrRaw === void 0)
-        return false;
-      return this.isNode(keyOrNodeOrEntryOrRaw);
+    isRealNode(keyNodeEntryOrRaw) {
+      if (keyNodeEntryOrRaw === this._NIL || keyNodeEntryOrRaw === null || keyNodeEntryOrRaw === void 0) return false;
+      return this.isNode(keyNodeEntryOrRaw);
     }
     /**
      * The function checks if a given input is a valid node or null.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` in the `isRealNodeOrNull` function can be of type `BTNKeyOrNodeOrEntry<K,
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` in the `isRealNodeOrNull` function can be of type `BTNRep<K,
      * V, NODE>` or `R`. It is a union type that can either be a key, a node, an entry, or
      * @returns The function `isRealNodeOrNull` is returning a boolean value. It checks if the input
-     * `keyOrNodeOrEntryOrRaw` is either `null` or a real node, and returns `true` if it is a node or
+     * `keyNodeEntryOrRaw` is either `null` or a real node, and returns `true` if it is a node or
      * `null`, and `false` otherwise.
      */
-    isRealNodeOrNull(keyOrNodeOrEntryOrRaw) {
-      return keyOrNodeOrEntryOrRaw === null || this.isRealNode(keyOrNodeOrEntryOrRaw);
+    isRealNodeOrNull(keyNodeEntryOrRaw) {
+      return keyNodeEntryOrRaw === null || this.isRealNode(keyNodeEntryOrRaw);
     }
     /**
      * The function isNIL checks if a given key, node, entry, or raw value is equal to the _NIL value.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - BTNKeyOrNodeOrEntry<K, V,
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - BTNRep<K, V,
      * NODE> | R
-     * @returns The function is checking if the `keyOrNodeOrEntryOrRaw` parameter is equal to the `_NIL`
+     * @returns The function is checking if the `keyNodeEntryOrRaw` parameter is equal to the `_NIL`
      * property of the current object and returning a boolean value based on that comparison.
      */
-    isNIL(keyOrNodeOrEntryOrRaw) {
-      return keyOrNodeOrEntryOrRaw === this._NIL;
+    isNIL(keyNodeEntryOrRaw) {
+      return keyNodeEntryOrRaw === this._NIL;
     }
     /**
      * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
      * tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`. It represents a
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `BTNRep<K, V, NODE>` or `R`. It represents a
      * key, node, entry, or raw data in a binary tree structure. The function `isLeaf` checks whether the
      * provided
      * @returns The function `isLeaf` returns a boolean value indicating whether the input
-     * `keyOrNodeOrEntryOrRaw` is a leaf node in a binary tree.
+     * `keyNodeEntryOrRaw` is a leaf node in a binary tree.
      */
-    isLeaf(keyOrNodeOrEntryOrRaw) {
-      keyOrNodeOrEntryOrRaw = this.ensureNode(keyOrNodeOrEntryOrRaw);
-      if (keyOrNodeOrEntryOrRaw === void 0) return false;
-      if (keyOrNodeOrEntryOrRaw === null) return true;
-      return !this.isRealNode(keyOrNodeOrEntryOrRaw.left) && !this.isRealNode(keyOrNodeOrEntryOrRaw.right);
+    isLeaf(keyNodeEntryOrRaw) {
+      keyNodeEntryOrRaw = this.ensureNode(keyNodeEntryOrRaw);
+      if (keyNodeEntryOrRaw === void 0) return false;
+      if (keyNodeEntryOrRaw === null) return true;
+      return !this.isRealNode(keyNodeEntryOrRaw.left) && !this.isRealNode(keyNodeEntryOrRaw.right);
     }
     /**
      * The function `isEntry` checks if the input is a BTNEntry object by verifying if it is an array
      * with a length of 2.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `keyOrNodeOrEntryOrRaw`
-     * parameter in the `isEntry` function can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or type `R`.
-     * The function checks if the provided `keyOrNodeOrEntryOrRaw` is of type `BTN
-     * @returns The `isEntry` function is checking if the `keyOrNodeOrEntryOrRaw` parameter is an array
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
+     * parameter in the `isEntry` function can be of type `BTNRep<K, V, NODE>` or type `R`.
+     * The function checks if the provided `keyNodeEntryOrRaw` is of type `BTN
+     * @returns The `isEntry` function is checking if the `keyNodeEntryOrRaw` parameter is an array
      * with a length of 2. If it is, then it returns `true`, indicating that the parameter is of type
      * `BTNEntry<K, V>`. If the condition is not met, it returns `false`.
      */
-    isEntry(keyOrNodeOrEntryOrRaw) {
-      return Array.isArray(keyOrNodeOrEntryOrRaw) && keyOrNodeOrEntryOrRaw.length === 2;
+    isEntry(keyNodeEntryOrRaw) {
+      return Array.isArray(keyNodeEntryOrRaw) && keyNodeEntryOrRaw.length === 2;
     }
     /**
      * Time Complexity O(1)
@@ -7173,8 +7189,8 @@ var dataStructureTyped = (() => {
      *
      * The `add` function in TypeScript adds a new node to a binary tree while handling duplicate keys
      * and finding the correct insertion position.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `add` method you provided
-     * seems to be for adding a new node to a binary tree structure. The `keyOrNodeOrEntryOrRaw`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `add` method you provided
+     * seems to be for adding a new node to a binary tree structure. The `keyNodeEntryOrRaw`
      * parameter in the method can accept different types of values:
      * @param {V} [value] - The `value` parameter in the `add` method represents the value associated
      * with the key that you want to add to the binary tree. When adding a key-value pair to the binary
@@ -7184,11 +7200,12 @@ var dataStructureTyped = (() => {
      * node was successful, and `false` if the insertion position could not be found or if a duplicate
      * key was found and the node was replaced instead of inserted.
      */
-    add(keyOrNodeOrEntryOrRaw, value) {
-      const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value);
+    add(keyNodeEntryOrRaw, value) {
+      const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
       if (newNode === void 0) return false;
       if (!this._root) {
         this._setRoot(newNode);
+        if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
         this._size = 1;
         return true;
       }
@@ -7199,6 +7216,7 @@ var dataStructureTyped = (() => {
         if (!cur) continue;
         if (newNode !== null && cur.key === newNode.key) {
           this._replaceNode(cur, newNode);
+          if (this._isMapMode) this._setValue(cur.key, newValue);
           return true;
         }
         if (potentialParent === void 0 && (cur.left === void 0 || cur.right === void 0)) {
@@ -7217,6 +7235,7 @@ var dataStructureTyped = (() => {
         } else if (potentialParent.right === void 0) {
           potentialParent.right = newNode;
         }
+        if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
         this._size++;
         return true;
       }
@@ -7229,24 +7248,24 @@ var dataStructureTyped = (() => {
      * The `addMany` function takes in multiple keys or nodes or entries or raw values along with
      * optional values, and adds them to a data structure while returning an array indicating whether
      * each insertion was successful.
-     * @param keysOrNodesOrEntriesOrRaws - `keysOrNodesOrEntriesOrRaws` is an iterable that can contain a
+     * @param keysNodesEntriesOrRaws - `keysNodesEntriesOrRaws` is an iterable that can contain a
      * mix of keys, nodes, entries, or raw values. Each element in this iterable can be of type
-     * `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`.
+     * `BTNRep<K, V, NODE>` or `R`.
      * @param [values] - The `values` parameter in the `addMany` function is an optional parameter that
      * accepts an iterable of values. These values correspond to the keys or nodes being added in the
-     * `keysOrNodesOrEntriesOrRaws` parameter. If provided, the function will iterate over the values and
+     * `keysNodesEntriesOrRaws` parameter. If provided, the function will iterate over the values and
      * assign them
      * @returns The `addMany` method returns an array of boolean values indicating whether each key,
      * node, entry, or raw value was successfully added to the data structure. Each boolean value
      * corresponds to the success of adding the corresponding key or value in the input iterable.
      */
-    addMany(keysOrNodesOrEntriesOrRaws, values) {
+    addMany(keysNodesEntriesOrRaws, values) {
       const inserted = [];
       let valuesIterator;
       if (values) {
         valuesIterator = values[Symbol.iterator]();
       }
-      for (const keyOrNodeOrEntryOrRaw of keysOrNodesOrEntriesOrRaws) {
+      for (const keyNodeEntryOrRaw of keysNodesEntriesOrRaws) {
         let value = void 0;
         if (valuesIterator) {
           const valueResult = valuesIterator.next();
@@ -7254,7 +7273,7 @@ var dataStructureTyped = (() => {
             value = valueResult.value;
           }
         }
-        inserted.push(this.add(keyOrNodeOrEntryOrRaw, value));
+        inserted.push(this.add(keyNodeEntryOrRaw, value));
       }
       return inserted;
     }
@@ -7264,15 +7283,15 @@ var dataStructureTyped = (() => {
      *
      * The `refill` function clears the existing data structure and then adds new key-value pairs based
      * on the provided input.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter in the `refill`
-     * method can accept an iterable containing a mix of `BTNKeyOrNodeOrEntry<K, V, NODE>` objects or `R`
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the `refill`
+     * method can accept an iterable containing a mix of `BTNRep<K, V, NODE>` objects or `R`
      * objects.
      * @param [values] - The `values` parameter in the `refill` method is an optional parameter that
      * accepts an iterable of values of type `V` or `undefined`.
      */
-    refill(keysOrNodesOrEntriesOrRaws, values) {
+    refill(keysNodesEntriesOrRaws, values) {
       this.clear();
-      this.addMany(keysOrNodesOrEntriesOrRaws, values);
+      this.addMany(keysNodesEntriesOrRaws, values);
     }
     /**
      * Time Complexity: O(n)
@@ -7280,19 +7299,19 @@ var dataStructureTyped = (() => {
      *
      * The function `delete` in TypeScript implements the deletion of a node in a binary tree and returns
      * the deleted node along with information for tree balancing.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrNodeOrEntryOrRawOrPredicate
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw
      * - The `delete` method you provided is used to delete a node from a binary tree based on the key,
-     * node, entry, raw data, or a custom predicate. The method returns an array of
+     * node, entry or raw data. The method returns an array of
      * `BinaryTreeDeleteResult` objects containing information about the deleted node and whether
      * balancing is needed.
      * @returns The `delete` method returns an array of `BinaryTreeDeleteResult` objects. Each object in
      * the array contains information about the node that was deleted (`deleted`) and the node that may
      * need to be balanced (`needBalanced`).
      */
-    delete(keyOrNodeOrEntryOrRawOrPredicate) {
+    delete(keyNodeEntryOrRaw) {
       const deletedResult = [];
       if (!this._root) return deletedResult;
-      const curr = this.getNode(keyOrNodeOrEntryOrRawOrPredicate);
+      const curr = this.getNode(keyNodeEntryOrRaw);
       if (!curr) return deletedResult;
       const parent = curr == null ? void 0 : curr.parent;
       let needBalanced;
@@ -7325,6 +7344,7 @@ var dataStructureTyped = (() => {
       }
       this._size = this._size - 1;
       deletedResult.push({ deleted: orgCurrent, needBalanced });
+      if (this._isMapMode && orgCurrent) this._store.delete(orgCurrent.key);
       return deletedResult;
     }
     /**
@@ -7333,12 +7353,12 @@ var dataStructureTyped = (() => {
      *
      * The function `getNodes` retrieves nodes from a binary tree based on a key, node, entry, raw data,
      * or predicate, with options for recursive or iterative traversal.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrNodeOrEntryOrRawOrPredicate
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
      * - The `getNodes` function you provided takes several parameters:
      * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` function is a boolean flag that
      * determines whether to return only the first node that matches the criteria specified by the
-     * `keyOrNodeOrEntryOrRawOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * `keyNodeEntryRawOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `getNodes` function is used to specify the starting point for traversing the binary tree. It
      * represents the root node of the binary tree or the node from which the traversal should begin. If
      * not provided, the default value is set to `this._root
@@ -7348,12 +7368,12 @@ var dataStructureTyped = (() => {
      * @returns The `getNodes` function returns an array of nodes that satisfy the provided condition
      * based on the input parameters and the iteration type specified.
      */
-    getNodes(keyOrNodeOrEntryOrRawOrPredicate, onlyOne = false, beginRoot = this._root, iterationType = this.iterationType) {
-      if (keyOrNodeOrEntryOrRawOrPredicate === void 0) return [];
-      if (keyOrNodeOrEntryOrRawOrPredicate === null) return [];
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot) return [];
-      const callback = this._ensurePredicate(keyOrNodeOrEntryOrRawOrPredicate);
+    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+      if (keyNodeEntryRawOrPredicate === void 0) return [];
+      if (keyNodeEntryRawOrPredicate === null) return [];
+      startNode = this.ensureNode(startNode);
+      if (!startNode) return [];
+      const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
       const ans = [];
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
@@ -7365,9 +7385,9 @@ var dataStructureTyped = (() => {
           if (this.isRealNode(cur.left)) dfs(cur.left);
           if (this.isRealNode(cur.right)) dfs(cur.right);
         };
-        dfs(beginRoot);
+        dfs(startNode);
       } else {
-        const stack = [beginRoot];
+        const stack = [startNode];
         while (stack.length > 0) {
           const cur = stack.pop();
           if (this.isRealNode(cur)) {
@@ -7388,10 +7408,10 @@ var dataStructureTyped = (() => {
      *
      * The `getNode` function retrieves a node based on the provided key, node, entry, raw data, or
      * predicate.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrNodeOrEntryOrRawOrPredicate
-     * - The `keyOrNodeOrEntryOrRawOrPredicate` parameter in the `getNode` function can accept a key,
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
+     * - The `keyNodeEntryRawOrPredicate` parameter in the `getNode` function can accept a key,
      * node, entry, raw data, or a predicate function.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `getNode` function is used to specify the starting point for searching for a node in a binary
      * tree. If no specific starting point is provided, the default value is set to `this._root`, which
      * is typically the root node of the binary tree.
@@ -7402,9 +7422,9 @@ var dataStructureTyped = (() => {
      * @returns The `getNode` function is returning the first node that matches the specified criteria,
      * or `null` if no matching node is found.
      */
-    getNode(keyOrNodeOrEntryOrRawOrPredicate, beginRoot = this._root, iterationType = this.iterationType) {
+    getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
       var _a;
-      return (_a = this.getNodes(keyOrNodeOrEntryOrRawOrPredicate, true, beginRoot, iterationType)[0]) != null ? _a : null;
+      return (_a = this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0]) != null ? _a : null;
     }
     /**
      * Time Complexity: O(n)
@@ -7417,7 +7437,7 @@ var dataStructureTyped = (() => {
      * specifies how the tree nodes should be traversed when searching for a node with the given key. It
      * is an optional parameter with a default value of `this.iterationType`.
      * @returns The `getNodeByKey` function is returning an optional binary tree node
-     * (`OptBTNOrNull<NODE>`).
+     * (`OptNodeOrNull<NODE>`).
      */
     getNodeByKey(key, iterationType = this.iterationType) {
       return this.getNode(key, this._root, iterationType);
@@ -7428,10 +7448,10 @@ var dataStructureTyped = (() => {
      *
      * This function overrides the `get` method to retrieve the value associated with a specified key,
      * node, entry, raw data, or predicate in a data structure.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrNodeOrEntryOrRawOrPredicate
-     * - The `keyOrNodeOrEntryOrRawOrPredicate` parameter in the `get` method can accept one of the
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
+     * - The `keyNodeEntryRawOrPredicate` parameter in the `get` method can accept one of the
      * following types:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `get`
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `get`
      * method is used to specify the starting point for searching for a key or node in the binary tree.
      * If no specific starting point is provided, the default starting point is the root of the binary
      * tree (`this._root`).
@@ -7444,9 +7464,14 @@ var dataStructureTyped = (() => {
      * the method returns the corresponding value. If the key or node is not found, it returns
      * `undefined`.
      */
-    get(keyOrNodeOrEntryOrRawOrPredicate, beginRoot = this._root, iterationType = this.iterationType) {
+    get(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
       var _a;
-      return (_a = this.getNode(keyOrNodeOrEntryOrRawOrPredicate, beginRoot, iterationType)) == null ? void 0 : _a.value;
+      if (this._isMapMode) {
+        const key = this._getKey(keyNodeEntryRawOrPredicate);
+        if (key === null || key === void 0) return;
+        return this._store.get(key);
+      }
+      return (_a = this.getNode(keyNodeEntryRawOrPredicate, startNode, iterationType)) == null ? void 0 : _a.value;
     }
     /**
      * Time Complexity: O(n)
@@ -7454,10 +7479,10 @@ var dataStructureTyped = (() => {
      *
      * The `has` function in TypeScript checks if a specified key, node, entry, raw data, or predicate
      * exists in the data structure.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrNodeOrEntryOrRawOrPredicate
-     * - The `keyOrNodeOrEntryOrRawOrPredicate` parameter in the `override has` method can accept one of
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
+     * - The `keyNodeEntryRawOrPredicate` parameter in the `override has` method can accept one of
      * the following types:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `override` method is used to specify the starting point for the search operation within the data
      * structure. It defaults to `this._root` if not provided explicitly.
      * @param {IterationType} iterationType - The `iterationType` parameter in the `override has` method
@@ -7469,8 +7494,8 @@ var dataStructureTyped = (() => {
      * are matching nodes, it returns `true`, indicating that the tree contains the specified element.
      * Otherwise, it returns `false`.
      */
-    has(keyOrNodeOrEntryOrRawOrPredicate, beginRoot = this._root, iterationType = this.iterationType) {
-      return this.getNodes(keyOrNodeOrEntryOrRawOrPredicate, true, beginRoot, iterationType).length > 0;
+    has(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+      return this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType).length > 0;
     }
     /**
      * Time Complexity: O(1)
@@ -7479,8 +7504,8 @@ var dataStructureTyped = (() => {
      * The `clear` function resets the root node and size of a data structure to empty.
      */
     clear() {
-      this._setRoot(void 0);
-      this._size = 0;
+      this._clearNodes();
+      if (this._isMapMode) this._clearValues();
     }
     /**
      * Time Complexity: O(1)
@@ -7500,17 +7525,17 @@ var dataStructureTyped = (() => {
      *
      * The function checks if a binary tree is perfectly balanced by comparing its minimum height with
      * its height.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
      * point for checking if the binary tree is perfectly balanced. It represents the root node of the
      * binary tree or a specific node from which the balance check should begin.
      * @returns The method `isPerfectlyBalanced` is returning a boolean value, which indicates whether
-     * the tree starting from the `beginRoot` node is perfectly balanced or not. The return value is
+     * the tree starting from the `startNode` node is perfectly balanced or not. The return value is
      * determined by comparing the minimum height of the tree with the height of the tree. If the minimum
      * height plus 1 is greater than or equal to the height of the tree, then it is considered perfectly
      * balanced and
      */
-    isPerfectlyBalanced(beginRoot = this._root) {
-      return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
+    isPerfectlyBalanced(startNode = this._root) {
+      return this.getMinHeight(startNode) + 1 >= this.getHeight(startNode);
     }
     /**
      * Time Complexity: O(n)
@@ -7518,7 +7543,7 @@ var dataStructureTyped = (() => {
      *
      * The function `isBST` in TypeScript checks if a binary search tree is valid using either recursive
      * or iterative methods.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `isBST`
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `isBST`
      * function represents the starting point for checking whether a binary search tree (BST) is valid.
      * It can be a node in the BST or a reference to the root of the BST. If no specific node is
      * provided, the function will default to
@@ -7530,9 +7555,9 @@ var dataStructureTyped = (() => {
      * the tree satisfies the BST property, where for every node, all nodes in its left subtree have keys
      * less than the node's key, and all nodes in its right subtree have keys greater than the node's
      */
-    isBST(beginRoot = this._root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot) return true;
+    isBST(startNode = this._root, iterationType = this.iterationType) {
+      startNode = this.ensureNode(startNode);
+      if (!startNode) return true;
       if (iterationType === "RECURSIVE") {
         const dfs = (cur, min, max) => {
           if (!this.isRealNode(cur)) return true;
@@ -7540,14 +7565,14 @@ var dataStructureTyped = (() => {
           if (numKey <= min || numKey >= max) return false;
           return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
         };
-        const isStandardBST = dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-        const isInverseBST = dfs(beginRoot, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
+        const isStandardBST = dfs(startNode, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+        const isInverseBST = dfs(startNode, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
         return isStandardBST || isInverseBST;
       } else {
         const checkBST = (checkMax = false) => {
           const stack = [];
           let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
-          let curr = beginRoot;
+          let curr = startNode;
           while (this.isRealNode(curr) || stack.length > 0) {
             while (this.isRealNode(curr)) {
               stack.push(curr);
@@ -7570,20 +7595,20 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `getDepth` function calculates the depth between two nodes in a binary tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} dist - The `dist` parameter in the `getDepth`
+     * @param {BTNRep<K, V, NODE> | R} dist - The `dist` parameter in the `getDepth`
      * function represents the node or entry in a binary tree map, or a reference to a node in the tree.
-     * It is the target node for which you want to calculate the depth from the `beginRoot` node.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * It is the target node for which you want to calculate the depth from the `startNode` node.
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `getDepth` function represents the starting point from which you want to calculate the depth of a
      * given node or entry in a binary tree. If no specific starting point is provided, the default value
-     * for `beginRoot` is set to the root of the binary
+     * for `startNode` is set to the root of the binary
      * @returns The `getDepth` method returns the depth of a given node `dist` relative to the
-     * `beginRoot` node in a binary tree. If the `dist` node is not found in the path to the `beginRoot`
+     * `startNode` node in a binary tree. If the `dist` node is not found in the path to the `startNode`
      * node, it returns the depth of the `dist` node from the root of the tree.
      */
-    getDepth(dist, beginRoot = this._root) {
+    getDepth(dist, startNode = this._root) {
       let distEnsured = this.ensureNode(dist);
-      const beginRootEnsured = this.ensureNode(beginRoot);
+      const beginRootEnsured = this.ensureNode(startNode);
       let depth = 0;
       while (distEnsured == null ? void 0 : distEnsured.parent) {
         if (distEnsured === beginRootEnsured) {
@@ -7600,7 +7625,7 @@ var dataStructureTyped = (() => {
      *
      * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
      * or iterative approach in TypeScript.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
      * point from which the height of the binary tree will be calculated. It can be a node in the binary
      * tree or a reference to the root of the tree. If not provided, it defaults to the root of the
      * binary tree data structure.
@@ -7611,9 +7636,9 @@ var dataStructureTyped = (() => {
      * root node. The height is calculated based on the maximum depth of the tree, considering either a
      * recursive approach or an iterative approach depending on the `iterationType` parameter.
      */
-    getHeight(beginRoot = this._root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNode(beginRoot);
-      if (!this.isRealNode(beginRoot)) return -1;
+    getHeight(startNode = this._root, iterationType = this.iterationType) {
+      startNode = this.ensureNode(startNode);
+      if (!this.isRealNode(startNode)) return -1;
       if (iterationType === "RECURSIVE") {
         const _getMaxHeight = (cur) => {
           if (!this.isRealNode(cur)) return -1;
@@ -7621,9 +7646,9 @@ var dataStructureTyped = (() => {
           const rightHeight = _getMaxHeight(cur.right);
           return Math.max(leftHeight, rightHeight) + 1;
         };
-        return _getMaxHeight(beginRoot);
+        return _getMaxHeight(startNode);
       } else {
-        const stack = [{ node: beginRoot, depth: 0 }];
+        const stack = [{ node: startNode, depth: 0 }];
         let maxHeight = 0;
         while (stack.length > 0) {
           const { node, depth } = stack.pop();
@@ -7640,7 +7665,7 @@ var dataStructureTyped = (() => {
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach in TypeScript.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `getMinHeight` function represents the starting node from which the minimum height of the binary
      * tree will be calculated. It is either a node in the binary tree or a reference to the root of the
      * tree. If not provided, the default value is the root
@@ -7652,9 +7677,9 @@ var dataStructureTyped = (() => {
      * leaf node in the tree. The method uses either a recursive approach or an iterative approach (using
      * a stack) based on the `iterationType` parameter.
      */
-    getMinHeight(beginRoot = this._root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot) return -1;
+    getMinHeight(startNode = this._root, iterationType = this.iterationType) {
+      startNode = this.ensureNode(startNode);
+      if (!startNode) return -1;
       if (iterationType === "RECURSIVE") {
         const _getMinHeight = (cur) => {
           if (!this.isRealNode(cur)) return 0;
@@ -7663,10 +7688,10 @@ var dataStructureTyped = (() => {
           const rightMinHeight = _getMinHeight(cur.right);
           return Math.min(leftMinHeight, rightMinHeight) + 1;
         };
-        return _getMinHeight(beginRoot);
+        return _getMinHeight(startNode);
       } else {
         const stack = [];
-        let node = beginRoot, last = null;
+        let node = startNode, last = null;
         const depths = /* @__PURE__ */ new Map();
         while (stack.length > 0 || node) {
           if (this.isRealNode(node)) {
@@ -7686,7 +7711,7 @@ var dataStructureTyped = (() => {
             } else node = node.right;
           }
         }
-        return depths.get(beginRoot);
+        return depths.get(startNode);
       }
     }
     /**
@@ -7699,7 +7724,7 @@ var dataStructureTyped = (() => {
      * the path to the root. It is expected to be a function that takes a node as an argument and returns
      * a value based on that node. The return type of the callback function is determined by the generic
      * type `C
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginNode - The `beginNode` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} beginNode - The `beginNode` parameter in the
      * `getPathToRoot` function can be either a key, a node, an entry, or any other value of type `R`.
      * @param [isReverse=true] - The `isReverse` parameter in the `getPathToRoot` function determines
      * whether the resulting path from the given `beginNode` to the root should be in reverse order or
@@ -7709,7 +7734,7 @@ var dataStructureTyped = (() => {
      * array is either in reverse order or in the original order based on the value of the `isReverse`
      * parameter.
      */
-    getPathToRoot(callback = this._DEFAULT_BTN_CALLBACK, beginNode, isReverse = true) {
+    getPathToRoot(callback = this._DEFAULT_NODE_CALLBACK, beginNode, isReverse = true) {
       const result = [];
       let beginNodeEnsured = this.ensureNode(beginNode);
       if (!beginNodeEnsured) return result;
@@ -7728,8 +7753,8 @@ var dataStructureTyped = (() => {
      * tail-recursive iteration.
      * @param {C} callback - The `callback` parameter is a function that will be called with the leftmost
      * node of a binary tree or with `undefined` if the tree is empty. It is provided with a default
-     * value of `_DEFAULT_BTN_CALLBACK` if not specified.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * value of `_DEFAULT_NODE_CALLBACK` if not specified.
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `getLeftMost` function represents the starting point for finding the leftmost node in a binary
      * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
      * starting point is provided, the function will default
@@ -7737,26 +7762,26 @@ var dataStructureTyped = (() => {
      * specifies the type of iteration to be used when traversing the binary tree nodes. It can have two
      * possible values:
      * @returns The `getLeftMost` function returns the result of the callback function `C` applied to the
-     * leftmost node in the binary tree starting from the `beginRoot` node. If the `beginRoot` node is
-     * `NIL`, it returns the result of the callback function applied to `undefined`. If the `beginRoot`
+     * leftmost node in the binary tree starting from the `startNode` node. If the `startNode` node is
+     * `NIL`, it returns the result of the callback function applied to `undefined`. If the `startNode`
      * node is not a real node, it returns the result of the callback
      */
-    getLeftMost(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-      if (this.isNIL(beginRoot)) return callback(void 0);
-      beginRoot = this.ensureNode(beginRoot);
-      if (!this.isRealNode(beginRoot)) return callback(beginRoot);
+    getLeftMost(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+      if (this.isNIL(startNode)) return callback(void 0);
+      startNode = this.ensureNode(startNode);
+      if (!this.isRealNode(startNode)) return callback(startNode);
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
           if (!this.isRealNode(cur.left)) return cur;
           return dfs(cur.left);
         };
-        return callback(dfs(beginRoot));
+        return callback(dfs(startNode));
       } else {
         const dfs = trampoline((cur) => {
           if (!this.isRealNode(cur.left)) return cur;
           return dfs.cont(cur.left);
         });
-        return callback(dfs(beginRoot));
+        return callback(dfs(startNode));
       }
     }
     /**
@@ -7766,10 +7791,10 @@ var dataStructureTyped = (() => {
      * The function `getRightMost` retrieves the rightmost node in a binary tree using either recursive
      * or iterative traversal methods.
      * @param {C} callback - The `callback` parameter is a function that will be called with the result
-     * of finding the rightmost node in a binary tree. It is of type `BTNCallback<OptBTNOrNull<NODE>>`,
+     * of finding the rightmost node in a binary tree. It is of type `NodeCallback<OptNodeOrNull<NODE>>`,
      * which means it is a callback function that can accept either an optional binary tree node or null
      * as
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `getRightMost` function represents the starting point for finding the rightmost node in a binary
      * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
      * starting point is provided, the function will default
@@ -7781,22 +7806,22 @@ var dataStructureTyped = (() => {
      * the binary tree structure, determined based on the specified iteration type ('RECURSIVE' or
      * other).
      */
-    getRightMost(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-      if (this.isNIL(beginRoot)) return callback(void 0);
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot) return callback(beginRoot);
+    getRightMost(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+      if (this.isNIL(startNode)) return callback(void 0);
+      startNode = this.ensureNode(startNode);
+      if (!startNode) return callback(startNode);
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
           if (!this.isRealNode(cur.right)) return cur;
           return dfs(cur.right);
         };
-        return callback(dfs(beginRoot));
+        return callback(dfs(startNode));
       } else {
         const dfs = trampoline((cur) => {
           if (!this.isRealNode(cur.right)) return cur;
           return dfs.cont(cur.right);
         });
-        return callback(dfs(beginRoot));
+        return callback(dfs(startNode));
       }
     }
     /**
@@ -7858,14 +7883,14 @@ var dataStructureTyped = (() => {
      * The function `dfs` performs a depth-first search traversal on a binary tree structure based on the
      * specified parameters.
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends the
-     * `BTNCallback` interface with a type parameter of `OptBTNOrNull<NODE>`. It has a default value of
-     * `this._DEFAULT_BTN_CALLBACK as C`.
+     * `NodeCallback` interface with a type parameter of `OptNodeOrNull<NODE>`. It has a default value of
+     * `this._DEFAULT_NODE_CALLBACK as C`.
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `dfs` method specifies the
      * order in which the Depth-First Search (DFS) algorithm should traverse the nodes in the tree. The
      * possible values for the `pattern` parameter are:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `dfs`
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `dfs`
      * method is used to specify the starting point for the Depth-First Search traversal. It can be
-     * either a `BTNKeyOrNodeOrEntry` object representing a key, node, or entry in the binary tree map,
+     * either a `BTNRep` object representing a key, node, or entry in the binary tree map,
      * or it can be a
      * @param {IterationType} iterationType - The `iterationType` parameter in the `dfs` method specifies
      * the type of iteration to be performed during the depth-first search traversal. It is used to
@@ -7877,10 +7902,10 @@ var dataStructureTyped = (() => {
      * @returns The `dfs` method is returning an array of the return type specified by the generic type
      * parameter `C`. The return type is determined by the callback function provided to the method.
      */
-    dfs(callback = this._DEFAULT_BTN_CALLBACK, pattern = "IN", beginRoot = this._root, iterationType = this.iterationType, includeNull = false) {
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot) return [];
-      return this._dfs(callback, pattern, beginRoot, iterationType, includeNull);
+    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", startNode = this._root, iterationType = this.iterationType, includeNull = false) {
+      startNode = this.ensureNode(startNode);
+      if (!startNode) return [];
+      return this._dfs(callback, pattern, startNode, iterationType, includeNull);
     }
     /**
      * Time complexity: O(n)
@@ -7890,8 +7915,8 @@ var dataStructureTyped = (() => {
      * tree, executing a specified callback function on each node visited.
      * @param {C} callback - The `callback` parameter in the `bfs` function is a function that will be
      * called on each node visited during the breadth-first search traversal. It is a generic type `C`
-     * that extends the `BTNCallback` type, which takes a parameter of type `NODE` or `null`.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `bfs`
+     * that extends the `NodeCallback` type, which takes a parameter of type `NODE` or `null`.
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `bfs`
      * function represents the starting point for the breadth-first search traversal in a binary tree. It
      * can be specified as a key, node, or entry in the binary tree structure. If not provided, the
      * default value is the root node of the binary
@@ -7905,12 +7930,12 @@ var dataStructureTyped = (() => {
      * @returns The `bfs` function returns an array of values that are the result of applying the
      * provided callback function to each node in the binary tree in a breadth-first search manner.
      */
-    bfs(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType, includeNull = false) {
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot) return [];
+    bfs(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
+      startNode = this.ensureNode(startNode);
+      if (!startNode) return [];
       const ans = [];
       if (iterationType === "RECURSIVE") {
-        const queue = new Queue([beginRoot]);
+        const queue = new Queue([startNode]);
         const dfs = (level) => {
           if (queue.size === 0) return;
           const current = queue.shift();
@@ -7926,7 +7951,7 @@ var dataStructureTyped = (() => {
         };
         dfs(0);
       } else {
-        const queue = new Queue([beginRoot]);
+        const queue = new Queue([startNode]);
         while (queue.size > 0) {
           const levelSize = queue.size;
           for (let i = 0; i < levelSize; i++) {
@@ -7952,7 +7977,7 @@ var dataStructureTyped = (() => {
      * structure based on a specified callback and iteration type.
      * @param {C} callback - The `callback` parameter is a function that will be called on each leaf node
      * in the binary tree. It is optional and defaults to a default callback function if not provided.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `leaves`
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `leaves`
      * method is used to specify the starting point for finding and processing the leaves of a binary
      * tree. It can be provided as either a key, a node, or an entry in the binary tree structure. If not
      * explicitly provided, the default value
@@ -7962,10 +7987,10 @@ var dataStructureTyped = (() => {
      * @returns The `leaves` method returns an array of values that are the result of applying the
      * provided callback function to each leaf node in the binary tree.
      */
-    leaves(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNode(beginRoot);
+    leaves(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+      startNode = this.ensureNode(startNode);
       const leaves = [];
-      if (!this.isRealNode(beginRoot)) return [];
+      if (!this.isRealNode(startNode)) return [];
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
           if (this.isLeaf(cur)) {
@@ -7975,9 +8000,9 @@ var dataStructureTyped = (() => {
           if (this.isRealNode(cur.left)) dfs(cur.left);
           if (this.isRealNode(cur.right)) dfs(cur.right);
         };
-        dfs(beginRoot);
+        dfs(startNode);
       } else {
-        const queue = new Queue([beginRoot]);
+        const queue = new Queue([startNode]);
         while (queue.size > 0) {
           const cur = queue.shift();
           if (this.isRealNode(cur)) {
@@ -8000,7 +8025,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be applied to each node in
      * the binary tree during the traversal. It is used to process each node and determine what
      * information to include in the output for each level of the tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `listLevels` function represents the starting point for traversing the binary tree. It can be
      * either a key, a node, or an entry in the binary tree. If not provided, the default value is the
      * root of the binary tree.
@@ -8015,10 +8040,10 @@ var dataStructureTyped = (() => {
      * level in a binary tree. Each inner array contains the return value of the provided callback
      * function applied to the nodes at that level.
      */
-    listLevels(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType, includeNull = false) {
-      beginRoot = this.ensureNode(beginRoot);
+    listLevels(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
+      startNode = this.ensureNode(startNode);
       const levelsNodes = [];
-      if (!beginRoot) return levelsNodes;
+      if (!startNode) return levelsNodes;
       if (iterationType === "RECURSIVE") {
         const _recursive = (node, level) => {
           if (!levelsNodes[level]) levelsNodes[level] = [];
@@ -8031,9 +8056,9 @@ var dataStructureTyped = (() => {
             if (node && node.right) _recursive(node.right, level + 1);
           }
         };
-        _recursive(beginRoot, 0);
+        _recursive(startNode, 0);
       } else {
-        const stack = [[beginRoot, 0]];
+        const stack = [[startNode, 0]];
         while (stack.length > 0) {
           const head = stack.pop();
           const [node, level] = head;
@@ -8058,11 +8083,11 @@ var dataStructureTyped = (() => {
      * Morris Traversal algorithm with different order patterns.
      * @param {C} callback - The `callback` parameter in the `morris` function is a function that will be
      * called on each node in the binary tree during the traversal. It is of type `C`, which extends the
-     * `BTNCallback<NODE>` type. The default value for `callback` is `this._DEFAULT
+     * `NodeCallback<NODE>` type. The default value for `callback` is `this._DEFAULT
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `morris` function specifies
      * the type of Depth-First Search (DFS) order pattern to traverse the binary tree. The possible
      * values for the `pattern` parameter are:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `morris`
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `morris`
      * function is the starting point for the Morris traversal algorithm. It represents the root node of
      * the binary tree or the node from which the traversal should begin. It can be provided as either a
      * key, a node, an entry, or a reference
@@ -8070,11 +8095,11 @@ var dataStructureTyped = (() => {
      * provided callback function to each node in the binary tree in the specified order pattern (IN,
      * PRE, or POST).
      */
-    morris(callback = this._DEFAULT_BTN_CALLBACK, pattern = "IN", beginRoot = this._root) {
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot) return [];
+    morris(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", startNode = this._root) {
+      startNode = this.ensureNode(startNode);
+      if (!startNode) return [];
       const ans = [];
-      let cur = beginRoot;
+      let cur = startNode;
       const _reverseEdge = (node) => {
         let pre = null;
         let next = null;
@@ -8145,7 +8170,7 @@ var dataStructureTyped = (() => {
             }
             cur = cur.right;
           }
-          _printEdge(beginRoot);
+          _printEdge(startNode);
           break;
       }
       return ans;
@@ -8166,12 +8191,16 @@ var dataStructureTyped = (() => {
       this.bfs(
         (node) => {
           if (node === null) cloned.add(null);
-          else cloned.add([node.key, node.value]);
+          else {
+            if (this._isMapMode) cloned.add([node.key, this._store.get(node.key)]);
+            else cloned.add([node.key, node.value]);
+          }
         },
         this._root,
         this.iterationType,
         true
       );
+      if (this._isMapMode) cloned._store = this._store;
       return cloned;
     }
     /**
@@ -8238,7 +8267,7 @@ var dataStructureTyped = (() => {
      *
      * The function `toVisual` in TypeScript overrides the visual representation of a binary tree with
      * customizable options for displaying undefined, null, and sentinel nodes.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `toVisual` method is used to specify the starting point for visualizing the binary tree structure.
      * It can be a node, key, entry, or the root of the tree. If no specific starting point is provided,
      * the default is set to the root
@@ -8250,20 +8279,17 @@ var dataStructureTyped = (() => {
      * the lines to the output string. The final output string contains the visual representation of the
      * binary tree with the specified options.
      */
-    toVisual(beginRoot = this._root, options) {
-      const opts = __spreadValues({ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false }, options);
-      beginRoot = this.ensureNode(beginRoot);
+    toVisual(startNode = this._root, options) {
+      const opts = __spreadValues({ isShowUndefined: false, isShowNull: true, isShowRedBlackNIL: false }, options);
+      startNode = this.ensureNode(startNode);
       let output = "";
-      if (!beginRoot) return output;
-      if (opts.isShowUndefined)
-        output += `U for undefined
-      `;
-      if (opts.isShowNull)
-        output += `N for null
-      `;
-      if (opts.isShowRedBlackNIL)
-        output += `S for Sentinel Node(NIL)
-      `;
+      if (!startNode) return output;
+      if (opts.isShowUndefined) output += `U for undefined
+`;
+      if (opts.isShowNull) output += `N for null
+`;
+      if (opts.isShowRedBlackNIL) output += `S for Sentinel Node(NIL)
+`;
       const display = (root) => {
         const [lines, , ,] = this._displayAux(root, opts);
         let paragraph = "";
@@ -8272,9 +8298,27 @@ var dataStructureTyped = (() => {
         }
         output += paragraph;
       };
-      display(beginRoot);
+      display(startNode);
       return output;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `print` in TypeScript overrides the default print behavior to log a visual
+     * representation of the binary tree to the console.
+     * @param {BinaryTreePrintOptions} [options] - The `options` parameter is used to specify the
+     * printing options for the binary tree. It is an optional parameter that allows you to customize how
+     * the binary tree is printed, such as choosing between different traversal orders or formatting
+     * options.
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * `override print` method is used to specify the starting point for printing the binary tree. It can
+     * be either a key, a node, an entry, or the root of the tree. If no specific starting point is
+     * provided, the default value is set to
+     */
+    print(options, startNode = this._root) {
+      console.log(this.toVisual(startNode, options));
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -8283,13 +8327,13 @@ var dataStructureTyped = (() => {
      * the specified order pattern and callback function.
      * @param {C} callback - The `callback` parameter in the `_dfs` method is a function that will be
      * called on each node visited during the depth-first search traversal. It is of type `C`, which
-     * extends `BTNCallback<OptBTNOrNull<NODE>>`. The default value for this parameter is `this._DEFAULT
+     * extends `NodeCallback<OptNodeOrNull<NODE>>`. The default value for this parameter is `this._DEFAULT
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `_dfs` method specifies the
      * order in which the nodes are visited during the Depth-First Search traversal. It can have one of
      * the following values:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the `_dfs`
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `_dfs`
      * method is used to specify the starting point for the depth-first search traversal in a binary
-     * tree. It can be provided as either a `BTNKeyOrNodeOrEntry` object or a reference to the root node
+     * tree. It can be provided as either a `BTNRep` object or a reference to the root node
      * of the tree. If no specific
      * @param {IterationType} iterationType - The `iterationType` parameter in the `_dfs` method
      * specifies the type of iteration to be performed during the Depth-First Search (DFS) traversal of a
@@ -8317,12 +8361,12 @@ var dataStructureTyped = (() => {
      * @returns The function `_dfs` returns an array of the return type of the callback function provided
      * as input.
      */
-    _dfs(callback = this._DEFAULT_BTN_CALLBACK, pattern = "IN", beginRoot = this._root, iterationType = this.iterationType, includeNull = false, shouldVisitLeft = (node) => !!node, shouldVisitRight = (node) => !!node, shouldVisitRoot = (node) => {
+    _dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", startNode = this._root, iterationType = this.iterationType, includeNull = false, shouldVisitLeft = (node) => !!node, shouldVisitRight = (node) => !!node, shouldVisitRoot = (node) => {
       if (includeNull) return this.isRealNodeOrNull(node);
       return this.isRealNode(node);
     }, shouldProcessRoot = (node) => this.isRealNodeOrNull(node)) {
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot) return [];
+      startNode = this.ensureNode(startNode);
+      if (!startNode) return [];
       const ans = [];
       if (iterationType === "RECURSIVE") {
         const dfs = (node) => {
@@ -8351,9 +8395,9 @@ var dataStructureTyped = (() => {
               break;
           }
         };
-        dfs(beginRoot);
+        dfs(startNode);
       } else {
-        const stack = [{ opt: 0 /* VISIT */, node: beginRoot }];
+        const stack = [{ opt: 0 /* VISIT */, node: startNode }];
         const pushLeft = (cur) => {
           var _a;
           if (shouldVisitLeft(cur.node)) stack.push({ opt: 0 /* VISIT */, node: (_a = cur.node) == null ? void 0 : _a.left });
@@ -8421,7 +8465,8 @@ var dataStructureTyped = (() => {
           }
           current = stack.pop();
           if (this.isRealNode(current)) {
-            yield [current.key, current.value];
+            if (this._isMapMode) yield [current.key, this._store.get(current.key)];
+            else yield [current.key, current.value];
             current = current.right;
           }
         }
@@ -8429,7 +8474,8 @@ var dataStructureTyped = (() => {
         if (node.left && this.isRealNode(node)) {
           yield* __yieldStar(this[Symbol.iterator](node.left));
         }
-        yield [node.key, node.value];
+        if (this._isMapMode) yield [node.key, this._store.get(node.key)];
+        else yield [node.key, node.value];
         if (node.right && this.isRealNode(node)) {
           yield* __yieldStar(this[Symbol.iterator](node.right));
         }
@@ -8495,12 +8541,12 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The _swapProperties function swaps key and value properties between two nodes in a binary tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} srcNode - The `srcNode` parameter in the
-     * `_swapProperties` method can be either a BTNKeyOrNodeOrEntry object containing key and value
+     * @param {BTNRep<K, V, NODE> | R} srcNode - The `srcNode` parameter in the
+     * `_swapProperties` method can be either a BTNRep object containing key and value
      * properties, or it can be of type R.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} destNode - The `destNode` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} destNode - The `destNode` parameter in the
      * `_swapProperties` method represents the node or entry where the properties will be swapped with
-     * the `srcNode`. It can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>` or `R`. The method ensures that
+     * the `srcNode`. It can be of type `BTNRep<K, V, NODE>` or `R`. The method ensures that
      * both `srcNode
      * @returns The `_swapProperties` method returns either the `destNode` with its key and value swapped
      * with the `srcNode`, or `undefined` if either `srcNode` or `destNode` is falsy.
@@ -8513,9 +8559,9 @@ var dataStructureTyped = (() => {
         const tempNode = this.createNode(key, value);
         if (tempNode) {
           destNode.key = srcNode.key;
-          destNode.value = srcNode.value;
+          if (!this._isMapMode) destNode.value = srcNode.value;
           srcNode.key = tempNode.key;
-          srcNode.value = tempNode.value;
+          if (!this._isMapMode) srcNode.value = tempNode.value;
         }
         return destNode;
       }
@@ -8557,7 +8603,7 @@ var dataStructureTyped = (() => {
      *
      * The function _setRoot sets the root node of a data structure while updating the parent reference
      * of the previous root node.
-     * @param v - The parameter `v` in the `_setRoot` method is of type `OptBTNOrNull<NODE>`, which means
+     * @param v - The parameter `v` in the `_setRoot` method is of type `OptNodeOrNull<NODE>`, which means
      * it can either be an optional `NODE` type or `null`.
      */
     _setRoot(v) {
@@ -8572,43 +8618,103 @@ var dataStructureTyped = (() => {
      *
      * The function `_ensurePredicate` in TypeScript ensures that the input is converted into a valid
      * predicate function for a binary tree node.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} keyOrEntryOrRawOrPredicate - The
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
      * `_ensurePredicate` method in the provided code snippet is responsible for ensuring that the input
-     * parameter `keyOrEntryOrRawOrPredicate` is transformed into a valid predicate function that can be
+     * parameter `keyNodeEntryRawOrPredicate` is transformed into a valid predicate function that can be
      * used for filtering nodes in a binary tree.
-     * @returns A BTNPredicate<NODE> function is being returned.
+     * @returns A NodePredicate<NODE> function is being returned.
      */
-    _ensurePredicate(keyOrEntryOrRawOrPredicate) {
-      if (keyOrEntryOrRawOrPredicate === null || keyOrEntryOrRawOrPredicate === void 0)
+    _ensurePredicate(keyNodeEntryRawOrPredicate) {
+      if (keyNodeEntryRawOrPredicate === null || keyNodeEntryRawOrPredicate === void 0)
         return (node) => node ? false : false;
-      if (this._isPredicated(keyOrEntryOrRawOrPredicate)) return keyOrEntryOrRawOrPredicate;
-      if (this.isRealNode(keyOrEntryOrRawOrPredicate)) return (node) => node === keyOrEntryOrRawOrPredicate;
-      if (this.isEntry(keyOrEntryOrRawOrPredicate)) {
-        const [key] = keyOrEntryOrRawOrPredicate;
+      if (this._isPredicate(keyNodeEntryRawOrPredicate)) return keyNodeEntryRawOrPredicate;
+      if (this.isRealNode(keyNodeEntryRawOrPredicate)) return (node) => node === keyNodeEntryRawOrPredicate;
+      if (this.isEntry(keyNodeEntryRawOrPredicate)) {
+        const [key] = keyNodeEntryRawOrPredicate;
         return (node) => node.key === key;
       }
-      if (this.isKey(keyOrEntryOrRawOrPredicate)) return (node) => node.key === keyOrEntryOrRawOrPredicate;
+      if (this.isKey(keyNodeEntryRawOrPredicate)) return (node) => node.key === keyNodeEntryRawOrPredicate;
       if (this._toEntryFn) {
-        const [key] = this._toEntryFn(keyOrEntryOrRawOrPredicate);
+        const [key] = this._toEntryFn(keyNodeEntryRawOrPredicate);
         return (node) => node.key === key;
       }
-      return (node) => node.key === keyOrEntryOrRawOrPredicate;
+      return (node) => node.key === keyNodeEntryRawOrPredicate;
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_isPredicated` checks if a given parameter is a function.
+     * The function `_isPredicate` checks if a given parameter is a function.
      * @param {any} p - The parameter `p` is a variable of type `any`, which means it can hold any type
-     * of value. In this context, the function `_isPredicated` is checking if `p` is a function that
-     * satisfies the type `BTNPredicate<NODE>`.
+     * of value. In this context, the function `_isPredicate` is checking if `p` is a function that
+     * satisfies the type `NodePredicate<NODE>`.
      * @returns The function is checking if the input `p` is a function and returning a boolean value
      * based on that check. If `p` is a function, it will return `true`, indicating that `p` is a
      * predicate function for a binary tree node. If `p` is not a function, it will return `false`.
      */
-    _isPredicated(p) {
+    _isPredicate(p) {
       return typeof p === "function";
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `_getKey` in TypeScript returns the key from a given input, which can be a node,
+     * entry, raw data, or null/undefined.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_getKey` method you provided is a
+     * TypeScript method that takes in a parameter `keyNodeEntryOrRaw` of type `BTNRep<K, V, NODE> | R`,
+     * where `BTNRep` is a generic type with keys `K`, `V`, and `NODE`, and `
+     * @returns The `_getKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
+     * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on
+     * the conditions checked in the method.
+     */
+    _getKey(keyNodeEntryOrRaw) {
+      if (keyNodeEntryOrRaw === null) return null;
+      if (keyNodeEntryOrRaw === void 0) return;
+      if (keyNodeEntryOrRaw === this._NIL) return;
+      if (this.isNode(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw.key;
+      if (this.isEntry(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw[0];
+      if (this.isRaw(keyNodeEntryOrRaw)) {
+        if (this._toEntryFn) {
+          const [key] = this._toEntryFn(keyNodeEntryOrRaw);
+          return key;
+        }
+        return;
+      }
+      return keyNodeEntryOrRaw;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `_setValue` sets a value in a store based on a key, handling cases where the key or
+     * value is null or undefined.
+     * @param {K | null | undefined} key - The `key` parameter can be of type `K`, `null`, or
+     * `undefined`.
+     * @param {V | undefined} value - The `value` parameter in the `_setValue` method can be of type `V`
+     * or `undefined`.
+     * @returns The method `_setValue` returns `false` if either the `key` is `null` or `undefined`, or
+     * if the `value` is `undefined`. Otherwise, it returns the result of calling the `set` method on the
+     * `_store` object with the `key` and `value` arguments.
+     */
+    _setValue(key, value) {
+      if (key === null || key === void 0) return false;
+      if (value === void 0) return false;
+      return this._store.set(key, value);
+    }
+    /**
+     * The _clearNodes function sets the root node to undefined and resets the size to 0.
+     */
+    _clearNodes() {
+      this._setRoot(void 0);
+      this._size = 0;
+    }
+    /**
+     * The _clearValues function clears all values stored in the _store object.
+     */
+    _clearValues() {
+      this._store.clear();
+    }
   };
 
   // src/data-structures/binary-tree/bst.ts
@@ -8631,7 +8737,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function sets the left child of a node and updates the parent reference of the child.
-     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be an
+     * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be an
      * instance of the `NODE` class or `undefined`.
      */
     set left(v) {
@@ -8650,7 +8756,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function sets the right child of a node and updates the parent reference of the child.
-     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be a
+     * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be a
      * `NODE` object or `undefined`.
      */
     set right(v) {
@@ -8663,13 +8769,13 @@ var dataStructureTyped = (() => {
   var BST = class _BST extends BinaryTree {
     /**
      * This is the constructor function for a Binary Search Tree class in TypeScript.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable that can contain either keys, nodes, entries, or raw elements. These elements will be
      * added to the binary search tree during the construction of the object.
      * @param [options] - An optional object that contains additional options for the Binary Search Tree.
      * It can include a comparator function that defines the order of the elements in the tree.
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       __publicField(this, "_root");
       __publicField(this, "_DEFAULT_COMPARATOR", (a, b) => {
@@ -8687,7 +8793,7 @@ var dataStructureTyped = (() => {
         const { comparator } = options;
         if (comparator) this._comparator = comparator;
       }
-      if (keysOrNodesOrEntriesOrRaws) this.addMany(keysOrNodesOrEntriesOrRaws);
+      if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
     }
     /**
      * The function returns the root node of a tree structure.
@@ -8717,22 +8823,24 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _BST([], __spreadValues({
         iterationType: this.iterationType,
+        isMapMode: this._isMapMode,
         comparator: this._comparator,
         toEntryFn: this._toEntryFn
       }, options));
     }
     /**
      * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - A variable that can be of
-     * type R or BTNKeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
+     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
      * element.
      * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
      * value associated with a key in a key-value pair.
      * @returns either a NODE object or undefined.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value) {
-      var _a;
-      return (_a = super.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value)) != null ? _a : void 0;
+    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
+      const [node, tValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+      if (node === null) return [void 0, void 0];
+      return [node, tValue != null ? tValue : value];
     }
     /**
      * Time Complexity: O(log n)
@@ -8740,8 +8848,8 @@ var dataStructureTyped = (() => {
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R`, which represents the key, node,
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept a value of type `R`, which represents the key, node,
      * entry, or raw element that needs to be ensured in the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
      * parameter that specifies the type of iteration to be used when ensuring a node. It has a default
@@ -8749,19 +8857,19 @@ var dataStructureTyped = (() => {
      * @returns The method is returning either the node that was ensured or `undefined` if the node could
      * not be ensured.
      */
-    ensureNode(keyOrNodeOrEntryOrRaw, iterationType = this.iterationType) {
+    ensureNode(keyNodeEntryOrRaw, iterationType = this.iterationType) {
       var _a;
-      return (_a = super.ensureNode(keyOrNodeOrEntryOrRaw, iterationType)) != null ? _a : void 0;
+      return (_a = super.ensureNode(keyNodeEntryOrRaw, iterationType)) != null ? _a : void 0;
     }
     /**
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `BSTNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw) {
-      return keyOrNodeOrEntryOrRaw instanceof BSTNode;
+    isNode(keyNodeEntryOrRaw) {
+      return keyNodeEntryOrRaw instanceof BSTNode;
     }
     /**
      * The function "override isKey" checks if a key is comparable based on a given comparator.
@@ -8779,17 +8887,18 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key in the binary search tree. If provided, it will be stored in the node along with the key.
      * @returns a boolean value.
      */
-    add(keyOrNodeOrEntryOrRaw, value) {
-      const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value);
+    add(keyNodeEntryOrRaw, value) {
+      const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
       if (newNode === void 0) return false;
       if (this._root === void 0) {
         this._setRoot(newNode);
+        if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
         this._size++;
         return true;
       }
@@ -8801,6 +8910,7 @@ var dataStructureTyped = (() => {
         } else if (this.comparator(current.key, newNode.key) > 0) {
           if (current.left === void 0) {
             current.left = newNode;
+            if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
             this._size++;
             return true;
           }
@@ -8808,6 +8918,7 @@ var dataStructureTyped = (() => {
         } else {
           if (current.right === void 0) {
             current.right = newNode;
+            if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
             this._size++;
             return true;
           }
@@ -8822,7 +8933,7 @@ var dataStructureTyped = (() => {
      *
      * The `addMany` function in TypeScript adds multiple keys or nodes to a data structure and returns
      * an array indicating whether each key or node was successfully inserted.
-     * @param keysOrNodesOrEntriesOrRaws - An iterable containing keys, nodes, entries, or raw
+     * @param keysNodesEntriesOrRaws - An iterable containing keys, nodes, entries, or raw
      * elements 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
@@ -8837,30 +8948,27 @@ var dataStructureTyped = (() => {
      * @returns The function `addMany` returns an array of booleans indicating whether each element was
      * successfully inserted into the data structure.
      */
-    addMany(keysOrNodesOrEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
+    addMany(keysNodesEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
       const inserted = [];
       let valuesIterator;
       if (values) {
         valuesIterator = values[Symbol.iterator]();
       }
       if (!isBalanceAdd) {
-        for (const kve of keysOrNodesOrEntriesOrRaws) {
+        for (const kve of keysNodesEntriesOrRaws) {
           const value = valuesIterator == null ? void 0 : valuesIterator.next().value;
-          const nn = this.add(kve, value);
-          inserted.push(nn);
+          inserted.push(this.add(kve, value));
         }
         return inserted;
       }
       const realBTNExemplars = [];
-      const isRealBTNExemplar = (kve) => {
-        if (kve === void 0 || kve === null) return false;
-        return !(this.isEntry(kve) && (kve[0] === void 0 || kve[0] === null));
-      };
-      for (const kve of keysOrNodesOrEntriesOrRaws) {
-        if (isRealBTNExemplar(kve)) realBTNExemplars.push(kve);
+      let i = 0;
+      for (const kve of keysNodesEntriesOrRaws) {
+        realBTNExemplars.push({ key: kve, value: valuesIterator == null ? void 0 : valuesIterator.next().value, orgIndex: i });
+        i++;
       }
       let sorted = [];
-      sorted = realBTNExemplars.sort((a, b) => {
+      sorted = realBTNExemplars.sort(({ key: a }, { key: b }) => {
         let keyA, keyB;
         if (this.isEntry(a)) keyA = a[0];
         else if (this.isRealNode(a)) keyA = a.key;
@@ -8884,8 +8992,8 @@ var dataStructureTyped = (() => {
       const _dfs = (arr) => {
         if (arr.length === 0) return;
         const mid = Math.floor((arr.length - 1) / 2);
-        const newNode = this.add(arr[mid]);
-        inserted.push(newNode);
+        const { key, value, orgIndex } = arr[mid];
+        inserted[orgIndex] = this.add(key, value);
         _dfs(arr.slice(0, mid));
         _dfs(arr.slice(mid + 1));
       };
@@ -8898,8 +9006,8 @@ var dataStructureTyped = (() => {
             const [l, r] = popped;
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
-              const newNode = this.add(sorted[m]);
-              inserted.push(newNode);
+              const { key, value, orgIndex } = sorted[m];
+              inserted[orgIndex] = this.add(key, value);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
             }
@@ -8918,30 +9026,30 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(k + log n)
      *
      * The function `getNodes` in TypeScript overrides the base class method to retrieve nodes based on a
-     * given predicate and iteration type.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * given keyNodeEntryRawOrPredicate and iteration type.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The `keyNodeEntryRawOrPredicate`
      * parameter in the `getNodes` method is used to filter the nodes that will be returned. It can be a
-     * key, a node, an entry, or a custom predicate function that determines whether a node should be
+     * key, a node, an entry, or a custom keyNodeEntryRawOrPredicate function that determines whether a node should be
      * included in the result.
      * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` method is a boolean flag that
-     * determines whether to return only the first node that matches the predicate (`true`) or all nodes
-     * that match the predicate (`false`). If `onlyOne` is set to `true`, the method will stop iterating
+     * determines whether to return only the first node that matches the keyNodeEntryRawOrPredicate (`true`) or all nodes
+     * that match the keyNodeEntryRawOrPredicate (`false`). If `onlyOne` is set to `true`, the method will stop iterating
      * and
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
      * `getNodes` method is used to specify the starting point for traversing the tree when searching for
-     * nodes that match a given predicate. It represents the root node of the subtree where the search
+     * nodes that match a given keyNodeEntryRawOrPredicate. It represents the root node of the subtree where the search
      * should begin. If not explicitly provided, the default value for `begin
      * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` method
      * specifies the type of iteration to be performed when traversing the nodes of a binary tree. It can
      * have two possible values:
-     * @returns The `getNodes` method returns an array of nodes that satisfy the given predicate.
-     */
-    getNodes(predicate, onlyOne = false, beginRoot = this._root, iterationType = this.iterationType) {
-      if (predicate === void 0) return [];
-      if (predicate === null) return [];
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot) return [];
-      const callback = this._ensurePredicate(predicate);
+     * @returns The `getNodes` method returns an array of nodes that satisfy the given keyNodeEntryRawOrPredicate.
+     */
+    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+      if (keyNodeEntryRawOrPredicate === void 0) return [];
+      if (keyNodeEntryRawOrPredicate === null) return [];
+      startNode = this.ensureNode(startNode);
+      if (!startNode) return [];
+      const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
       const ans = [];
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
@@ -8950,26 +9058,32 @@ var dataStructureTyped = (() => {
             if (onlyOne) return;
           }
           if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
-          if (this.isKey(predicate)) {
-            if (this.isRealNode(cur.left) && this.comparator(cur.key, predicate) > 0) dfs(cur.left);
-            if (this.isRealNode(cur.right) && this.comparator(cur.key, predicate) < 0) dfs(cur.right);
+          if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
+            const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
+            if (this.isRealNode(cur.left) && benchmarkKey !== null && benchmarkKey !== void 0 && this.comparator(cur.key, benchmarkKey) > 0)
+              dfs(cur.left);
+            if (this.isRealNode(cur.right) && benchmarkKey !== null && benchmarkKey !== void 0 && this.comparator(cur.key, benchmarkKey) < 0)
+              dfs(cur.right);
           } else {
             if (this.isRealNode(cur.left)) dfs(cur.left);
             if (this.isRealNode(cur.right)) dfs(cur.right);
           }
         };
-        dfs(beginRoot);
+        dfs(startNode);
       } else {
-        const stack = [beginRoot];
+        const stack = [startNode];
         while (stack.length > 0) {
           const cur = stack.pop();
           if (callback(cur)) {
             ans.push(cur);
             if (onlyOne) return ans;
           }
-          if (this.isKey(predicate)) {
-            if (this.isRealNode(cur.right) && this.comparator(cur.key, predicate) < 0) stack.push(cur.right);
-            if (this.isRealNode(cur.left) && this.comparator(cur.key, predicate) > 0) stack.push(cur.left);
+          if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
+            const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
+            if (this.isRealNode(cur.right) && benchmarkKey !== null && benchmarkKey !== void 0 && this.comparator(cur.key, benchmarkKey) < 0)
+              stack.push(cur.right);
+            if (this.isRealNode(cur.left) && benchmarkKey !== null && benchmarkKey !== void 0 && this.comparator(cur.key, benchmarkKey) > 0)
+              stack.push(cur.left);
           } else {
             if (this.isRealNode(cur.right)) stack.push(cur.right);
             if (this.isRealNode(cur.left)) stack.push(cur.left);
@@ -8982,10 +9096,10 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * This function retrieves a node based on a given predicate within a binary search tree structure.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
-     * parameter can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>`, `R`, or `BTNPredicate<NODE>`.
-     * @param {R | BSTNKeyOrNode<K, NODE>} beginRoot - The `beginRoot` parameter in the `getNode` method
+     * This function retrieves a node based on a given keyNodeEntryRawOrPredicate within a binary search tree structure.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The `keyNodeEntryRawOrPredicate`
+     * parameter can be of type `BTNRep<K, V, NODE>`, `R`, or `NodePredicate<NODE>`.
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} startNode - The `startNode` parameter in the `getNode` method
      * is used to specify the starting point for searching nodes in the binary search tree. If no
      * specific starting point is provided, the default value is set to `this._root`, which is the root
      * node of the binary search tree.
@@ -8993,14 +9107,14 @@ var dataStructureTyped = (() => {
      * parameter that specifies the type of iteration to be used. It has a default value of
      * `this.iterationType`, which means it will use the iteration type defined in the class instance if
      * no value is provided when calling the method.
-     * @returns The `getNode` method is returning an optional binary search tree node (`OptBSTN<NODE>`).
-     * It is using the `getNodes` method to find the node based on the provided predicate, beginning at
-     * the specified root node (`beginRoot`) and using the specified iteration type. The method then
+     * @returns The `getNode` method is returning an optional binary search tree node (`OptNode<NODE>`).
+     * It is using the `getNodes` method to find the node based on the provided keyNodeEntryRawOrPredicate, beginning at
+     * the specified root node (`startNode`) and using the specified iteration type. The method then
      * returns the first node found or `undefined` if no node is found.
      */
-    getNode(predicate, beginRoot = this._root, iterationType = this.iterationType) {
+    getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
       var _a;
-      return (_a = this.getNodes(predicate, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
+      return (_a = this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0]) != null ? _a : void 0;
     }
     /**
      * Time Complexity: O(log n)
@@ -9026,11 +9140,11 @@ var dataStructureTyped = (() => {
      * the callback function.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * during the depth-first search traversal. It is an optional parameter and defaults to
-     * `this._DEFAULT_BTN_CALLBACK`. The type `C` represents the type of the callback function.
+     * `this._DEFAULT_NODE_CALLBACK`. The type `C` represents the type of the callback function.
      * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
      * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
      * take one of the following values:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
      * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
      * node entry. If not specified, the default value is the root of the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
@@ -9038,8 +9152,8 @@ var dataStructureTyped = (() => {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._DEFAULT_BTN_CALLBACK, pattern = "IN", beginRoot = this._root, iterationType = this.iterationType) {
-      return super.dfs(callback, pattern, beginRoot, iterationType);
+    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", startNode = this._root, iterationType = this.iterationType) {
+      return super.dfs(callback, pattern, startNode, iterationType);
     }
     /**
      * Time complexity: O(n)
@@ -9050,7 +9164,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * visited during the breadth-first search. It should take a single argument, which is the current
      * node being visited, and it can return a value of any type.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
      * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
      * object. If no value is provided, the default value is the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -9058,8 +9172,8 @@ var dataStructureTyped = (() => {
      * the following values:
      * @returns an array of the return type of the callback function.
      */
-    bfs(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-      return super.bfs(callback, beginRoot, iterationType, false);
+    bfs(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+      return super.bfs(callback, startNode, iterationType, false);
     }
     /**
      * Time complexity: O(n)
@@ -9068,9 +9182,9 @@ var dataStructureTyped = (() => {
      * The function overrides the listLevels method from the superclass and returns an array of arrays
      * containing the results of the callback function applied to each level of the tree.
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
-     * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the
+     * `NodeCallback<NODE>`. It represents a callback function that will be called for each node in the
      * tree during the iteration process.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
      * point for listing the levels of the binary tree. It can be either a root node of the tree, a
      * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
      * value is provided, the root of
@@ -9079,8 +9193,8 @@ var dataStructureTyped = (() => {
      * @returns The method is returning a two-dimensional array of the return type of the callback
      * function.
      */
-    listLevels(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-      return super.listLevels(callback, beginRoot, iterationType, false);
+    listLevels(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+      return super.listLevels(callback, startNode, iterationType, false);
     }
     /**
      * Time complexity: O(n)
@@ -9094,7 +9208,7 @@ var dataStructureTyped = (() => {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
      * 0, or 1, where:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} targetNode - The `targetNode` parameter is the node in
+     * @param {BTNRep<K, V, NODE> | R} targetNode - The `targetNode` parameter is the node in
      * the binary tree that you want to start traversing from. It can be specified either by providing
      * the key of the node, the node itself, or an entry containing the key and value of the node. If no
      * `targetNode` is provided,
@@ -9103,7 +9217,7 @@ var dataStructureTyped = (() => {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._DEFAULT_BTN_CALLBACK, lesserOrGreater = -1, targetNode = this._root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._DEFAULT_NODE_CALLBACK, lesserOrGreater = -1, targetNode = this._root, iterationType = this.iterationType) {
       const targetNodeEnsured = this.ensureNode(targetNode);
       const ans = [];
       if (!this._root) return ans;
@@ -9146,14 +9260,15 @@ var dataStructureTyped = (() => {
      */
     perfectlyBalance(iterationType = this.iterationType) {
       const sorted = this.dfs((node) => node, "IN"), n = sorted.length;
-      this.clear();
+      this._clearNodes();
       if (sorted.length < 1) return false;
       if (iterationType === "RECURSIVE") {
         const buildBalanceBST = (l, r) => {
           if (l > r) return;
           const m = l + Math.floor((r - l) / 2);
           const midNode = sorted[m];
-          this.add([midNode.key, midNode.value]);
+          if (this._isMapMode) this.add(midNode.key);
+          else this.add([midNode.key, midNode.value]);
           buildBalanceBST(l, m - 1);
           buildBalanceBST(m + 1, r);
         };
@@ -9168,7 +9283,8 @@ var dataStructureTyped = (() => {
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
               const midNode = sorted[m];
-              this.add([midNode.key, midNode.value]);
+              if (this._isMapMode) this.add(midNode.key);
+              else this.add([midNode.key, midNode.value]);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
             }
@@ -9236,7 +9352,7 @@ var dataStructureTyped = (() => {
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
-     * @param {OptBSTN<NODE>} v - v is a parameter of type NODE or undefined.
+     * @param {OptNode<NODE>} v - v is a parameter of type NODE or undefined.
      */
     _setRoot(v) {
       if (v) {
@@ -9844,7 +9960,7 @@ var dataStructureTyped = (() => {
     /**
      * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
      * entries, or raw elements.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements. These elements will
      * be used to initialize the AVLTree.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
@@ -9852,9 +9968,9 @@ var dataStructureTyped = (() => {
      * keys), `allowDuplicates` (a boolean indicating whether duplicate keys are allowed), and
      * `nodeBuilder` (
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
-      if (keysOrNodesOrEntriesOrRaws) super.addMany(keysOrNodesOrEntriesOrRaws);
+      if (keysNodesEntriesOrRaws) super.addMany(keysNodesEntriesOrRaws);
     }
     /**
      * The function creates a new AVL tree node with the given key and value.
@@ -9878,19 +9994,20 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _AVLTree([], __spreadValues({
         iterationType: this.iterationType,
+        isMapMode: this._isMapMode,
         comparator: this._comparator,
         toEntryFn: this._toEntryFn
       }, options));
     }
     /**
      * The function checks if the input is an instance of AVLTreeNode.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `AVLTreeNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw) {
-      return keyOrNodeOrEntryOrRaw instanceof AVLTreeNode;
+    isNode(keyNodeEntryOrRaw) {
+      return keyNodeEntryOrRaw instanceof AVLTreeNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -9898,17 +10015,17 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a class and inserts a key-value pair into a data
      * structure, then balances the path.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept values of type `R`, `BTNKeyOrNodeOrEntry<K, V, NODE>`, or
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept values of type `R`, `BTNRep<K, V, NODE>`, or
      * `RawElement`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key or node being added to the data structure.
      * @returns The method is returning a boolean value.
      */
-    add(keyOrNodeOrEntryOrRaw, value) {
-      if (keyOrNodeOrEntryOrRaw === null) return false;
-      const inserted = super.add(keyOrNodeOrEntryOrRaw, value);
-      if (inserted) this._balancePath(keyOrNodeOrEntryOrRaw);
+    add(keyNodeEntryOrRaw, value) {
+      if (keyNodeEntryOrRaw === null) return false;
+      const inserted = super.add(keyNodeEntryOrRaw, value);
+      if (inserted) this._balancePath(keyNodeEntryOrRaw);
       return inserted;
     }
     /**
@@ -9917,15 +10034,15 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the delete method in a TypeScript class, performs deletion, and then
      * balances the tree if necessary.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
      * parameter in the `override delete` method can be one of the following types:
      * @returns The `delete` method is being overridden in this code snippet. It first calls the `delete`
      * method from the superclass (presumably a parent class) with the provided `predicate`, which could
      * be a key, node, entry, or a custom predicate. The result of this deletion operation is stored in
      * `deletedResults`, which is an array of `BinaryTreeDeleteResult` objects.
      */
-    delete(predicate) {
-      const deletedResults = super.delete(predicate);
+    delete(keyNodeEntryOrRaw) {
+      const deletedResults = super.delete(keyNodeEntryOrRaw);
       for (const { needBalanced } of deletedResults) {
         if (needBalanced) {
           this._balancePath(needBalanced);
@@ -9939,10 +10056,10 @@ var dataStructureTyped = (() => {
      *
      * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a
      * binary search tree.
-     * @param {R | BSTNKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents either a node
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents either a node
      * object (`NODE`) or a key-value pair (`R`) that is being swapped with another node.
-     * @param {R | BSTNKeyOrNode<K, NODE>} destNode - The `destNode` parameter is either an instance of
-     * `R` or an instance of `BSTNKeyOrNode<K, NODE>`.
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter is either an instance of
+     * `R` or an instance of `BSTNOptKeyOrNode<K, NODE>`.
      * @returns The method is returning the `destNodeEnsured` object if both `srcNodeEnsured` and
      * `destNodeEnsured` are truthy. Otherwise, it returns `undefined`.
      */
@@ -9955,10 +10072,10 @@ var dataStructureTyped = (() => {
         if (tempNode) {
           tempNode.height = height;
           destNodeEnsured.key = srcNodeEnsured.key;
-          destNodeEnsured.value = srcNodeEnsured.value;
+          if (!this._isMapMode) destNodeEnsured.value = srcNodeEnsured.value;
           destNodeEnsured.height = srcNodeEnsured.height;
           srcNodeEnsured.key = tempNode.key;
-          srcNodeEnsured.value = tempNode.value;
+          if (!this._isMapMode) srcNodeEnsured.value = tempNode.value;
           srcNodeEnsured.height = tempNode.height;
         }
         return destNodeEnsured;
@@ -10160,8 +10277,8 @@ var dataStructureTyped = (() => {
      *
      * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
      * to restore balance in an AVL tree after inserting a node.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} node - The `node` parameter can be of type `R` or
-     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} node - The `node` parameter can be of type `R` or
+     * `BTNRep<K, V, NODE>`.
      */
     _balancePath(node) {
       node = this.ensureNode(node);
@@ -10247,7 +10364,7 @@ var dataStructureTyped = (() => {
   var RedBlackTree = class _RedBlackTree extends BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
      * initialize the RBTree with the provided elements.
      * @param [options] - The `options` parameter is an optional object that can be passed to the
@@ -10255,12 +10372,12 @@ var dataStructureTyped = (() => {
      * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
      * depend on the implementation
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       __publicField(this, "_root");
       this._root = this.NIL;
-      if (keysOrNodesOrEntriesOrRaws) {
-        this.addMany(keysOrNodesOrEntriesOrRaws);
+      if (keysNodesEntriesOrRaws) {
+        this.addMany(keysNodesEntriesOrRaws);
       }
     }
     /**
@@ -10296,6 +10413,7 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _RedBlackTree([], __spreadValues({
         iterationType: this.iterationType,
+        isMapMode: this._isMapMode,
         comparator: this._comparator,
         toEntryFn: this._toEntryFn
       }, options));
@@ -10305,13 +10423,13 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `RedBlackTreeNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw) {
-      return keyOrNodeOrEntryOrRaw instanceof RedBlackTreeNode;
+    isNode(keyNodeEntryOrRaw) {
+      return keyNodeEntryOrRaw instanceof RedBlackTreeNode;
     }
     // /**
     //  * Time Complexity: O(1)
@@ -10322,29 +10440,29 @@ var dataStructureTyped = (() => {
     //  * Time Complexity: O(1)
     //  * Space Complexity: O(1)
     //  *
-    //  * The function `keyValueOrEntryOrRawElementToNode` takes a key, value, or entry and returns a node if it is
+    //  * The function `keyValueNodeEntryRawToNodeAndValue` takes a key, value, or entry and returns a node if it is
     //  * valid, otherwise it returns undefined.
-    //  * @param {BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRaw - The key, value, or entry to convert.
-    //  * @param {V} [value] - The value associated with the key (if `keyOrNodeOrEntryOrRaw` is a key).
+    //  * @param {BTNRep<K, V, NODE>} keyNodeEntryOrRaw - The key, value, or entry to convert.
+    //  * @param {V} [value] - The value associated with the key (if `keyNodeEntryOrRaw` is a key).
     //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
     //  */
-    // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): NODE | undefined {
+    // override keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): NODE | undefined {
     //
-    //   if (keyOrNodeOrEntryOrRaw === null || keyOrNodeOrEntryOrRaw === undefined) return;
-    //   if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
+    //   if (keyNodeEntryOrRaw === null || keyNodeEntryOrRaw === undefined) return;
+    //   if (this.isNode(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw;
     //
     //   if (this._toEntryFn) {
-    //     const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw as R);
-    //     if (this.isKey(key)) return this.createNode(key, entryValue ?? value, 'RED');
+    //     const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw as R);
+    //     if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'RED');
     //   }
     //
-    //   if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
-    //     const [key, value] = keyOrNodeOrEntryOrRaw;
+    //   if (this.isEntry(keyNodeEntryOrRaw)) {
+    //     const [key, value] = keyNodeEntryOrRaw;
     //     if (key === undefined || key === null) return;
     //     else return  this.createNode(key, value, 'RED');
     //   }
     //
-    //   if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.createNode(keyOrNodeOrEntryOrRaw, value, 'RED');
+    //   if (this.isKey(keyNodeEntryOrRaw)) return this.createNode(keyNodeEntryOrRaw, value, 'RED');
     //
     //   return ;
     // }
@@ -10365,8 +10483,8 @@ var dataStructureTyped = (() => {
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key in the data structure. It represents the value that you want to add or update in the data
      * structure.
@@ -10374,8 +10492,8 @@ var dataStructureTyped = (() => {
      * the method returns true. If the node already exists and its value is updated, the method also
      * returns true. If the node cannot be added or updated, the method returns false.
      */
-    add(keyOrNodeOrEntryOrRaw, value) {
-      const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value);
+    add(keyNodeEntryOrRaw, value) {
+      const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
       if (!this.isRealNode(newNode)) return false;
       const insertStatus = this._insert(newNode);
       if (insertStatus === "CREATED") {
@@ -10384,6 +10502,7 @@ var dataStructureTyped = (() => {
         } else {
           return false;
         }
+        if (this._isMapMode) this._setValue(newNode.key, newValue);
         this._size++;
         return true;
       } else return insertStatus === "UPDATED";
@@ -10394,7 +10513,7 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the delete method in a binary tree data structure to remove a node based on
      * a given predicate and maintain the binary search tree properties.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
      * parameter in the `override delete` method is used to specify the condition or key based on which a
      * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
      * function that determines which node(s) should be deleted.
@@ -10402,12 +10521,12 @@ var dataStructureTyped = (() => {
      * objects. Each object in the array contains information about the deleted node and whether
      * balancing is needed.
      */
-    delete(predicate) {
-      if (predicate === null) return [];
+    delete(keyNodeEntryOrRaw) {
+      if (keyNodeEntryOrRaw === null) return [];
       const results = [];
       let nodeToDelete;
-      if (this._isPredicated(predicate)) nodeToDelete = this.getNode(predicate);
-      else nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
+      if (this._isPredicate(keyNodeEntryOrRaw)) nodeToDelete = this.getNode(keyNodeEntryOrRaw);
+      else nodeToDelete = this.isRealNode(keyNodeEntryOrRaw) ? keyNodeEntryOrRaw : this.getNode(keyNodeEntryOrRaw);
       if (!nodeToDelete) {
         return results;
       }
@@ -10443,6 +10562,7 @@ var dataStructureTyped = (() => {
           successor.color = nodeToDelete.color;
         }
       }
+      if (this._isMapMode) this._store.delete(nodeToDelete.key);
       this._size--;
       if (originalColor === "BLACK") {
         this._deleteFixup(replacementNode);
@@ -10756,16 +10876,16 @@ var dataStructureTyped = (() => {
   var AVLTreeMultiMap = class _AVLTreeMultiMap extends AVLTree {
     /**
      * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the AVLTreeMultiMap. It can include properties such as `compareKeys` and
      * `compareValues` functions to define custom comparison logic for keys and values, respectively.
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
-      if (keysOrNodesOrEntriesOrRaws) this.addMany(keysOrNodesOrEntriesOrRaws);
+      if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
     }
     /**
      * The function calculates the sum of the count property of all nodes in a tree using depth-first
@@ -10812,25 +10932,26 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _AVLTreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
+        isMapMode: this._isMapMode,
         comparator: this._comparator,
         toEntryFn: this._toEntryFn
       }, options));
     }
     /**
      * The function checks if the input is an instance of AVLTreeMultiMapNode.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `AVLTreeMultiMapNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw) {
-      return keyOrNodeOrEntryOrRaw instanceof AVLTreeMultiMapNode;
+    isNode(keyNodeEntryOrRaw) {
+      return keyNodeEntryOrRaw instanceof AVLTreeMultiMapNode;
     }
     /**
-     * The function `keyValueOrEntryOrRawElementToNode` converts a key, value, entry, or raw element into
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
      * a node object.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
-     * `keyOrNodeOrEntryOrRaw` parameter can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyNodeEntryOrRaw` parameter can be of type `R` or `BTNRep<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `override` function. It represents the value associated with the key in the data structure. If no
      * value is provided, it will default to `undefined`.
@@ -10838,20 +10959,25 @@ var dataStructureTyped = (() => {
      * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
      * @returns either a NODE object or undefined.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count = 1) {
-      if (keyOrNodeOrEntryOrRaw === void 0 || keyOrNodeOrEntryOrRaw === null) return;
-      if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
-      if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
-        const [key, entryValue] = keyOrNodeOrEntryOrRaw;
-        if (key === void 0 || key === null) return;
-        if (this.isKey(key)) return this.createNode(key, value != null ? value : entryValue, count);
+    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
+      if (keyNodeEntryOrRaw === void 0 || keyNodeEntryOrRaw === null) return [void 0, void 0];
+      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
+      if (this.isEntry(keyNodeEntryOrRaw)) {
+        const [key, entryValue] = keyNodeEntryOrRaw;
+        if (key === void 0 || key === null) return [void 0, void 0];
+        const finalValue = value != null ? value : entryValue;
+        return [this.createNode(key, finalValue, count), finalValue];
       }
-      if (this._toEntryFn) {
-        const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw);
-        if (this.isKey(key)) return this.createNode(key, value != null ? value : entryValue, count);
+      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, count), value];
+      if (this.isRaw(keyNodeEntryOrRaw)) {
+        if (this._toEntryFn) {
+          const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+          const finalValue = value != null ? value : entryValue;
+          if (this.isKey(key)) return [this.createNode(key, finalValue, count), finalValue];
+        }
+        return [void 0, void 0];
       }
-      if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.createNode(keyOrNodeOrEntryOrRaw, value, count);
-      return;
+      return [void 0, void 0];
     }
     /**
      * Time Complexity: O(log n)
@@ -10859,9 +10985,9 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a TypeScript class to add a new node to a data structure
      * and update the count.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
-     * `keyOrNodeOrEntryOrRaw` parameter can accept a value of type `R`, which can be any type. It
-     * can also accept a value of type `BTNKeyOrNodeOrEntry<K, V, NODE>`, which represents a key, node,
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyNodeEntryOrRaw` parameter can accept a value of type `R`, which can be any type. It
+     * can also accept a value of type `BTNRep<K, V, NODE>`, which represents a key, node,
      * entry, or raw element
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
@@ -10870,11 +10996,11 @@ var dataStructureTyped = (() => {
      * be added once. However, you can specify a different value for `count` if you want to add
      * @returns a boolean value.
      */
-    add(keyOrNodeOrEntryOrRaw, value, count = 1) {
-      const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count);
+    add(keyNodeEntryOrRaw, value, count = 1) {
+      const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
       if (newNode === void 0) return false;
       const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
-      const inserted = super.add(newNode);
+      const inserted = super.add(newNode, newValue);
       if (inserted) {
         this._count += orgNodeCount;
       }
@@ -10886,9 +11012,9 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the delete method in a binary tree data structure, handling deletion of
      * nodes and maintaining balance in the tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `predicate`
      * parameter in the `delete` method is used to specify the condition for deleting a node from the
-     * binary tree. It can be a key, node, entry, or a custom predicate function that determines which
+     * binary tree. It can be a key, node, or entry that determines which
      * node(s) should be deleted.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
      * boolean flag that determines whether to ignore the count of the node being deleted. If
@@ -10899,11 +11025,11 @@ var dataStructureTyped = (() => {
      * method returns an array of `BinaryTreeDeleteResult` objects, each containing information about the
      * deleted node and whether balancing is needed in the tree.
      */
-    delete(predicate, ignoreCount = false) {
+    delete(keyNodeEntryOrRaw, ignoreCount = false) {
       var _a;
       const deletedResult = [];
       if (!this.root) return deletedResult;
-      const curr = (_a = this.getNode(predicate)) != null ? _a : void 0;
+      const curr = (_a = this.getNode(keyNodeEntryOrRaw)) != null ? _a : void 0;
       if (!curr) return deletedResult;
       const parent = (curr == null ? void 0 : curr.parent) ? curr.parent : void 0;
       let needBalanced = void 0, orgCurrent = curr;
@@ -10979,7 +11105,8 @@ var dataStructureTyped = (() => {
           if (l > r) return;
           const m = l + Math.floor((r - l) / 2);
           const midNode = sorted[m];
-          this.add(midNode.key, midNode.value, midNode.count);
+          if (this._isMapMode) this.add(midNode.key, void 0, midNode.count);
+          else this.add(midNode.key, midNode.value, midNode.count);
           buildBalanceBST(l, m - 1);
           buildBalanceBST(m + 1, r);
         };
@@ -10994,7 +11121,8 @@ var dataStructureTyped = (() => {
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
               const midNode = sorted[m];
-              this.add(midNode.key, midNode.value, midNode.count);
+              if (this._isMapMode) this.add(midNode.key, void 0, midNode.count);
+              else this.add(midNode.key, midNode.value, midNode.count);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
             }
@@ -11012,7 +11140,9 @@ var dataStructureTyped = (() => {
      */
     clone() {
       const cloned = this.createTree();
-      this.bfs((node) => cloned.add(node.key, node.value, node.count));
+      if (this._isMapMode) this.bfs((node) => cloned.add(node.key, void 0, node.count));
+      else this.bfs((node) => cloned.add(node.key, node.value, node.count));
+      if (this._isMapMode) cloned._store = this._store;
       return cloned;
     }
     /**
@@ -11021,9 +11151,9 @@ var dataStructureTyped = (() => {
      *
      * The `_swapProperties` function swaps the properties (key, value, count, height) between two nodes
      * in a binary search tree.
-     * @param {R | BSTNKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
      * that will be swapped with the `destNode`.
-     * @param {R | BSTNKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
      * node where the properties will be swapped with the source node.
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      * If either `srcNode` or `destNode` is undefined, it returns `undefined`.
@@ -11037,11 +11167,11 @@ var dataStructureTyped = (() => {
         if (tempNode) {
           tempNode.height = height;
           destNode.key = srcNode.key;
-          destNode.value = srcNode.value;
+          if (!this._isMapMode) destNode.value = srcNode.value;
           destNode.count = srcNode.count;
           destNode.height = srcNode.height;
           srcNode.key = tempNode.key;
-          srcNode.value = tempNode.value;
+          if (!this._isMapMode) srcNode.value = tempNode.value;
           srcNode.count = tempNode.count;
           srcNode.height = tempNode.height;
         }
@@ -11104,17 +11234,17 @@ var dataStructureTyped = (() => {
   var TreeMultiMap = class _TreeMultiMap extends RedBlackTree {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
-     * @param keysOrNodesOrEntriesOrRaws - The parameter `keysOrNodesOrEntriesOrRaws` is an
+     * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
      * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
      * TreeMultiMap with initial data.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the `TreeMultiMap` constructor. It can include properties such as `compareKeys` and
      * `compareValues`, which are functions used to compare keys and values respectively.
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
-      if (keysOrNodesOrEntriesOrRaws) this.addMany(keysOrNodesOrEntriesOrRaws);
+      if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
     }
     // TODO the _count is not accurate after nodes count modified
     /**
@@ -11164,15 +11294,16 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _TreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
+        isMapMode: this._isMapMode,
         comparator: this._comparator,
         toEntryFn: this._toEntryFn
       }, options));
     }
     /**
-     * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
+     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that represents the value
      * associated with the key in the node. It is used when creating a new node or updating the value of
      * an existing node.
@@ -11180,30 +11311,32 @@ var dataStructureTyped = (() => {
      * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
      * @returns either a NODE object or undefined.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count = 1) {
-      if (keyOrNodeOrEntryOrRaw === void 0 || keyOrNodeOrEntryOrRaw === null) return;
-      if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
-      if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
-        const [key, entryValue] = keyOrNodeOrEntryOrRaw;
-        if (key === void 0 || key === null) return;
-        if (this.isKey(key)) return this.createNode(key, value != null ? value : entryValue, "BLACK", count);
+    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
+      if (keyNodeEntryOrRaw === void 0 || keyNodeEntryOrRaw === null) return [void 0, void 0];
+      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
+      if (this.isEntry(keyNodeEntryOrRaw)) {
+        const [key, entryValue] = keyNodeEntryOrRaw;
+        if (key === void 0 || key === null) return [void 0, void 0];
+        const finalValue = value != null ? value : entryValue;
+        if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
       }
       if (this._toEntryFn) {
-        const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw);
-        if (this.isKey(key)) return this.createNode(key, value != null ? value : entryValue, "BLACK", count);
+        const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+        const finalValue = value != null ? value : entryValue;
+        if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
       }
-      if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.createNode(keyOrNodeOrEntryOrRaw, value, "BLACK", count);
-      return;
+      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, "BLACK", count), value];
+      return [void 0, void 0];
     }
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `TreeMultiMapNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw) {
-      return keyOrNodeOrEntryOrRaw instanceof TreeMultiMapNode;
+    isNode(keyNodeEntryOrRaw) {
+      return keyNodeEntryOrRaw instanceof TreeMultiMapNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -11211,8 +11344,8 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a class and adds a new node to a data structure, updating
      * the count and returning a boolean indicating success.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
-     * `keyOrNodeOrEntryOrRaw` parameter can accept one of the following types:
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyNodeEntryOrRaw` parameter can accept one of the following types:
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
      * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
@@ -11221,10 +11354,10 @@ var dataStructureTyped = (() => {
      * @returns The method is returning a boolean value. It returns true if the addition of the new node
      * was successful, and false otherwise.
      */
-    add(keyOrNodeOrEntryOrRaw, value, count = 1) {
-      const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count);
+    add(keyNodeEntryOrRaw, value, count = 1) {
+      const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
       const orgCount = (newNode == null ? void 0 : newNode.count) || 0;
-      const isSuccessAdded = super.add(newNode);
+      const isSuccessAdded = super.add(newNode, newValue);
       if (isSuccessAdded) {
         this._count += orgCount;
         return true;
@@ -11238,22 +11371,21 @@ var dataStructureTyped = (() => {
      *
      * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
      * structure, handling cases where nodes have children and maintaining balance in the tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `predicate`
      * parameter in the `delete` method is used to specify the condition or key based on which a node
-     * should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
-     * function.
+     * should be deleted from the binary tree. It can be a key, a node, or an entry.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
      * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
      * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
      * `ignoreCount` is `false
      * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
      */
-    delete(predicate, ignoreCount = false) {
-      if (predicate === null) return [];
+    delete(keyNodeEntryOrRaw, ignoreCount = false) {
+      if (keyNodeEntryOrRaw === null) return [];
       const results = [];
       let nodeToDelete;
-      if (this._isPredicated(predicate)) nodeToDelete = this.getNode(predicate);
-      else nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
+      if (this._isPredicate(keyNodeEntryOrRaw)) nodeToDelete = this.getNode(keyNodeEntryOrRaw);
+      else nodeToDelete = this.isRealNode(keyNodeEntryOrRaw) ? keyNodeEntryOrRaw : this.getNode(keyNodeEntryOrRaw);
       if (!nodeToDelete) {
         return results;
       }
@@ -11361,7 +11493,8 @@ var dataStructureTyped = (() => {
           if (l > r) return;
           const m = l + Math.floor((r - l) / 2);
           const midNode = sorted[m];
-          this.add(midNode.key, midNode.value, midNode.count);
+          if (this._isMapMode) this.add(midNode.key, void 0, midNode.count);
+          else this.add(midNode.key, midNode.value, midNode.count);
           buildBalanceBST(l, m - 1);
           buildBalanceBST(m + 1, r);
         };
@@ -11376,7 +11509,8 @@ var dataStructureTyped = (() => {
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
               const midNode = sorted[m];
-              this.add(midNode.key, midNode.value, midNode.count);
+              if (this._isMapMode) this.add(midNode.key, void 0, midNode.count);
+              else this.add(midNode.key, midNode.value, midNode.count);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
             }
@@ -11394,7 +11528,8 @@ var dataStructureTyped = (() => {
      */
     clone() {
       const cloned = this.createTree();
-      this.bfs((node) => cloned.add(node.key, node.value, node.count));
+      this.bfs((node) => cloned.add(node.key, void 0, node.count));
+      if (this._isMapMode) cloned._store = this._store;
       return cloned;
     }
     /**
@@ -11403,10 +11538,10 @@ var dataStructureTyped = (() => {
      *
      * The `_swapProperties` function swaps the properties (key, value, count, color) between two nodes
      * in a binary search tree.
-     * @param {R | BSTNKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
      * that will be swapped with the `destNode`. It can be either an instance of the `R` class or an
-     * instance of the `BSTNKeyOrNode<K, NODE>` class.
-     * @param {R | BSTNKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+     * instance of the `BSTNOptKeyOrNode<K, NODE>` class.
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
      * node where the properties will be swapped with the source node.
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      * If either `srcNode` or `destNode` is undefined, it returns undefined.
@@ -11420,11 +11555,11 @@ var dataStructureTyped = (() => {
         if (tempNode) {
           tempNode.color = color;
           destNode.key = srcNode.key;
-          destNode.value = srcNode.value;
+          if (!this._isMapMode) destNode.value = srcNode.value;
           destNode.count = srcNode.count;
           destNode.color = srcNode.color;
           srcNode.key = tempNode.key;
-          srcNode.value = tempNode.value;
+          if (!this._isMapMode) srcNode.value = tempNode.value;
           srcNode.count = tempNode.count;
           srcNode.color = tempNode.color;
         }
@@ -12462,9 +12597,9 @@ var dataStructureTyped = (() => {
      *
      */
     getHeight() {
-      const beginRoot = this.root;
+      const startNode = this.root;
       let maxDepth = 0;
-      if (beginRoot) {
+      if (startNode) {
         const bfs = (node, level) => {
           if (level > maxDepth) {
             maxDepth = level;
@@ -12476,7 +12611,7 @@ var dataStructureTyped = (() => {
             }
           }
         };
-        bfs(beginRoot, 0);
+        bfs(startNode, 0);
       }
       return maxDepth;
     }