data-structure-typed 1.52.0 → 1.52.2

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

@@ -3564,6 +3564,11 @@ var dataStructureTyped = (() => {
       super(options);
       __publicField(this, "_elements", []);
       __publicField(this, "_offset", 0);
+      __publicField(this, "_autoCompactRatio", 0.5);
+      if (options) {
+        const { autoCompactRatio = 0.5 } = options;
+        this._autoCompactRatio = autoCompactRatio;
+      }
       if (elements) {
         for (const el of elements) {
           if (this.toElementFn)
@@ -3624,6 +3629,21 @@ var dataStructureTyped = (() => {
     get last() {
       return this.size > 0 ? this.elements[this.elements.length - 1] : void 0;
     }
+    /**
+     * This function returns the value of the autoCompactRatio property.
+     * @returns The `autoCompactRatio` property of the object, which is a number.
+     */
+    get autoCompactRatio() {
+      return this._autoCompactRatio;
+    }
+    /**
+     * The above function sets the autoCompactRatio property to a specified number in TypeScript.
+     * @param {number} v - The parameter `v` represents the value that will be assigned to the
+     * `_autoCompactRatio` property.
+     */
+    set autoCompactRatio(v) {
+      this._autoCompactRatio = v;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -3634,7 +3654,6 @@ var dataStructureTyped = (() => {
      *
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
-     * @static
      * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
      * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
      * array.
@@ -3675,10 +3694,8 @@ var dataStructureTyped = (() => {
         return void 0;
       const first = this.first;
       this._offset += 1;
-      if (this.offset * 2 < this.elements.length)
-        return first;
-      this._elements = this.elements.slice(this.offset);
-      this._offset = 0;
+      if (this.offset / this.elements.length > this.autoCompactRatio)
+        this.compact();
       return first;
     }
     /**
@@ -3754,6 +3771,16 @@ var dataStructureTyped = (() => {
       this._elements = [];
       this._offset = 0;
     }
+    /**
+     * The `compact` function in TypeScript slices the elements array based on the offset and resets the
+     * offset to zero.
+     * @returns The `compact()` method is returning a boolean value of `true`.
+     */
+    compact() {
+      this._elements = this.elements.slice(this.offset);
+      this._offset = 0;
+      return true;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -3863,6 +3890,7 @@ var dataStructureTyped = (() => {
     constructor(elements = [], options) {
       super(options);
       __publicField(this, "_bucketSize", 1 << 12);
+      __publicField(this, "_maxLen", -1);
       __publicField(this, "_bucketFirst", 0);
       __publicField(this, "_firstInBucket", 0);
       __publicField(this, "_bucketLast", 0);
@@ -3871,9 +3899,11 @@ var dataStructureTyped = (() => {
       __publicField(this, "_buckets", []);
       __publicField(this, "_size", 0);
       if (options) {
-        const { bucketSize } = options;
+        const { bucketSize, maxLen } = options;
         if (typeof bucketSize === "number")
           this._bucketSize = bucketSize;
+        if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0)
+          this._maxLen = maxLen;
       }
       let _size;
       if ("length" in elements) {
@@ -3910,6 +3940,14 @@ var dataStructureTyped = (() => {
     get bucketSize() {
       return this._bucketSize;
     }
+    /**
+     * The maxLen function returns the max length of the deque.
+     *
+     * @return The max length of the deque
+     */
+    get maxLen() {
+      return this._maxLen;
+    }
     /**
      * The function returns the value of the protected variable `_bucketFirst`.
      * @returns The value of the `_bucketFirst` property.
@@ -4009,6 +4047,8 @@ var dataStructureTyped = (() => {
       }
       this._size += 1;
       this._buckets[this._bucketLast][this._lastInBucket] = element;
+      if (this._maxLen > 0 && this._size > this._maxLen)
+        this.shift();
       return true;
     }
     /**
@@ -4071,6 +4111,8 @@ var dataStructureTyped = (() => {
       }
       this._size += 1;
       this._buckets[this._bucketFirst][this._firstInBucket] = element;
+      if (this._maxLen > 0 && this._size > this._maxLen)
+        this.pop();
       return true;
     }
     /**
@@ -6710,7 +6752,7 @@ var dataStructureTyped = (() => {
       if (vertex) {
         const neighbors = this.getNeighbors(vertex);
         for (const neighbor of neighbors) {
-          this._inEdgeMap.delete(neighbor);
+          this.deleteEdgeSrcToDest(vertex, neighbor);
         }
         this._outEdgeMap.delete(vertex);
         this._inEdgeMap.delete(vertex);
@@ -7791,7 +7833,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function sets the left child of a node and updates its parent reference.
-     * @param {NODE | null | undefined} v - The parameter `v` can be of type `NODE`, `null`, or
+     * @param {OptBTNOrNull<NODE>} v - The parameter `v` can be of type `NODE`, `null`, or
      * `undefined`.
      */
     set left(v) {
@@ -7810,7 +7852,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function sets the right child of a node and updates its parent.
-     * @param {NODE | null | undefined} v - The parameter `v` can be of type `NODE`, `null`, or
+     * @param {OptBTNOrNull<NODE>} v - The parameter `v` can be of type `NODE`, `null`, or
      * `undefined`.
      */
     set right(v) {
@@ -7839,7 +7881,7 @@ var dataStructureTyped = (() => {
   var BinaryTree = class _BinaryTree extends IterableEntryBase {
     /**
      * The constructor function initializes a binary tree object with optional keysOrNodesOrEntriesOrRawElements and options.
-     * @param [keysOrNodesOrEntriesOrRawElements] - Optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * @param [keysOrNodesOrEntriesOrRawElements] - Optional iterable of BTNKeyOrNodeOrEntry 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
@@ -7917,8 +7959,8 @@ var dataStructureTyped = (() => {
     /**
      * The function `keyValueOrEntryOrRawElementToNode` converts a key-value pair, entry, or raw element
      * into a node object.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `keyValueOrEntryOrRawElementToNode` function. It represents the value associated with a key in a
      * key-value pair. If provided, it will be used to create a node with the specified key and value.
@@ -7962,8 +8004,8 @@ var dataStructureTyped = (() => {
      *
      * The `ensureNode` function checks if the input is a valid node and returns it, or converts it to a
      * node if it is a key or entry.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, `KeyOrNodeOrEntry<K, V, NODE>`, or
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, `BTNKeyOrNodeOrEntry<K, V, NODE>`, or
      * a raw element.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
      * parameter that specifies the type of iteration to be used when searching for a node. It has a
@@ -7998,8 +8040,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of the BinaryTreeNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `BinaryTreeNode` class.
      */
@@ -8008,8 +8050,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if a given node is a valid node in a binary search tree.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
-     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
     isRealNode(node) {
@@ -8019,8 +8061,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if a given node is a real node or null.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
-     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
     isNodeOrNull(node) {
@@ -8028,8 +8070,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if a given node is equal to the NIL value.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
-     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
     isNIL(node) {
@@ -8038,8 +8080,8 @@ var dataStructureTyped = (() => {
     /**
      * The function checks if the input is an array with two elements, indicating it is a binary tree
      * node entry.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
     isEntry(keyOrNodeOrEntryOrRawElement) {
@@ -8087,10 +8129,10 @@ var dataStructureTyped = (() => {
      *
      * The `add` function is used to insert a new node into a binary tree, checking for duplicate keys
      * and finding the appropriate insertion position.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
      * `keyOrNodeOrEntryOrRawElement` parameter can accept a value of type `R`, which represents the key,
      * node, entry, or raw element to be added to the tree. It can also accept a value of type
-     * `KeyOrNodeOrEntry<K, V, NODE>
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key being added to the tree. It represents the value that will be stored in the tree for the given
      * key.
@@ -8185,7 +8227,7 @@ var dataStructureTyped = (() => {
      *
      * The `refill` function clears the current data and adds new data to the collection.
      * @param keysOrNodesOrEntriesOrRawElements - An iterable collection of keys, nodes, entries, or raw
-     * elements. These can be of any type (R) or a specific type (KeyOrNodeOrEntry<K, V, NODE>).
+     * elements. These can be of any type (R) or a specific type (BTNKeyOrNodeOrEntry<K, V, NODE>).
      * @param [values] - The `values` parameter is an optional iterable of values that will be associated
      * with the keys or nodes being added. If provided, the values will be assigned to the corresponding
      * keys or nodes. If not provided, the values will be set to `undefined`.
@@ -8276,7 +8318,7 @@ var dataStructureTyped = (() => {
      * the identifier or all nodes that match the identifier. If set to true, only the first matching
      * node will be returned. If set to false, all matching nodes will be returned. The default value is
      * false.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the search. It can be either a node object, a key-value pair, or a key. If it is not
      * provided, the `root` of the data structure is used as the starting point.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
@@ -8334,7 +8376,7 @@ var dataStructureTyped = (() => {
      * the `C` callback function, or it can be `null` or `undefined`.
      * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
      * node matches the desired criteria. It should return a value that can be used to identify the node.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for searching nodes in a tree structure. It can be either a root node, a key-value pair, or
      * a node entry. If not provided, the search will start from the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -8379,7 +8421,7 @@ var dataStructureTyped = (() => {
      * callback function `C`. It can also be `null` or `undefined` if no identifier is provided.
      * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
      * node matches the given identifier. It is optional and defaults to `this._DEFAULT_CALLBACK`.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the search in the binary tree. It can be either a root node of the tree or a key, node,
      * or entry object that exists in the tree. If no specific starting point is provided, the search
      * will begin from the root of the
@@ -8410,7 +8452,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be used to determine
      * whether a node should be included in the result or not. It is of type `C`, which extends the
      * `BTNCallback<NODE>` type.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the iteration in the data structure. It can be either a root node, a key-value pair, or
      * a node entry. If not specified, it defaults to the root of the data structure.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -8459,10 +8501,10 @@ var dataStructureTyped = (() => {
      *
      * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
      * height of the tree.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The parameter `beginRoot` is optional and
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The parameter `beginRoot` is optional and
      * has a default value of `this.root`. It represents the starting point for checking if the tree is
      * perfectly balanced. It can be either a root node (`R`), a key or node or entry
-     * (`KeyOrNodeOrEntry<K, V, NODE
+     * (`BTNKeyOrNodeOrEntry<K, V, NODE
      * @returns a boolean value.
      */
     isPerfectlyBalanced(beginRoot = this.root) {
@@ -8477,7 +8519,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `isBST` checks if a binary search tree is valid, either recursively or iteratively.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for checking if a binary search tree (BST) is valid. It can be either a root node
      * of the BST, a key value of a node in the BST, or an entry object containing both the key and value
      * of a node in the BST
@@ -8534,10 +8576,10 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function calculates the depth of a given node or key in a tree-like data structure.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} dist - The `dist` parameter can be either a `R`
-     * (representing a root node), or a `KeyOrNodeOrEntry<K, V, NODE>` (representing a key, node, or
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} dist - The `dist` parameter can be either a `R`
+     * (representing a root node), or a `BTNKeyOrNodeOrEntry<K, V, NODE>` (representing a key, node, or
      * entry).
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is optional and
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is optional and
      * represents the starting point from which to calculate the depth. It can be either a reference to a
      * node in the tree or a key-value pair or an entry object. If not provided, the default value is
      * `this.root`, which refers to the root node
@@ -8566,9 +8608,9 @@ var dataStructureTyped = (() => {
      *
      * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
      * or iterative approach.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for calculating the height of a tree. It can be either a root node (`R`), a key or
-     * node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current tree.
+     * node or entry (`BTNKeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current tree.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
      * iteration used to calculate the height of the tree. It can have two possible values:
      * @returns the maximum height of the binary tree.
@@ -8610,9 +8652,9 @@ var dataStructureTyped = (() => {
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for calculating the minimum height of a tree. It can be either a root node (`R`), a
-     * key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current
+     * key or node or entry (`BTNKeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current
      * tree.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
      * iteration to be used when calculating the minimum height of the tree. It can have two possible
@@ -8672,8 +8714,8 @@ var dataStructureTyped = (() => {
      *
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
      * up to the root node, with an option to reverse the order of the nodes.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginNode - The `beginNode` parameter can be either of
-     * type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginNode - The `beginNode` parameter can be either of
+     * type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
      * resulting path should be reversed or not. If `isReverse` is set to `true`, the path will be
      * reversed before returning it. If `isReverse` is set to `false` or not provided, the path will
@@ -8701,9 +8743,9 @@ var dataStructureTyped = (() => {
      *
      * The `getLeftMost` function returns the leftmost node in a binary tree, either using recursive or
      * iterative traversal.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for finding the leftmost node in a binary tree. It can be either a root node (`R`),
-     * a key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
+     * a key or node or entry (`BTNKeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
      * of iteration to be performed. It can have two possible values:
      * @returns The function `getLeftMost` returns the leftmost node in a binary tree.
@@ -8740,9 +8782,9 @@ var dataStructureTyped = (() => {
      *
      * The `getRightMost` function returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for finding the rightmost node in a binary tree. It can be either a root node
-     * (`R`), a key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
+     * (`R`), a key or node or entry (`BTNKeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
      * of iteration to be performed when finding the rightmost node in a binary tree. It can have two
      * possible values:
@@ -8838,7 +8880,7 @@ var dataStructureTyped = (() => {
      * return type of the callback function is determined by the generic type `C`.
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter determines the order in which the
      * nodes are visited during the depth-first search. It can have one of the following values:
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point of the depth-first search. It can be either a node object, a key-value pair, or a key. If it
      * is a key or key-value pair, the method will find the corresponding node in the tree and start the
      * search from there.
@@ -8962,7 +9004,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the breadth-first search traversal. It takes a single argument, which is the current node being
      * visited, and returns a value of any type.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point of the breadth-first search. It can be either a root node of a tree or a key, node,
      * or entry object. If no value is provided, the `root` property of the class is used as the default
      * starting point.
@@ -9037,7 +9079,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the tree. It takes a node as an argument and returns a value. The return type of the callback
      * function is determined by the generic type `C` which extends `BTNCallback<NODE | null>`.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
      * starting point for traversing the tree. It can be either a root node, a key-value pair, or a node
      * entry. If no value is provided, the `root` property of the class is used as the default starting
      * point.
@@ -9112,7 +9154,7 @@ var dataStructureTyped = (() => {
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `morris` function is used
      * to specify the order in which the nodes of a binary tree are traversed. It can take one of the
      * following values:
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the traversal. It can be either a node object, a key, or an entry object. If no value is
      * provided, the `root` of the tree is used as the starting point.
      * @returns The function `morris` returns an array of values that are the return values of the
@@ -9299,7 +9341,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n)
      *
      * The `print` function in TypeScript prints the binary tree structure with customizable options.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for printing the binary tree. It can be either a node of the binary tree or a key or entry
      * that exists in the binary tree. If no value is provided, the root of the binary tree will be used
      * as the starting point.
@@ -9381,7 +9423,7 @@ var dataStructureTyped = (() => {
      *
      * The `_displayAux` function is responsible for generating the display layout of a binary tree node,
      * taking into account various options such as whether to show null, undefined, or NaN nodes.
-     * @param {NODE | null | undefined} node - The `node` parameter represents a node in a binary tree.
+     * @param {OptBTNOrNull<NODE>} node - The `node` parameter represents a node in a binary tree.
      * It can be of type `NODE`, `null`, or `undefined`.
      * @param {BinaryTreePrintOptions} options - The `options` parameter is an object that contains the
      * following properties:
@@ -9441,10 +9483,10 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `_swapProperties` swaps the key-value properties between two nodes.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} srcNode - The source node that will be swapped with the
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} srcNode - The source node that will be swapped with the
      * destination node. It can be either an instance of the class `R`, or an object of type
-     * `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} destNode - The `destNode` parameter is the node where
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} destNode - The `destNode` parameter is the node where
      * the properties will be swapped with the `srcNode`.
      * @returns either the `destNode` object with its properties swapped with the `srcNode` object's
      * properties, or `undefined` if either `srcNode` or `destNode` is falsy.
@@ -9507,7 +9549,7 @@ var dataStructureTyped = (() => {
      *
      * The function sets the root property of an object to the provided value, and also updates the
      * parent property of the new root.
-     * @param {NODE | null | undefined} v - The parameter `v` is of type `NODE | null | undefined`. This
+     * @param {OptBTNOrNull<NODE>} v - The parameter `v` is of type `OptBTNOrNull<NODE>`. This
      * means that it can accept a value of type `NODE`, `null`, or `undefined`.
      */
     _setRoot(v) {
@@ -9561,7 +9603,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function sets the left child of a node and updates the parent reference of the child.
-     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be an
+     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be an
      * instance of the `NODE` class or `undefined`.
      */
     set left(v) {
@@ -9580,7 +9622,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function sets the right child of a node and updates the parent reference of the child.
-     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be a
+     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be a
      * `NODE` object or `undefined`.
      */
     set right(v) {
@@ -9656,8 +9698,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
-     * type R or KeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
+     * type R or BTNKeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
      * element.
      * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
      * value associated with a key in a key-value pair.
@@ -9673,7 +9715,7 @@ var dataStructureTyped = (() => {
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
      * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, which represents the key, node,
      * entry, or raw element that needs to be ensured in the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
@@ -9688,8 +9730,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `BSTNode` class.
      */
@@ -9701,8 +9743,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key in the binary search tree. If provided, it will be stored in the node along with the key.
      * @returns a boolean value.
@@ -9861,7 +9903,7 @@ var dataStructureTyped = (() => {
      * @param [onlyOne=false] - A boolean value indicating whether to return only the first matching node
      * or all matching nodes. If set to true, only the first matching node will be returned. If set to
      * false, all matching nodes will be returned. The default value is false.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the search in the binary tree. It can be either a node object, a key-value pair, or an
      * entry object. If it is not provided, the `root` of the binary tree is used as the starting point.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
@@ -9983,7 +10025,7 @@ var dataStructureTyped = (() => {
      * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
      * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
      * take one of the following values:
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
      * node entry. If not specified, the default value is the root of the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
@@ -10007,7 +10049,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * visited during the breadth-first search. It should take a single argument, which is the current
      * node being visited, and it can return a value of any type.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
      * object. If no value is provided, the default value is the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -10031,7 +10073,7 @@ var dataStructureTyped = (() => {
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
      * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the
      * tree during the iteration process.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for listing the levels of the binary tree. It can be either a root node of the tree, a
      * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
      * value is provided, the root of
@@ -10059,7 +10101,7 @@ var dataStructureTyped = (() => {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
      * 0, or 1, where:
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} targetNode - The `targetNode` parameter is the node in
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} targetNode - The `targetNode` parameter is the node in
      * the binary tree that you want to start traversing from. It can be specified either by providing
      * the key of the node, the node itself, or an entry containing the key and value of the node. If no
      * `targetNode` is provided,
@@ -10229,7 +10271,7 @@ var dataStructureTyped = (() => {
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
-     * @param {NODE | undefined} v - v is a parameter of type NODE or undefined.
+     * @param {OptBSTN<NODE>} v - v is a parameter of type NODE or undefined.
      */
     _setRoot(v) {
       if (v) {
@@ -10879,8 +10921,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of AVLTreeNode.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `AVLTreeNode` class.
      */
@@ -10898,8 +10940,8 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a class and inserts a key-value pair into a data
      * structure, then balances the path.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept values of type `R`, `KeyOrNodeOrEntry<K, V, NODE>`, or
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept values of type `R`, `BTNKeyOrNodeOrEntry<K, V, NODE>`, or
      * `RawElement`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key or node being added to the data structure.
@@ -11218,8 +11260,8 @@ var dataStructureTyped = (() => {
      *
      * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
      * to restore balance in an AVL tree after inserting a node.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The `node` parameter can be of type `R` or
-     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The `node` parameter can be of type `R` or
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      */
     _balancePath(node) {
       node = this.ensureNode(node);
@@ -11367,8 +11409,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `RedBlackTreeNode` class.
      */
@@ -11386,11 +11428,11 @@ var dataStructureTyped = (() => {
     //  *
     //  * The function `keyValueOrEntryOrRawElementToNode` takes a key, value, or entry and returns a node if it is
     //  * valid, otherwise it returns undefined.
-    //  * @param {KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The key, value, or entry to convert.
+    //  * @param {BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The key, value, or entry to convert.
     //  * @param {V} [value] - The value associated with the key (if `keyOrNodeOrEntryOrRawElement` is a key).
     //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
     //  */
-    // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined {
+    // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined {
     //
     //   if (keyOrNodeOrEntryOrRawElement === null || keyOrNodeOrEntryOrRawElement === undefined) return;
     //   if (this.isNode(keyOrNodeOrEntryOrRawElement)) return keyOrNodeOrEntryOrRawElement;
@@ -11435,8 +11477,8 @@ var dataStructureTyped = (() => {
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key in the data structure. It represents the value that you want to add or update in the data
      * structure.
@@ -11942,8 +11984,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of AVLTreeMultiMapNode.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `AVLTreeMultiMapNode` class.
      */
@@ -11953,8 +11995,8 @@ var dataStructureTyped = (() => {
     /**
      * The function `keyValueOrEntryOrRawElementToNode` converts a key, value, entry, or raw element into
      * a node object.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
-     * `keyOrNodeOrEntryOrRawElement` parameter can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * `keyOrNodeOrEntryOrRawElement` parameter can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `override` function. It represents the value associated with the key in the data structure. If no
      * value is provided, it will default to `undefined`.
@@ -11993,9 +12035,9 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a TypeScript class to add a new node to a data structure
      * and update the count.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
      * `keyOrNodeOrEntryOrRawElement` parameter can accept a value of type `R`, which can be any type. It
-     * can also accept a value of type `KeyOrNodeOrEntry<K, V, NODE>`, which represents a key, node,
+     * can also accept a value of type `BTNKeyOrNodeOrEntry<K, V, NODE>`, which represents a key, node,
      * entry, or raw element
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
@@ -12340,8 +12382,8 @@ var dataStructureTyped = (() => {
     /**
      * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that represents the value
      * associated with the key in the node. It is used when creating a new node or updating the value of
      * an existing node.
@@ -12372,8 +12414,8 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
      * an instance of the `TreeMultiMapNode` class.
      */
@@ -12390,7 +12432,7 @@ var dataStructureTyped = (() => {
      *
      * The function overrides the add method of a class and adds a new node to a data structure, updating
      * the count and returning a boolean indicating success.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
      * `keyOrNodeOrEntryOrRawElement` parameter can accept one of the following types:
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.