data-structure-typed 1.52.0 → 1.52.2

package/dist/mjs/data-structures/binary-tree/binary-tree.js

@@ -40,7 +40,7 @@ export class BinaryTreeNode {
     }
     /**
      * 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) {
@@ -60,7 +60,7 @@ export class BinaryTreeNode {
     }
     /**
      * 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) {
@@ -98,7 +98,7 @@ export class BinaryTree extends IterableEntryBase {
     iterationType = 'ITERATIVE';
     /**
      * 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
@@ -174,8 +174,8 @@ export class BinaryTree extends IterableEntryBase {
     /**
      * 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.
@@ -219,8 +219,8 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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
@@ -255,8 +255,8 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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.
      */
@@ -265,8 +265,8 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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) {
@@ -276,8 +276,8 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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) {
@@ -285,8 +285,8 @@ export class BinaryTree extends IterableEntryBase {
     }
     /**
      * 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) {
@@ -295,8 +295,8 @@ export class BinaryTree extends IterableEntryBase {
     /**
      * 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) {
@@ -344,10 +344,10 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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.
@@ -449,7 +449,7 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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`.
@@ -544,7 +544,7 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -603,7 +603,7 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -647,7 +647,7 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -677,7 +677,7 @@ export class BinaryTree extends IterableEntryBase {
      * @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
@@ -726,10 +726,10 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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) {
@@ -744,7 +744,7 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -804,10 +804,10 @@ export class BinaryTree extends IterableEntryBase {
      * 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
@@ -836,9 +836,9 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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.
@@ -881,9 +881,9 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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
@@ -921,8 +921,8 @@ export class BinaryTree extends IterableEntryBase {
                     if (!this.isRealNode(node.right) || last === node.right) {
                         node = stack.pop();
                         if (this.isRealNode(node)) {
-                            const leftMinHeight = this.isRealNode(node.left) ? depths.get(node.left) ?? -1 : -1;
-                            const rightMinHeight = this.isRealNode(node.right) ? depths.get(node.right) ?? -1 : -1;
+                            const leftMinHeight = this.isRealNode(node.left) ? (depths.get(node.left) ?? -1) : -1;
+                            const rightMinHeight = this.isRealNode(node.right) ? (depths.get(node.right) ?? -1) : -1;
                             depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
                             last = node;
                             node = null;
@@ -945,8 +945,8 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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
@@ -975,9 +975,9 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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.
@@ -1016,9 +1016,9 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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:
@@ -1118,7 +1118,7 @@ export class BinaryTree extends IterableEntryBase {
      * 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.
@@ -1249,7 +1249,7 @@ export class BinaryTree extends IterableEntryBase {
      * @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.
@@ -1327,7 +1327,7 @@ export class BinaryTree extends IterableEntryBase {
      * @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.
@@ -1405,7 +1405,7 @@ export class BinaryTree extends IterableEntryBase {
      * @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
@@ -1591,7 +1591,7 @@ export class BinaryTree extends IterableEntryBase {
      * 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.
@@ -1674,7 +1674,7 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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:
@@ -1747,10 +1747,10 @@ export class BinaryTree extends IterableEntryBase {
      * 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.
@@ -1814,7 +1814,7 @@ export class BinaryTree extends IterableEntryBase {
      *
      * 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) {

package/dist/mjs/data-structures/binary-tree/bst.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, Comparator, CP, DFSOrderPattern, IterationType, KeyOrNodeOrEntry } from '../../types';
+import type { BSTNested, BSTNKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNKeyOrNodeOrEntry, Comparator, CP, DFSOrderPattern, IterationType, OptBSTN } from '../../types';
 import { BTNEntry } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
@@ -17,26 +17,26 @@ export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE>
      * The function returns the value of the `_left` property.
      * @returns The `_left` property of the current object is being returned.
      */
-    get left(): NODE | undefined;
+    get left(): OptBSTN<NODE>;
     /**
      * 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: NODE | undefined);
+    set left(v: OptBSTN<NODE>);
     protected _right?: NODE;
     /**
      * The function returns the right node of a binary tree or undefined if there is no right node.
      * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
      * `undefined`.
      */
-    get right(): NODE | undefined;
+    get right(): OptBSTN<NODE>;
     /**
      * 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: NODE | undefined);
+    set right(v: OptBSTN<NODE>);
 }
 /**
  * 1. Node Order: Each node's left child has a lesser value, and the right child has a greater value.
@@ -56,13 +56,13 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @param [options] - An optional object that contains additional options for the Binary Search Tree.
      * It can include a comparator function that defines the order of the elements in the tree.
      */
-    constructor(keysOrNodesOrEntriesOrRawElements?: Iterable<R | KeyOrNodeOrEntry<K, V, NODE>>, options?: BSTOptions<K, V, R>);
+    constructor(keysOrNodesOrEntriesOrRawElements?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: BSTOptions<K, V, R>);
     protected _root?: NODE;
     /**
      * The function returns the root node of a tree structure.
      * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
      */
-    get root(): NODE | undefined;
+    get root(): OptBSTN<NODE>;
     /**
      * The function creates a new BSTNode with the given key and value and returns it.
      * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
@@ -82,21 +82,21 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
     createTree(options?: Partial<BSTOptions<K, V, R>>): TREE;
     /**
      * 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.
      * @returns either a NODE object or undefined.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined;
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): OptBSTN<NODE>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
      * 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
@@ -105,27 +105,27 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @returns The method is returning either the node that was ensured or `undefined` if the node could
      * not be ensured.
      */
-    ensureNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | undefined;
+    ensureNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBSTN<NODE>;
     /**
      * 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.
      */
-    isNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is NODE;
+    isNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is NODE;
     /**
      * Time Complexity: O(log n)
      * 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.
      */
-    add(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
+    add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -151,7 +151,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @returns The function `addMany` returns an array of booleans indicating whether each element was
      * successfully inserted into the data structure.
      */
-    addMany(keysOrNodesOrEntriesOrRawElements: Iterable<R | KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
+    addMany(keysOrNodesOrEntriesOrRawElements: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
@@ -167,14 +167,14 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @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
      * iteration to be performed. It can have two possible values:
      * @returns The method `getNodes` returns an array of `NODE` objects.
      */
-    getNodes<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    getNodes<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -200,7 +200,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * of the following values:
      * @returns The method is returning a NODE object or undefined.
      */
-    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: R | BSTNKeyOrNode<K, NODE>, iterationType?: IterationType): NODE | undefined;
+    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: R | BSTNKeyOrNode<K, NODE>, iterationType?: IterationType): OptBSTN<NODE>;
     /**
      * Time Complexity: O(k log n)
      * Space Complexity: O(k + log n)
@@ -218,7 +218,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * It has a default value of `'ITERATIVE'`.
      * @returns The method is returning a NODE object or undefined.
      */
-    getNodeByKey(key: K, iterationType?: IterationType): NODE | undefined;
+    getNodeByKey(key: K, iterationType?: IterationType): OptBSTN<NODE>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
@@ -235,7 +235,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @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
@@ -243,7 +243,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
+    dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -257,7 +257,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @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
@@ -265,7 +265,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * the following values:
      * @returns an array of the return type of the callback function.
      */
-    bfs<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
+    bfs<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -279,7 +279,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @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
@@ -288,7 +288,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @returns The method is returning a two-dimensional array of the return type of the callback
      * function.
      */
-    listLevels<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[][];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -305,7 +305,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @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,
@@ -314,7 +314,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @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<C extends BTNCallback<NODE>>(callback?: C, lesserOrGreater?: CP, targetNode?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
+    lesserOrGreaterTraverse<C extends BTNCallback<NODE>>(callback?: C, lesserOrGreater?: CP, targetNode?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -363,7 +363,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
     /**
      * 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.
      */
-    protected _setRoot(v: NODE | undefined): void;
+    protected _setRoot(v: OptBSTN<NODE>): void;
 }