data-structure-typed 1.49.5 → 1.49.6

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

@@ -7241,8 +7241,8 @@ var dataStructureTyped = (() => {
 
   // src/types/common.ts
   var BSTVariant = /* @__PURE__ */ ((BSTVariant2) => {
-    BSTVariant2["MIN"] = "MIN";
-    BSTVariant2["MAX"] = "MAX";
+    BSTVariant2["STANDARD"] = "STANDARD";
+    BSTVariant2["INVERSE"] = "INVERSE";
     return BSTVariant2;
   })(BSTVariant || {});
   var CP = /* @__PURE__ */ ((CP2) => {
@@ -7315,15 +7315,15 @@ var dataStructureTyped = (() => {
   };
   var BinaryTree = class _BinaryTree extends IterableEntryBase {
     /**
-     * The constructor function initializes a binary tree object with optional elements and options.
-     * @param [elements] - An optional iterable of BTNExemplar objects. These objects represent the
-     * elements to be added to the binary tree.
+     * The constructor function initializes a binary tree object with optional nodes and options.
+     * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * nodes to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
      * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
      * required.
      */
-    constructor(elements, options) {
+    constructor(nodes, options) {
       super();
       __publicField(this, "iterationType", "ITERATIVE" /* ITERATIVE */);
       __publicField(this, "_extractor", (key) => Number(key));
@@ -7340,8 +7340,8 @@ var dataStructureTyped = (() => {
         }
       }
       this._size = 0;
-      if (elements)
-        this.addMany(elements);
+      if (nodes)
+        this.addMany(nodes);
     }
     get extractor() {
       return this._extractor;
@@ -7372,29 +7372,21 @@ var dataStructureTyped = (() => {
       return new _BinaryTree([], __spreadValues({ iterationType: this.iterationType }, options));
     }
     /**
-     * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V,N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the class N.
-     */
-    isNode(exemplar) {
-      return exemplar instanceof BinaryTreeNode;
-    }
-    /**
-     * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
+     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the exemplar node. If no value
+     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If no value
      * is provided, it will be `undefined`.
      * @returns a value of type N (node), or null, or undefined.
      */
-    exemplarToNode(exemplar, value) {
-      if (exemplar === void 0)
+    exemplarToNode(keyOrNodeOrEntry, value) {
+      if (keyOrNodeOrEntry === void 0)
         return;
       let node;
-      if (exemplar === null) {
+      if (keyOrNodeOrEntry === null) {
         node = null;
-      } else if (this.isEntry(exemplar)) {
-        const [key, value2] = exemplar;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value2] = keyOrNodeOrEntry;
         if (key === void 0) {
           return;
         } else if (key === null) {
@@ -7402,23 +7394,104 @@ var dataStructureTyped = (() => {
         } else {
           node = this.createNode(key, value2);
         }
-      } else if (this.isNode(exemplar)) {
-        node = exemplar;
-      } else if (this.isNotNodeInstance(exemplar)) {
-        node = this.createNode(exemplar, value);
+      } else if (this.isNode(keyOrNodeOrEntry)) {
+        node = keyOrNodeOrEntry;
+      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, value);
       } else {
         return;
       }
       return node;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     *
+     * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
+     * key, otherwise it returns the key itself.
+     * @param {K | N | null | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `N`,
+     * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to be used when searching for a node by key. It has a default value of
+     * `IterationType.ITERATIVE`.
+     * @returns either the node corresponding to the given key if it is a valid node key, or the key
+     * itself if it is not a valid node key.
+     */
+    ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE" /* ITERATIVE */) {
+      let res;
+      if (this.isRealNode(keyOrNodeOrEntry)) {
+        res = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        if (keyOrNodeOrEntry[0] === null)
+          res = null;
+        else if (keyOrNodeOrEntry[0] !== void 0)
+          res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+      } else {
+        if (keyOrNodeOrEntry === null)
+          res = null;
+        else if (keyOrNodeOrEntry !== void 0)
+          res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+      }
+      return res;
+    }
+    /**
+     * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the class N.
+     */
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof BinaryTreeNode;
+    }
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param kne - BTNExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
+     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,N> - A generic type representing a node in a binary tree. It has
      * two type parameters V and N, representing the value and node type respectively.
      * @returns a boolean value.
      */
-    isEntry(kne) {
-      return Array.isArray(kne) && kne.length === 2;
+    isEntry(keyOrNodeOrEntry) {
+      return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(log n)
+     */
+    /**
+     * The function checks if a given node is a real node by verifying if it is an instance of
+     * BinaryTreeNode and its key is not NaN.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isRealNode(node) {
+      return node instanceof BinaryTreeNode && String(node.key) !== "NaN";
+    }
+    /**
+     * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNIL(node) {
+      return node instanceof BinaryTreeNode && String(node.key) === "NaN";
+    }
+    /**
+     * The function checks if a given node is a real node or null.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNodeOrNull(node) {
+      return this.isRealNode(node) || node === null;
+    }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof BinaryTreeNode);
     }
     /**
      * Time Complexity O(log n) - O(n)
@@ -7437,11 +7510,11 @@ var dataStructureTyped = (() => {
     add(keyOrNodeOrEntry, value) {
       const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
       if (newNode === void 0)
-        return;
+        return false;
       if (!this.root) {
         this._root = newNode;
         this._size = 1;
-        return newNode;
+        return true;
       }
       const queue = new Queue([this.root]);
       let potentialParent;
@@ -7451,7 +7524,7 @@ var dataStructureTyped = (() => {
           continue;
         if (newNode !== null && cur.key === newNode.key) {
           this._replaceNode(cur, newNode);
-          return newNode;
+          return true;
         }
         if (potentialParent === void 0 && (cur.left === void 0 || cur.right === void 0)) {
           potentialParent = cur;
@@ -7470,9 +7543,9 @@ var dataStructureTyped = (() => {
           potentialParent.right = newNode;
         }
         this._size++;
-        return newNode;
+        return true;
       }
-      return void 0;
+      return false;
     }
     /**
      * Time Complexity: O(k log n) - O(k * n)
@@ -7483,19 +7556,19 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
      *
-     * The `addMany` function takes in a collection of nodes and an optional collection of values, and
+     * The `addMany` function takes in a collection of keysOrNodesOrEntries and an optional collection of values, and
      * adds each node with its corresponding value to the data structure.
-     * @param nodes - An iterable collection of BTNExemplar objects.
+     * @param keysOrNodesOrEntries - An iterable collection of KeyOrNodeOrEntry objects.
      * @param [values] - An optional iterable of values that will be assigned to each node being added.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(nodes, values) {
+    addMany(keysOrNodesOrEntries, values) {
       const inserted = [];
       let valuesIterator;
       if (values) {
         valuesIterator = values[Symbol.iterator]();
       }
-      for (const kne of nodes) {
+      for (const keyOrNodeOrEntry of keysOrNodesOrEntries) {
         let value = void 0;
         if (valuesIterator) {
           const valueResult = valuesIterator.next();
@@ -7503,17 +7576,30 @@ var dataStructureTyped = (() => {
             value = valueResult.value;
           }
         }
-        inserted.push(this.add(kne, value));
+        inserted.push(this.add(keyOrNodeOrEntry, value));
       }
       return inserted;
     }
     /**
-     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+     * Time Complexity: O(k * n)
      * Space Complexity: O(1)
+     * "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+     */
+    /**
+     * Time Complexity: O(k * n)
+     * Space Complexity: O(1)
+     *
+     * The `refill` function clears the current data and adds new key-value pairs to the data structure.
+     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries. These can be of type
+     * KeyOrNodeOrEntry<K, V, N>.
+     * @param [values] - The `values` parameter is an optional iterable that contains the values to be
+     * associated with the keys or nodes or entries in the `keysOrNodesOrEntries` parameter. If provided,
+     * the values will be associated with the corresponding keys or nodes or entries in the
+     * `keysOrNodesOrEntries` iterable
      */
-    refill(nodesOrKeysOrEntries, values) {
+    refill(keysOrNodesOrEntries, values) {
       this.clear();
-      this.addMany(nodesOrKeysOrEntries, values);
+      this.addMany(keysOrNodesOrEntries, values);
     }
     /**
      * Time Complexity: O(n)
@@ -7583,24 +7669,24 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function calculates the depth of a given node in a binary tree.
-     * @param {K | N | null | undefined} distNode - The `distNode` parameter represents the node in
+     * @param {K | N | null | undefined} dist - The `dist` parameter represents the node in
      * the binary tree whose depth we want to find. It can be of type `K`, `N`, `null`, or
      * `undefined`.
      * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
      * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
      * `N` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
-     * @returns the depth of the `distNode` relative to the `beginRoot`.
+     * @returns the depth of the `dist` relative to the `beginRoot`.
      */
-    getDepth(distNode, beginRoot = this.root) {
-      distNode = this.ensureNode(distNode);
+    getDepth(dist, beginRoot = this.root) {
+      dist = this.ensureNode(dist);
       beginRoot = this.ensureNode(beginRoot);
       let depth = 0;
-      while (distNode == null ? void 0 : distNode.parent) {
-        if (distNode === beginRoot) {
+      while (dist == null ? void 0 : dist.parent) {
+        if (dist === beginRoot) {
           return depth;
         }
         depth++;
-        distNode = distNode.parent;
+        dist = dist.parent;
       }
       return depth;
     }
@@ -7792,6 +7878,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
+     * Space Complexity: O(log n).
      *
      * The function checks if a Binary Tree Node with a specific identifier exists in the tree.
      * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
@@ -7888,24 +7975,6 @@ var dataStructureTyped = (() => {
         }
       }
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
-    /**
-     * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
-     * key, otherwise it returns the key itself.
-     * @param {K | N | null | undefined} key - The `key` parameter can be of type `K`, `N`,
-     * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be used when searching for a node by key. It has a default value of
-     * `IterationType.ITERATIVE`.
-     * @returns either the node corresponding to the given key if it is a valid node key, or the key
-     * itself if it is not a valid node key.
-     */
-    ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
-      return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -7935,10 +8004,13 @@ var dataStructureTyped = (() => {
       return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) == null ? void 0 : _a.value) != null ? _b : void 0;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Clear the binary tree, removing all nodes.
      */
     clear() {
@@ -7946,6 +8018,13 @@ var dataStructureTyped = (() => {
       this._size = 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Check if the binary tree is empty.
      * @returns {boolean} - True if the binary tree is empty, false otherwise.
      */
@@ -7980,7 +8059,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(log n)
@@ -8071,7 +8150,7 @@ var dataStructureTyped = (() => {
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot, iterationType = this.iterationType) {
+    isBST(beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return true;
@@ -8084,45 +8163,32 @@ var dataStructureTyped = (() => {
             return false;
           return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
         };
-        return dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+        const isStandardBST = dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+        const isInverseBST = dfs(beginRoot, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
+        return isStandardBST || isInverseBST;
       } else {
-        const stack = [];
-        let prev = Number.MIN_SAFE_INTEGER, curr = beginRoot;
-        while (curr || stack.length > 0) {
-          while (curr) {
-            stack.push(curr);
-            curr = curr.left;
+        const checkBST = (checkMax = false) => {
+          const stack = [];
+          let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
+          let curr = beginRoot;
+          while (curr || stack.length > 0) {
+            while (curr) {
+              stack.push(curr);
+              curr = curr.left;
+            }
+            curr = stack.pop();
+            const numKey = this.extractor(curr.key);
+            if (!curr || !checkMax && prev >= numKey || checkMax && prev <= numKey)
+              return false;
+            prev = numKey;
+            curr = curr.right;
           }
-          curr = stack.pop();
-          const numKey = this.extractor(curr.key);
-          if (!curr || prev >= numKey)
-            return false;
-          prev = numKey;
-          curr = curr.right;
-        }
-        return true;
+          return true;
+        };
+        const isStandardBST = checkBST(false), isInverseBST = checkBST(true);
+        return isStandardBST || isInverseBST;
       }
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function checks if a binary tree is a binary search tree.
-     * @param iterationType - The parameter "iterationType" is used to specify the type of iteration to
-     * be used when checking if the binary tree is a binary search tree (BST). It is an optional
-     * parameter with a default value of "this.iterationType". The value of "this.iterationType" is
-     * expected to be
-     * @returns a boolean value.
-     */
-    isBST(iterationType = this.iterationType) {
-      if (this.root === null)
-        return true;
-      return this.isSubtreeBST(this.root, iterationType);
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(log n)
@@ -8142,7 +8208,7 @@ var dataStructureTyped = (() => {
      * whether to include null values in the traversal. If `includeNull` is set to `true`, the
      * traversal will include null values, otherwise it will skip them.
      * @returns The function `subTreeTraverse` returns an array of values that are the result of invoking
-     * the `callback` function on each node in the subtree. The type of the array elements is determined
+     * the `callback` function on each node in the subtree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
     subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
@@ -8182,44 +8248,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     */
-    /**
-     * The function checks if a given node is a real node by verifying if it is an instance of
-     * BinaryTreeNode and its key is not NaN.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-     * @returns a boolean value.
-     */
-    isRealNode(node) {
-      return node instanceof BinaryTreeNode && String(node.key) !== "NaN";
-    }
-    /**
-     * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-     * @returns a boolean value.
-     */
-    isNIL(node) {
-      return node instanceof BinaryTreeNode && String(node.key) === "NaN";
-    }
-    /**
-     * The function checks if a given node is a real node or null.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-     * @returns a boolean value.
-     */
-    isNodeOrNull(node) {
-      return this.isRealNode(node) || node === null;
-    }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof BinaryTreeNode);
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -8527,7 +8555,12 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time complexity: O(n)
-     * Space complexity: O(1)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
      * The `morris` function performs a depth-first traversal on a binary tree using the Morris traversal
      * algorithm.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
@@ -8540,7 +8573,7 @@ var dataStructureTyped = (() => {
      * for the traversal. It can be specified as a key, a node object, or `null`/`undefined` to indicate
      * the root of the tree. If no value is provided, the default value is the root of the tree.
      * @returns The function `morris` returns an array of values that are the result of invoking the
-     * `callback` function on each node in the binary tree. The type of the array elements is determined
+     * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
     morris(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root) {
@@ -8649,8 +8682,8 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function creates a new tree by iterating over the elements of the current tree and
-     * adding only the elements that satisfy the given predicate function.
+     * The `filter` function creates a new tree by iterating over the nodes of the current tree and
+     * adding only the nodes that satisfy the given predicate function.
      * @param predicate - The `predicate` parameter is a function that takes three arguments: `value`,
      * `key`, and `index`. It should return a boolean value indicating whether the pair should be
      * included in the filtered tree or not.
@@ -8707,6 +8740,13 @@ var dataStructureTyped = (() => {
     // // }
     //
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The `print` function is used to display a binary tree structure in a visually appealing way.
      * @param {K | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
@@ -8909,16 +8949,16 @@ var dataStructureTyped = (() => {
   var BST = class _BST extends BinaryTree {
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
-     * the tree with optional elements and options.
-     * @param [elements] - An optional iterable of BTNExemplar objects that will be added to the
+     * the tree with optional nodes and options.
+     * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
      * binary search tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
-    constructor(elements, options) {
+    constructor(nodes, options) {
       super([], options);
       __publicField(this, "_root");
-      __publicField(this, "_variant", "MIN" /* MIN */);
+      __publicField(this, "_variant", "STANDARD" /* STANDARD */);
       if (options) {
         const { variant } = options;
         if (variant) {
@@ -8926,8 +8966,8 @@ var dataStructureTyped = (() => {
         }
       }
       this._root = void 0;
-      if (elements)
-        this.addMany(elements);
+      if (nodes)
+        this.addMany(nodes);
     }
     get root() {
       return this._root;
@@ -8960,48 +9000,88 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V, N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
-     */
-    isNode(exemplar) {
-      return exemplar instanceof BSTNode;
-    }
-    /**
-     * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
+     * The function `exemplarToNode` takes an keyOrNodeOrEntry and returns a node if the keyOrNodeOrEntry is valid,
      * otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the exemplar node.
+     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node.
      * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar, value) {
+    exemplarToNode(keyOrNodeOrEntry, value) {
       let node;
-      if (exemplar === null || exemplar === void 0) {
+      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
         return;
-      } else if (this.isNode(exemplar)) {
-        node = exemplar;
-      } else if (this.isEntry(exemplar)) {
-        const [key, value2] = exemplar;
+      } else if (this.isNode(keyOrNodeOrEntry)) {
+        node = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value2] = keyOrNodeOrEntry;
         if (key === void 0 || key === null) {
           return;
         } else {
           node = this.createNode(key, value2);
         }
-      } else if (this.isNotNodeInstance(exemplar)) {
-        node = this.createNode(exemplar, value);
+      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, value);
       } else {
         return;
       }
       return node;
     }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     * Average case for a balanced tree. Space for the recursive call stack in the worst case.
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     *
+     * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
+     * otherwise it returns the key itself.
+     * @param {K | N | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `N`, or
+     * `undefined`.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
+     * @returns either a node object (N) or undefined.
+     */
+    ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE" /* ITERATIVE */) {
+      let res;
+      if (this.isRealNode(keyOrNodeOrEntry)) {
+        res = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        if (keyOrNodeOrEntry[0])
+          res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+      } else {
+        if (keyOrNodeOrEntry)
+          res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+      }
+      return res;
+    }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof BSTNode);
+    }
+    /**
+     * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the BSTNode class.
+     */
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof BSTNode;
+    }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *  - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The `add` function adds a new node to a binary tree, updating the value if the key already exists
      * or inserting a new node if the key is unique.
@@ -9014,23 +9094,23 @@ var dataStructureTyped = (() => {
     add(keyOrNodeOrEntry, value) {
       const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
       if (newNode === void 0)
-        return;
+        return false;
       if (this.root === void 0) {
         this._setRoot(newNode);
         this._size++;
-        return this.root;
+        return true;
       }
       let current = this.root;
       while (current !== void 0) {
         if (this._compare(current.key, newNode.key) === "eq" /* eq */) {
           this._replaceNode(current, newNode);
-          return newNode;
+          return true;
         } else if (this._compare(current.key, newNode.key) === "gt" /* gt */) {
           if (current.left === void 0) {
             current.left = newNode;
             newNode.parent = current;
             this._size++;
-            return newNode;
+            return true;
           }
           current = current.left;
         } else {
@@ -9038,20 +9118,21 @@ var dataStructureTyped = (() => {
             current.right = newNode;
             newNode.parent = current;
             this._size++;
-            return newNode;
+            return true;
           }
           current = current.right;
         }
       }
-      return void 0;
+      return false;
     }
     /**
-     * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(k) - Additional space is required for the sorted array.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(k)
+     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
      */
     /**
-     * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(k) - Additional space is required for the sorted array.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(k)
      *
      * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
      * balancing the tree after each addition.
@@ -9062,7 +9143,7 @@ var dataStructureTyped = (() => {
      * order. If not provided, undefined will be assigned as the value for each key or node.
      * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
      * balanced or not. If set to true, the add operation will be balanced using a binary search tree
-     * algorithm. If set to false, the add operation will not be balanced and the elements will be added
+     * algorithm. If set to false, the add operation will not be balanced and the nodes will be added
      * in the order they appear in the input.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when adding multiple keys or nodes. It has a default value of
@@ -9143,20 +9224,19 @@ var dataStructureTyped = (() => {
       return inserted;
     }
     /**
-     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
      */
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
      * leftmost node if the comparison result is greater than.
      * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
      * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
      * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed. It can have one of the following values:
      * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
@@ -9165,7 +9245,7 @@ var dataStructureTyped = (() => {
       let current = this.ensureNode(beginRoot);
       if (!current)
         return void 0;
-      if (this._variant === "MIN" /* MIN */) {
+      if (this._variant === "STANDARD" /* STANDARD */) {
         while (current.right !== void 0) {
           current = current.right;
         }
@@ -9177,12 +9257,12 @@ var dataStructureTyped = (() => {
       return current.key;
     }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
      * either recursive or iterative methods.
@@ -9225,53 +9305,34 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof BSTNode);
-    }
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
-     */
-    /**
-     * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
-     * otherwise it returns the key itself.
-     * @param {K | N | undefined} key - The `key` parameter can be of type `K`, `N`, or
-     * `undefined`.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
-     * @returns either a node object (N) or undefined.
-     */
-    ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
-      return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
-    }
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
-     *
-     * The function `getNodes` returns an array of nodes that match a given identifier, using either a
-     * recursive or iterative approach.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
-     * want to search for in the nodes of the binary tree. It can be of any type that is returned by the
-     * callback function `C`.
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` as its
-     * argument and returns a value of type `ReturnType<C>`. The `C` type parameter represents a callback
-     * function type that extends the `BTNCallback<N>` type. The `BTNCallback<N>` type is
-     * @param [onlyOne=false] - A boolean flag indicating whether to stop searching after finding the
-     * first node that matches the identifier. If set to true, the function will return an array
-     * containing only the first matching node. If set to false (default), the function will continue
-     * searching for all nodes that match the identifier and return an array containing
-     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
-     * for the traversal. It can be either a key value or a node object. If it is undefined, the
-     * traversal will start from the root of the tree.
-     * @param iterationType - The `iterationType` parameter determines the type of iteration to be
-     * performed on the binary tree. It can have two possible values:
-     * @returns The method returns an array of nodes (`N[]`).
-     */
+       * Time Complexity: O(log n)
+       * Space Complexity: O(log n)
+       * Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key. Space for the recursive call stack in the worst case.
+       * /
+    
+       /**
+       * Time Complexity: O(log n)
+       * Space Complexity: O(log n)
+       *
+       * The function `getNodes` returns an array of nodes that match a given identifier, using either a
+       * recursive or iterative approach.
+       * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
+       * want to search for in the nodes of the binary tree. It can be of any type that is returned by the
+       * callback function `C`.
+       * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` as its
+       * argument and returns a value of type `ReturnType<C>`. The `C` type parameter represents a callback
+       * function type that extends the `BTNCallback<N>` type. The `BTNCallback<N>` type is
+       * @param [onlyOne=false] - A boolean flag indicating whether to stop searching after finding the
+       * first node that matches the identifier. If set to true, the function will return an array
+       * containing only the first matching node. If set to false (default), the function will continue
+       * searching for all nodes that match the identifier and return an array containing
+       * @param {K | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
+       * for the traversal. It can be either a key value or a node object. If it is undefined, the
+       * traversal will start from the root of the tree.
+       * @param iterationType - The `iterationType` parameter determines the type of iteration to be
+       * performed on the binary tree. It can have two possible values:
+       * @returns The method returns an array of nodes (`N[]`).
+       */
     getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
@@ -9324,12 +9385,13 @@ var dataStructureTyped = (() => {
       return ans;
     }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     * Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key. Space for the recursive call stack in the worst case.
      */
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      *
      * The `lesserOrGreaterTraverse` function traverses a binary tree and returns an array of nodes that
      * are either lesser or greater than a target node, depending on the specified comparison type.
@@ -9388,12 +9450,12 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      */
     /**
-     * Time Complexity: O(n) - Building a balanced tree from a sorted array.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      *
      * The `perfectlyBalance` function balances a binary search tree by adding nodes in a way that
      * ensures the tree is perfectly balanced.
@@ -9451,8 +9513,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n) - Additional space is required for the sorted array.
      */
     /**
-     * Time Complexity: O(n) - Visiting each node once.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      *
      * The function checks if a binary tree is AVL balanced using either recursive or iterative approach.
      * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
@@ -9519,7 +9581,7 @@ var dataStructureTyped = (() => {
     _compare(a, b) {
       const extractedA = this.extractor(a);
       const extractedB = this.extractor(b);
-      const compared = this.variant === "MIN" /* MIN */ ? extractedA - extractedB : extractedB - extractedA;
+      const compared = this.variant === "STANDARD" /* STANDARD */ ? extractedA - extractedB : extractedB - extractedA;
       return compared > 0 ? "gt" /* gt */ : compared < 0 ? "lt" /* lt */ : "eq" /* eq */;
     }
   };
@@ -9960,18 +10022,18 @@ var dataStructureTyped = (() => {
   };
   var AVLTree = class _AVLTree extends BST {
     /**
-     * The constructor function initializes an AVLTree object with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
-     * objects. It represents a collection of elements that will be added to the AVL tree during
+     * The constructor function initializes an AVLTree object with optional nodes and options.
+     * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * objects. It represents a collection of nodes that will be added to the AVL tree during
      * initialization.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
      * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
      * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
      */
-    constructor(elements, options) {
+    constructor(nodes, options) {
       super([], options);
-      if (elements)
-        super.addMany(elements);
+      if (nodes)
+        super.addMany(nodes);
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
@@ -9999,12 +10061,12 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function checks if an exemplar is an instance of AVLTreeNode.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
+     * The function checks if an keyOrNodeOrEntry is an instance of AVLTreeNode.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeNode class.
      */
-    isNode(exemplar) {
-      return exemplar instanceof AVLTreeNode;
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof AVLTreeNode;
     }
     /**
      * The function "isNotNodeInstance" checks if a potential key is a K.
@@ -10016,12 +10078,13 @@ var dataStructureTyped = (() => {
       return !(potentialKey instanceof AVLTreeNode);
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the add method of a binary tree node and balances the tree after inserting
      * a new node.
@@ -10033,19 +10096,19 @@ var dataStructureTyped = (() => {
      */
     add(keyOrNodeOrEntry, value) {
       if (keyOrNodeOrEntry === null)
-        return void 0;
+        return false;
       const inserted = super.add(keyOrNodeOrEntry, value);
       if (inserted)
-        this._balancePath(inserted);
+        this._balancePath(keyOrNodeOrEntry);
       return inserted;
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (BST) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the delete method of a binary tree, performs the deletion, and then
      * balances the tree if necessary.
@@ -10099,12 +10162,13 @@ var dataStructureTyped = (() => {
       return void 0;
     }
     /**
-     * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * constant time, as it performs a fixed number of operations. constant space, as it only uses a constant amount of memory.
      */
     /**
-     * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function calculates the balance factor of a node in a binary tree.
      * @param {N} node - The parameter "node" represents a node in a binary tree data structure.
@@ -10120,12 +10184,13 @@ var dataStructureTyped = (() => {
         return node.right.height - node.left.height;
     }
     /**
-     * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * constant time, as it performs a fixed number of operations. constant space, as it only uses a constant amount of memory.
      */
     /**
-     * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function updates the height of a node in a binary tree based on the heights of its left and
      * right children.
@@ -10143,12 +10208,13 @@ var dataStructureTyped = (() => {
         node.height = 1 + Math.max(node.right.height, node.left.height);
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The method traverses the path from the inserted node to the root.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The method traverses the path from the inserted node to the root. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The method traverses the path from the inserted node to the root.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * 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.
@@ -10156,6 +10222,7 @@ var dataStructureTyped = (() => {
      * AVL tree that needs to be balanced.
      */
     _balancePath(node) {
+      node = this.ensureNode(node);
       const path = this.getPathToRoot(node, false);
       for (let i = 0; i < path.length; i++) {
         const A = path[i];
@@ -10182,12 +10249,13 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * constant time, as these methods perform a fixed number of operations. constant space, as they only use a constant amount of memory.
      */
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function `_balanceLL` performs a left-left rotation to balance a binary tree.
      * @param {N} A - A is a node in a binary tree.
@@ -10221,12 +10289,12 @@ var dataStructureTyped = (() => {
         this._updateHeight(B);
     }
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
      * @param {N} A - A is a node in a binary tree.
@@ -10275,12 +10343,12 @@ var dataStructureTyped = (() => {
       C && this._updateHeight(C);
     }
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
      * @param {N} A - A is a node in a binary tree.
@@ -10315,12 +10383,12 @@ var dataStructureTyped = (() => {
       B && this._updateHeight(B);
     }
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
      * @param {N} A - A is a node in a binary tree.
@@ -10385,23 +10453,23 @@ var dataStructureTyped = (() => {
   var RedBlackTree = class _RedBlackTree extends BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
-     * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
-     * objects. It represents the initial elements that will be added to the RBTree during its
+     * initializes the tree with optional nodes and options.
+     * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * objects. It represents the initial nodes that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
-     * elements to the
+     * nodes to the
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(elements, options) {
+    constructor(nodes, options) {
       super([], options);
       __publicField(this, "Sentinel", new RedBlackTreeNode(NaN));
       __publicField(this, "_root");
       __publicField(this, "_size", 0);
       this._root = this.Sentinel;
-      if (elements)
-        super.addMany(elements);
+      if (nodes)
+        super.addMany(nodes);
     }
     get root() {
       return this._root;
@@ -10438,57 +10506,67 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
-     * class.
-     */
-    isNode(exemplar) {
-      return exemplar instanceof RedBlackTreeNode;
-    }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof RedBlackTreeNode);
-    }
-    /**
-     * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
+     * The function `exemplarToNode` takes an keyOrNodeOrEntry and converts it into a node object if possible.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the exemplar node. If a value
+     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
      * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar, value) {
+    exemplarToNode(keyOrNodeOrEntry, value) {
       let node;
-      if (exemplar === null || exemplar === void 0) {
+      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
         return;
-      } else if (this.isNode(exemplar)) {
-        node = exemplar;
-      } else if (this.isEntry(exemplar)) {
-        const [key, value2] = exemplar;
+      } else if (this.isNode(keyOrNodeOrEntry)) {
+        node = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value2] = keyOrNodeOrEntry;
         if (key === void 0 || key === null) {
           return;
         } else {
           node = this.createNode(key, value2, 1 /* RED */);
         }
-      } else if (this.isNotNodeInstance(exemplar)) {
-        node = this.createNode(exemplar, value, 1 /* RED */);
+      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, value, 1 /* RED */);
       } else {
         return;
       }
       return node;
     }
+    /**
+     * The function checks if an keyOrNodeOrEntry is an instance of the RedBlackTreeNode class.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the RedBlackTreeNode
+     * class.
+     */
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof RedBlackTreeNode;
+    }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
      */
+    isRealNode(node) {
+      if (node === this.Sentinel || node === void 0)
+        return false;
+      return node instanceof RedBlackTreeNode;
+    }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof RedBlackTreeNode);
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *  on average (where n is the number of nodes in the tree)
+     */
+    /**
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `add` function adds a new node to a binary search tree and performs necessary rotations and
@@ -10502,7 +10580,7 @@ var dataStructureTyped = (() => {
     add(keyOrNodeOrEntry, value) {
       const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
       if (newNode === void 0)
-        return;
+        return false;
       newNode.left = this.Sentinel;
       newNode.right = this.Sentinel;
       let y = void 0;
@@ -10518,7 +10596,7 @@ var dataStructureTyped = (() => {
             if (newNode !== x) {
               this._replaceNode(x, newNode);
             }
-            return;
+            return false;
           }
         }
       }
@@ -10533,21 +10611,23 @@ var dataStructureTyped = (() => {
       if (newNode.parent === void 0) {
         newNode.color = 0 /* BLACK */;
         this._size++;
-        return;
+        return false;
       }
       if (newNode.parent.parent === void 0) {
         this._size++;
-        return;
+        return false;
       }
       this._fixInsert(newNode);
       this._size++;
+      return true;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
+     *  on average (where n is the number of nodes in the tree)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes a node from a binary tree based on a given identifier and updates
@@ -10615,20 +10695,11 @@ var dataStructureTyped = (() => {
       return ans;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    isRealNode(node) {
-      if (node === this.Sentinel || node === void 0)
-        return false;
-      return node instanceof RedBlackTreeNode;
-    }
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function `getNode` retrieves a single node from a binary tree based on a given identifier and
@@ -10680,7 +10751,7 @@ var dataStructureTyped = (() => {
       return y;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     clear() {
@@ -10757,11 +10828,11 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function `_fixDelete` is used to fix the red-black tree after a node deletion.
@@ -10851,11 +10922,11 @@ var dataStructureTyped = (() => {
       v.parent = u.parent;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
@@ -10938,11 +11009,11 @@ var dataStructureTyped = (() => {
     }
   };
   var TreeMultimap = class _TreeMultimap extends AVLTree {
-    constructor(elements, options) {
+    constructor(nodes, options) {
       super([], options);
       __publicField(this, "_count", 0);
-      if (elements)
-        this.addMany(elements);
+      if (nodes)
+        this.addMany(nodes);
     }
     // TODO the _count is not accurate after nodes count modified
     get count() {
@@ -10969,26 +11040,8 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
-     * class.
-     */
-    isNode(exemplar) {
-      return exemplar instanceof TreeMultimapNode;
-    }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof TreeMultimapNode);
-    }
-    /**
-     * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
+     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -10997,33 +11050,52 @@ var dataStructureTyped = (() => {
      * times the value should be added to the node. If not provided, it defaults to 1.
      * @returns a node of type `N` or `undefined`.
      */
-    exemplarToNode(exemplar, value, count = 1) {
+    exemplarToNode(keyOrNodeOrEntry, value, count = 1) {
       let node;
-      if (exemplar === void 0 || exemplar === null) {
+      if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
         return;
-      } else if (this.isNode(exemplar)) {
-        node = exemplar;
-      } else if (this.isEntry(exemplar)) {
-        const [key, value2] = exemplar;
+      } else if (this.isNode(keyOrNodeOrEntry)) {
+        node = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value2] = keyOrNodeOrEntry;
         if (key === void 0 || key === null) {
           return;
         } else {
           node = this.createNode(key, value2, count);
         }
-      } else if (this.isNotNodeInstance(exemplar)) {
-        node = this.createNode(exemplar, value, count);
+      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, value, count);
       } else {
         return;
       }
       return node;
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+     * class.
+     */
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof TreeMultimapNode;
+    }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof TreeMultimapNode);
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the add method of a binary tree node and adds a new node to the tree.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
@@ -11040,21 +11112,22 @@ var dataStructureTyped = (() => {
     add(keyOrNodeOrEntry, value, count = 1) {
       const newNode = this.exemplarToNode(keyOrNodeOrEntry, value, count);
       if (newNode === void 0)
-        return;
+        return false;
       const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
       const inserted = super.add(newNode);
       if (inserted) {
         this._count += orgNodeCount;
       }
-      return inserted;
+      return true;
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
      * structure.
@@ -11066,12 +11139,13 @@ var dataStructureTyped = (() => {
       return super.addMany(keysOrNodesOrEntries);
     }
     /**
-     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node. linear space, as it creates an array to store the sorted nodes.
      */
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
      * tree using either a recursive or iterative approach.
@@ -11116,12 +11190,13 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
      * account the count of the node and balancing the tree if necessary.
@@ -11191,10 +11266,13 @@ var dataStructureTyped = (() => {
       return deletedResult;
     }
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear() {