data-structure-typed 1.46.8 → 1.47.0

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

@@ -3,13 +3,26 @@ var dataStructureTyped = (() => {
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __propIsEnum = Object.prototype.propertyIsEnumerable;
   var __knownSymbol = (name, symbol) => {
     if (symbol = Symbol[name])
       return symbol;
     throw Error("Symbol." + name + " is not defined");
   };
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    if (__getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(b)) {
+        if (__propIsEnum.call(b, prop))
+          __defNormalProp(a, prop, b[prop]);
+      }
+    return a;
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -113,7 +126,6 @@ var dataStructureTyped = (() => {
     HashTable: () => HashTable,
     HashTableNode: () => HashTableNode,
     Heap: () => Heap,
-    IterateDirection: () => IterateDirection,
     IterationType: () => IterationType,
     LinkedListQueue: () => LinkedListQueue,
     MapEdge: () => MapEdge,
@@ -6511,10 +6523,10 @@ var dataStructureTyped = (() => {
   };
 
   // src/types/data-structures/binary-tree/binary-tree.ts
-  var IterationType = /* @__PURE__ */ ((IterationType3) => {
-    IterationType3["ITERATIVE"] = "ITERATIVE";
-    IterationType3["RECURSIVE"] = "RECURSIVE";
-    return IterationType3;
+  var IterationType = /* @__PURE__ */ ((IterationType2) => {
+    IterationType2["ITERATIVE"] = "ITERATIVE";
+    IterationType2["RECURSIVE"] = "RECURSIVE";
+    return IterationType2;
   })(IterationType || {});
   var FamilyPosition = /* @__PURE__ */ ((FamilyPosition2) => {
     FamilyPosition2["ROOT"] = "ROOT";
@@ -6541,11 +6553,6 @@ var dataStructureTyped = (() => {
     CP2["gt"] = "gt";
     return CP2;
   })(CP || {});
-  var IterateDirection = /* @__PURE__ */ ((IterateDirection2) => {
-    IterateDirection2[IterateDirection2["DEFAULT"] = 0] = "DEFAULT";
-    IterateDirection2[IterateDirection2["REVERSE"] = 1] = "REVERSE";
-    return IterateDirection2;
-  })(IterateDirection || {});
 
   // src/data-structures/binary-tree/binary-tree.ts
   var BinaryTreeNode = class {
@@ -6621,19 +6628,20 @@ var dataStructureTyped = (() => {
       return "MAL_NODE" /* MAL_NODE */;
     }
   };
-  var BinaryTree = class {
+  var BinaryTree = class _BinaryTree {
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
-      __publicField(this, "iterationType", "ITERATIVE" /* ITERATIVE */);
+      __publicField(this, "options");
       __publicField(this, "_root");
       __publicField(this, "_size");
       __publicField(this, "_defaultOneParamCallback", (node) => node.key);
       if (options) {
-        const { iterationType = "ITERATIVE" /* ITERATIVE */ } = options;
-        this.iterationType = iterationType;
+        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */ }, options);
+      } else {
+        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */ };
       }
       this._size = 0;
     }
@@ -6658,6 +6666,9 @@ var dataStructureTyped = (() => {
     createNode(key, value) {
       return new BinaryTreeNode(key, value);
     }
+    createTree(options) {
+      return new _BinaryTree(__spreadValues(__spreadValues({}, this.options), options));
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -6879,7 +6890,7 @@ var dataStructureTyped = (() => {
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
+    getHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return -1;
@@ -6924,7 +6935,7 @@ var dataStructureTyped = (() => {
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
-    getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
+    getMinHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
       var _a, _b, _c;
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
@@ -7013,7 +7024,7 @@ var dataStructureTyped = (() => {
      * traverse the binary tree. It can have two possible values:
      * @returns an array of nodes of type `N`.
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.options.iterationType) {
       if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
       beginRoot = this.ensureNotKey(beginRoot);
@@ -7074,7 +7085,7 @@ var dataStructureTyped = (() => {
      * be performed in a pre-order, in-order, or post-order manner.
      * @returns a boolean value.
      */
-    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
       if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
       return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
@@ -7104,7 +7115,7 @@ var dataStructureTyped = (() => {
      * nodes are visited during the search.
      * @returns a value of type `N | null | undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
       var _a;
       if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
@@ -7196,7 +7207,7 @@ var dataStructureTyped = (() => {
      * @returns The value of the node with the given identifier is being returned. If the node is not
      * found, `undefined` is returned.
      */
-    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
       var _a, _b;
       if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
@@ -7264,7 +7275,7 @@ var dataStructureTyped = (() => {
      * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
-    getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
+    getLeftMost(beginRoot = this.root, iterationType = this.options.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return beginRoot;
@@ -7303,7 +7314,7 @@ var dataStructureTyped = (() => {
      * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
-    getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
+    getRightMost(beginRoot = this.root, iterationType = this.options.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return beginRoot;
@@ -7339,7 +7350,7 @@ var dataStructureTyped = (() => {
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot, iterationType = this.iterationType) {
+    isSubtreeBST(beginRoot, iterationType = this.options.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return true;
@@ -7384,7 +7395,7 @@ var dataStructureTyped = (() => {
      * expected to be
      * @returns a boolean value.
      */
-    isBST(iterationType = this.iterationType) {
+    isBST(iterationType = this.options.iterationType) {
       if (this.root === null)
         return true;
       return this.isSubtreeBST(this.root, iterationType);
@@ -7409,13 +7420,13 @@ var dataStructureTyped = (() => {
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
      * performed on the subtree. It can have two possible values:
      * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
-     * whether or not to include null values in the traversal. If `includeNull` is set to `true`, the
+     * 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
      * by the return type of the `callback` function.
      */
-    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
       beginRoot = this.ensureNotKey(beginRoot);
       const ans = [];
       if (!beginRoot)
@@ -7632,12 +7643,12 @@ var dataStructureTyped = (() => {
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
      * performed during the breadth-first search (BFS). It can have two possible values:
      * @param [includeNull=false] - The `includeNull` parameter is a boolean flag that determines whether
-     * or not to include null values in the breadth-first search traversal. If `includeNull` is set to
+     * to include null values in the breadth-first search traversal. If `includeNull` is set to
      * `true`, null values will be included in the traversal, otherwise they will be skipped.
      * @returns an array of values that are the result of invoking the callback function on each node in
      * the breadth-first traversal of a binary tree.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return [];
@@ -7706,12 +7717,12 @@ var dataStructureTyped = (() => {
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
      * performed on the tree. It can have two possible values:
      * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
-     * whether or not to include null values in the resulting levels. If `includeNull` is set to `true`,
+     * whether to include null values in the resulting levels. If `includeNull` is set to `true`,
      * null values will be included in the levels. If `includeNull` is set to `false`, null values will
      * be excluded
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
       beginRoot = this.ensureNotKey(beginRoot);
       const levelsNodes = [];
       if (!beginRoot)
@@ -7902,6 +7913,74 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    /**
+     * The `forEach` function iterates over each entry in a tree and calls a callback function with the
+     * entry and the tree as arguments.
+     * @param callback - The callback parameter is a function that will be called for each entry in the
+     * tree. It takes two parameters: entry and tree.
+     */
+    forEach(callback) {
+      for (const entry of this) {
+        callback(entry, this);
+      }
+    }
+    /**
+     * The `filter` function creates a new tree by iterating over the entries of the current tree and
+     * adding the entries that satisfy the given predicate.
+     * @param predicate - The `predicate` parameter is a function that takes two arguments: `entry` and
+     * `tree`.
+     * @returns The `filter` method is returning a new tree object that contains only the entries that
+     * satisfy the given predicate function.
+     */
+    filter(predicate) {
+      const newTree = this.createTree();
+      for (const [key, value] of this) {
+        if (predicate([key, value], this)) {
+          newTree.add(key, value);
+        }
+      }
+      return newTree;
+    }
+    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
+    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
+    //   const newTree = this.createTree();
+    //   for (const [key, value] of this) {
+    //     newTree.add(key, callback([key, value], this));
+    //   }
+    //   return newTree;
+    // }
+    /**
+     * The `map` function creates a new tree by applying a callback function to each entry in the current
+     * tree.
+     * @param callback - The callback parameter is a function that takes two arguments: entry and tree.
+     * @returns The `map` method is returning a new tree object.
+     */
+    map(callback) {
+      const newTree = this.createTree();
+      for (const [key, value] of this) {
+        newTree.add(key, callback([key, value], this));
+      }
+      return newTree;
+    }
+    /**
+     * The `reduce` function iterates over the entries of a tree and applies a callback function to each
+     * entry, accumulating a single value.
+     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
+     * entry, and tree. It is called for each entry in the tree and is used to accumulate a single value
+     * based on the logic defined in the callback function.
+     * @param {T} initialValue - The initialValue parameter is the initial value of the accumulator. It
+     * is the value that will be passed as the first argument to the callback function when reducing the
+     * elements of the tree.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
+     * all the entries in the tree and applying the callback function to each entry.
+     */
+    reduce(callback, initialValue) {
+      let accumulator = initialValue;
+      for (const [key, value] of this) {
+        accumulator = callback(accumulator, [key, value], this);
+      }
+      return accumulator;
+    }
     /**
      * The above function is an iterator for a binary tree that can be used to traverse the tree in
      * either an iterative or recursive manner.
@@ -7912,71 +7991,90 @@ var dataStructureTyped = (() => {
      * binary tree nodes in a specific order.
      */
     *[Symbol.iterator](node = this.root) {
-      if (!node) {
+      if (!node)
         return;
-      }
-      if (this.iterationType === "ITERATIVE" /* ITERATIVE */) {
+      if (this.options.iterationType === "ITERATIVE" /* ITERATIVE */) {
         const stack = [];
         let current = node;
         while (current || stack.length > 0) {
-          while (current) {
+          while (current && !isNaN(current.key)) {
             stack.push(current);
             current = current.left;
           }
           current = stack.pop();
-          if (current)
-            yield current.key;
-          if (current)
+          if (current && !isNaN(current.key)) {
+            yield [current.key, current.value];
             current = current.right;
+          }
         }
       } else {
-        if (node.left) {
+        if (node.left && !isNaN(node.key)) {
           yield* __yieldStar(this[Symbol.iterator](node.left));
         }
-        yield node.key;
-        if (node.right) {
+        yield [node.key, node.value];
+        if (node.right && !isNaN(node.key)) {
           yield* __yieldStar(this[Symbol.iterator](node.right));
         }
       }
     }
     /**
      * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {N | null | undefined} beginRoot - The `root` parameter is of type `BTNKey | N | null |
+     * @param {BTNKey | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `BTNKey | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * following types:
+     * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
      */
-    print(beginRoot = this.root) {
+    print(beginRoot = this.root, options) {
+      const opts = __spreadValues({ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false }, options);
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return;
+      if (opts.isShowUndefined)
+        console.log(`U for undefined
+      `);
+      if (opts.isShowNull)
+        console.log(`N for null
+      `);
+      if (opts.isShowRedBlackNIL)
+        console.log(`S for Sentinel Node
+      `);
       const display = (root) => {
-        const [lines, , ,] = this._displayAux(root);
+        const [lines, , ,] = this._displayAux(root, opts);
         for (const line of lines) {
           console.log(line);
         }
       };
       display(beginRoot);
     }
-    _displayAux(node) {
-      if (!node) {
-        return [["\u2500"], 1, 0, 0];
-      }
-      const line = node.key.toString();
-      const width = line.length;
-      if (!node.left && !node.right) {
-        return [[line], width, 1, Math.floor(width / 2)];
+    _displayAux(node, options) {
+      const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
+      const emptyDisplayLayout = [["\u2500"], 1, 0, 0];
+      if (node === null && !isShowNull) {
+        return emptyDisplayLayout;
+      } else if (node === void 0 && !isShowUndefined) {
+        return emptyDisplayLayout;
+      } else if (node !== null && node !== void 0 && isNaN(node.key) && !isShowRedBlackNIL) {
+        return emptyDisplayLayout;
+      } else if (node !== null && node !== void 0) {
+        const key = node.key, line = isNaN(key) ? "S" : key.toString(), width = line.length;
+        return _buildNodeDisplay(line, width, this._displayAux(node.left, options), this._displayAux(node.right, options));
+      } else {
+        const line = node === void 0 ? "U" : "N", width = line.length;
+        return _buildNodeDisplay(line, width, [[""], 1, 0, 0], [[""], 1, 0, 0]);
       }
-      const [leftLines, leftWidth, leftHeight, leftMiddle] = node.left ? this._displayAux(node.left) : [[""], 0, 0, 0];
-      const [rightLines, rightWidth, rightHeight, rightMiddle] = node.right ? this._displayAux(node.right) : [[""], 0, 0, 0];
-      const firstLine = " ".repeat(Math.max(0, leftMiddle + 1)) + "_".repeat(Math.max(0, leftWidth - leftMiddle - 1)) + line + "_".repeat(Math.max(0, rightMiddle)) + " ".repeat(Math.max(0, rightWidth - rightMiddle));
-      const secondLine = (leftHeight > 0 ? " ".repeat(leftMiddle) + "/" + " ".repeat(leftWidth - leftMiddle - 1) : " ".repeat(leftWidth)) + " ".repeat(width) + (rightHeight > 0 ? " ".repeat(rightMiddle) + "\\" + " ".repeat(rightWidth - rightMiddle - 1) : " ".repeat(rightWidth));
-      const mergedLines = [firstLine, secondLine];
-      for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
-        const leftLine = i < leftHeight ? leftLines[i] : " ".repeat(leftWidth);
-        const rightLine = i < rightHeight ? rightLines[i] : " ".repeat(rightWidth);
-        mergedLines.push(leftLine + " ".repeat(width) + rightLine);
+      function _buildNodeDisplay(line, width, left, right) {
+        const [leftLines, leftWidth, leftHeight, leftMiddle] = left;
+        const [rightLines, rightWidth, rightHeight, rightMiddle] = right;
+        const firstLine = " ".repeat(Math.max(0, leftMiddle + 1)) + "_".repeat(Math.max(0, leftWidth - leftMiddle - 1)) + line + "_".repeat(Math.max(0, rightMiddle)) + " ".repeat(Math.max(0, rightWidth - rightMiddle));
+        const secondLine = (leftHeight > 0 ? " ".repeat(leftMiddle) + "/" + " ".repeat(leftWidth - leftMiddle - 1) : " ".repeat(leftWidth)) + " ".repeat(width) + (rightHeight > 0 ? " ".repeat(rightMiddle) + "\\" + " ".repeat(rightWidth - rightMiddle - 1) : " ".repeat(rightWidth));
+        const mergedLines = [firstLine, secondLine];
+        for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
+          const leftLine = i < leftHeight ? leftLines[i] : " ".repeat(leftWidth);
+          const rightLine = i < rightHeight ? rightLines[i] : " ".repeat(rightWidth);
+          mergedLines.push(leftLine + " ".repeat(width) + rightLine);
+        }
+        return [mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
       }
-      return [mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
     }
     /**
      * Swap the data of two nodes in the binary tree.
@@ -8092,7 +8190,7 @@ var dataStructureTyped = (() => {
       this._right = v;
     }
   };
-  var BST = class extends BinaryTree {
+  var BST = class _BST extends BinaryTree {
     /**
      * The constructor function initializes a binary search tree with an optional comparator function.
      * @param {BSTOptions} [options] - An optional object that contains additional configuration options
@@ -8100,15 +8198,14 @@ var dataStructureTyped = (() => {
      */
     constructor(options) {
       super(options);
+      __publicField(this, "options");
       __publicField(this, "_root");
-      __publicField(this, "_comparator", (a, b) => a - b);
-      this._root = void 0;
-      if (options !== void 0) {
-        const { comparator } = options;
-        if (comparator !== void 0) {
-          this._comparator = comparator;
-        }
+      if (options) {
+        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
+      } else {
+        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
       }
+      this._root = void 0;
     }
     /**
      * Get the root node of the binary tree.
@@ -8127,6 +8224,9 @@ var dataStructureTyped = (() => {
     createNode(key, value) {
       return new BSTNode(key, value);
     }
+    createTree(options) {
+      return new _BST(__spreadValues(__spreadValues({}, this.options), options));
+    }
     /**
      * 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.
@@ -8228,7 +8328,7 @@ var dataStructureTyped = (() => {
      * current instance of the binary search tree
      * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
+    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.options.iterationType) {
       function hasNoUndefined(arr) {
         return arr.indexOf(void 0) === -1;
       }
@@ -8314,7 +8414,7 @@ var dataStructureTyped = (() => {
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey(beginRoot = this.root, iterationType = this.iterationType) {
+    lastKey(beginRoot = this.root, iterationType = this.options.iterationType) {
       var _a, _b, _c, _d, _e, _f;
       if (this._compare(0, 1) === "lt" /* lt */)
         return (_b = (_a = this.getRightMost(beginRoot, iterationType)) == null ? void 0 : _a.key) != null ? _b : 0;
@@ -8410,7 +8510,7 @@ var dataStructureTyped = (() => {
      * 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) {
+    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.options.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return [];
@@ -8486,7 +8586,7 @@ var dataStructureTyped = (() => {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = "lt" /* lt */, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = "lt" /* lt */, targetNode = this.root, iterationType = this.options.iterationType) {
       targetNode = this.ensureNotKey(targetNode);
       const ans = [];
       if (!targetNode)
@@ -8549,7 +8649,7 @@ var dataStructureTyped = (() => {
      * values:
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
-    perfectlyBalance(iterationType = this.iterationType) {
+    perfectlyBalance(iterationType = this.options.iterationType) {
       const sorted = this.dfs((node) => node, "in"), n = sorted.length;
       this.clear();
       if (sorted.length < 1)
@@ -8598,7 +8698,7 @@ var dataStructureTyped = (() => {
      * to check if the AVL tree is balanced. It can have two possible values:
      * @returns a boolean value.
      */
-    isAVLBalanced(iterationType = this.iterationType) {
+    isAVLBalanced(iterationType = this.options.iterationType) {
       var _a, _b;
       if (!this.root)
         return true;
@@ -8656,7 +8756,7 @@ var dataStructureTyped = (() => {
      * than), CP.lt (less than), or CP.eq (equal).
      */
     _compare(a, b) {
-      const compared = this._comparator(a, b);
+      const compared = this.options.comparator(a, b);
       if (compared > 0)
         return "gt" /* gt */;
       else if (compared < 0)
@@ -9100,7 +9200,7 @@ var dataStructureTyped = (() => {
       this.height = 0;
     }
   };
-  var AVLTree = class extends BST {
+  var AVLTree = class _AVLTree extends BST {
     /**
      * This is a constructor function for an AVL tree data structure in TypeScript.
      * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
@@ -9109,6 +9209,12 @@ var dataStructureTyped = (() => {
      */
     constructor(options) {
       super(options);
+      __publicField(this, "options");
+      if (options) {
+        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
+      } else {
+        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
+      }
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
@@ -9122,6 +9228,9 @@ var dataStructureTyped = (() => {
     createNode(key, value) {
       return new AVLTreeNode(key, value);
     }
+    createTree(options) {
+      return new _AVLTree(__spreadValues(__spreadValues({}, this.options), options));
+    }
     /**
      * 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.
@@ -9485,7 +9594,7 @@ var dataStructureTyped = (() => {
       this.color = color;
     }
   };
-  var RedBlackTree = class extends BST {
+  var RedBlackTree = class _RedBlackTree extends BST {
     /**
      * The constructor function initializes a Red-Black Tree with an optional set of options.
      * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
@@ -9493,10 +9602,16 @@ var dataStructureTyped = (() => {
      */
     constructor(options) {
       super(options);
-      __publicField(this, "NIL", new RedBlackTreeNode(NaN));
+      __publicField(this, "Sentinel", new RedBlackTreeNode(NaN));
+      __publicField(this, "options");
       __publicField(this, "_root");
       __publicField(this, "_size", 0);
-      this._root = this.NIL;
+      if (options) {
+        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
+      } else {
+        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
+      }
+      this._root = this.Sentinel;
     }
     get root() {
       return this._root;
@@ -9504,6 +9619,12 @@ var dataStructureTyped = (() => {
     get size() {
       return this._size;
     }
+    createNode(key, value, color = 0 /* BLACK */) {
+      return new RedBlackTreeNode(key, value, color);
+    }
+    createTree(options) {
+      return new _RedBlackTree(__spreadValues(__spreadValues({}, this.options), options));
+    }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -9532,11 +9653,11 @@ var dataStructureTyped = (() => {
       } else {
         return;
       }
-      node.left = this.NIL;
-      node.right = this.NIL;
+      node.left = this.Sentinel;
+      node.right = this.Sentinel;
       let y = void 0;
       let x = this.root;
-      while (x !== this.NIL) {
+      while (x !== this.Sentinel) {
         y = x;
         if (x) {
           if (node.key < x.key) {
@@ -9568,9 +9689,6 @@ var dataStructureTyped = (() => {
       this._fixInsert(node);
       this._size++;
     }
-    createNode(key, value, color = 0 /* BLACK */) {
-      return new RedBlackTreeNode(key, value, color);
-    }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -9595,9 +9713,9 @@ var dataStructureTyped = (() => {
       if (identifier === null)
         return ans;
       const helper = (node) => {
-        let z = this.NIL;
+        let z = this.Sentinel;
         let x, y;
-        while (node !== this.NIL) {
+        while (node !== this.Sentinel) {
           if (node && callback(node) === identifier) {
             z = node;
           }
@@ -9607,16 +9725,16 @@ var dataStructureTyped = (() => {
             node = node == null ? void 0 : node.left;
           }
         }
-        if (z === this.NIL) {
+        if (z === this.Sentinel) {
           this._size--;
           return;
         }
         y = z;
         let yOriginalColor = y.color;
-        if (z.left === this.NIL) {
+        if (z.left === this.Sentinel) {
           x = z.right;
           this._rbTransplant(z, z.right);
-        } else if (z.right === this.NIL) {
+        } else if (z.right === this.Sentinel) {
           x = z.left;
           this._rbTransplant(z, z.left);
         } else {
@@ -9644,7 +9762,7 @@ var dataStructureTyped = (() => {
       return ans;
     }
     isRealNode(node) {
-      return node !== this.NIL && node !== void 0;
+      return node !== this.Sentinel && node !== void 0;
     }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
@@ -9671,7 +9789,7 @@ var dataStructureTyped = (() => {
      * `getNodes` method, which is called within the `getNode` method.
      * @returns a value of type `N`, `null`, or `undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
       var _a;
       if (identifier instanceof BinaryTreeNode)
         callback = (node) => node;
@@ -9692,11 +9810,11 @@ var dataStructureTyped = (() => {
      */
     getSuccessor(x) {
       var _a;
-      if (x.right !== this.NIL) {
+      if (x.right !== this.Sentinel) {
         return (_a = this.getLeftMost(x.right)) != null ? _a : void 0;
       }
       let y = x.parent;
-      while (y !== this.NIL && y !== void 0 && x === y.right) {
+      while (y !== this.Sentinel && y !== void 0 && x === y.right) {
         x = y;
         y = y.parent;
       }
@@ -9716,18 +9834,18 @@ var dataStructureTyped = (() => {
      * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
     getPredecessor(x) {
-      if (x.left !== this.NIL) {
+      if (x.left !== this.Sentinel) {
         return this.getRightMost(x.left);
       }
       let y = x.parent;
-      while (y !== this.NIL && x === y.left) {
+      while (y !== this.Sentinel && x === y.left) {
         x = y;
         y = y.parent;
       }
       return y;
     }
     clear() {
-      this._root = this.NIL;
+      this._root = this.Sentinel;
       this._size = 0;
     }
     _setRoot(v) {
@@ -9751,7 +9869,7 @@ var dataStructureTyped = (() => {
       if (x.right) {
         const y = x.right;
         x.right = y.left;
-        if (y.left !== this.NIL) {
+        if (y.left !== this.Sentinel) {
           if (y.left)
             y.left.parent = x;
         }
@@ -9783,7 +9901,7 @@ var dataStructureTyped = (() => {
       if (x.left) {
         const y = x.left;
         x.left = y.right;
-        if (y.right !== this.NIL) {
+        if (y.right !== this.Sentinel) {
           if (y.right)
             y.right.parent = x;
         }
@@ -9967,16 +10085,22 @@ var dataStructureTyped = (() => {
       this.count = count;
     }
   };
-  var TreeMultimap = class extends AVLTree {
+  var TreeMultimap = class _TreeMultimap extends AVLTree {
     /**
      * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
      * merge duplicated values.
      * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
      * TreeMultimap.
      */
-    constructor(options) {
+    constructor(options = { iterationType: "ITERATIVE" /* ITERATIVE */ }) {
       super(options);
+      __publicField(this, "options");
       __publicField(this, "_count", 0);
+      if (options) {
+        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
+      } else {
+        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
+      }
     }
     get count() {
       return this._count;
@@ -9993,6 +10117,9 @@ var dataStructureTyped = (() => {
     createNode(key, value, count) {
       return new TreeMultimapNode(key, value, count);
     }
+    createTree(options) {
+      return new _TreeMultimap(__spreadValues(__spreadValues({}, this.options), options));
+    }
     /**
      * 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.
@@ -10122,7 +10249,7 @@ var dataStructureTyped = (() => {
      * values:
      * @returns a boolean value.
      */
-    perfectlyBalance(iterationType = this.iterationType) {
+    perfectlyBalance(iterationType = this.options.iterationType) {
       const sorted = this.dfs((node) => node, "in"), n = sorted.length;
       if (sorted.length < 1)
         return false;