graph-typed 1.43.1 → 1.44.0

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

@@ -381,7 +381,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
      * @returns a boolean value.
      */
-    isNodeOrNull(node: any): node is (N | null);
+    isNodeOrNull(node: any): node is N | null;
     /**
      * The function "isNodeKey" checks if a potential key is a number.
      * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
@@ -439,6 +439,13 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * binary tree nodes in a specific order.
      */
     [Symbol.iterator](node?: N | null | undefined): Generator<BTNKey, void, undefined>;
+    /**
+     * The `print` function is used to display a binary tree structure in a visually appealing way.
+     * @param {N | null | undefined} 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:
+     */
+    print(beginRoot?: BTNKey | N | null | undefined): void;
     protected _defaultOneParamCallback: (node: N) => number;
     /**
      * Swap the data of two nodes in the binary tree.
@@ -466,11 +473,4 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * type `N` or `null`.
      */
     protected _setRoot(v: N | null | undefined): void;
-    /**
-     * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {N | null | undefined} 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:
-     */
-    print(beginRoot?: BTNKey | N | null | undefined): void;
 }

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

@@ -1445,6 +1445,68 @@ class BinaryTree {
             }
         }
     }
+    /**
+     * The `print` function is used to display a binary tree structure in a visually appealing way.
+     * @param {N | null | undefined} 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:
+     */
+    print(beginRoot = this.root) {
+        beginRoot = this.ensureNotKey(beginRoot);
+        if (!beginRoot)
+            return;
+        const display = (root) => {
+            const [lines, , ,] = _displayAux(root);
+            for (const line of lines) {
+                console.log(line);
+            }
+        };
+        const _displayAux = (node) => {
+            if (!this.isRealNode(node)) {
+                return [[], 0, 0, 0];
+            }
+            if (this.isRealNode(node) && !this.isRealNode(node.right) && !this.isRealNode(node.left)) {
+                const line = `${node.key}`;
+                const width = line.length;
+                const height = 1;
+                const middle = Math.floor(width / 2);
+                return [[line], width, height, middle];
+            }
+            if (this.isRealNode(node) && !this.isRealNode(node.right)) {
+                const [lines, n, p, x] = _displayAux(node.left);
+                const s = `${node.key}`;
+                const u = s.length;
+                const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
+                const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
+                const shifted_lines = lines.map(line => line + ' '.repeat(u));
+                return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
+            }
+            if (this.isRealNode(node) && !this.isRealNode(node.left)) {
+                const [lines, n, p, u] = _displayAux(node.right);
+                const s = `${node.key}`;
+                const x = s.length;
+                const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
+                const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
+                const shifted_lines = lines.map(line => ' '.repeat(u) + line);
+                return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
+            }
+            const [left, n, p, x] = _displayAux(node.left);
+            const [right, m, q, y] = _displayAux(node.right);
+            const s = `${node.key}`;
+            const u = s.length;
+            const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
+            const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
+            if (p < q) {
+                left.push(...new Array(q - p).fill(' '.repeat(n)));
+            }
+            else if (q < p) {
+                right.push(...new Array(p - q).fill(' '.repeat(m)));
+            }
+            const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
+            return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
+        };
+        display(beginRoot);
+    }
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {N} srcNode - The source node to swap.
@@ -1518,67 +1580,5 @@ class BinaryTree {
         }
         this._root = v;
     }
-    /**
-     * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {N | null | undefined} 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:
-     */
-    print(beginRoot = this.root) {
-        beginRoot = this.ensureNotKey(beginRoot);
-        if (!beginRoot)
-            return;
-        const display = (root) => {
-            const [lines, , ,] = _displayAux(root);
-            for (const line of lines) {
-                console.log(line);
-            }
-        };
-        const _displayAux = (node) => {
-            if (!this.isRealNode(node)) {
-                return [[], 0, 0, 0];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.right) && !this.isRealNode(node.left)) {
-                const line = `${node.key}`;
-                const width = line.length;
-                const height = 1;
-                const middle = Math.floor(width / 2);
-                return [[line], width, height, middle];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.right)) {
-                const [lines, n, p, x] = _displayAux(node.left);
-                const s = `${node.key}`;
-                const u = s.length;
-                const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
-                const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
-                const shifted_lines = lines.map(line => line + ' '.repeat(u));
-                return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.left)) {
-                const [lines, n, p, u] = _displayAux(node.right);
-                const s = `${node.key}`;
-                const x = s.length;
-                const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
-                const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
-                const shifted_lines = lines.map(line => ' '.repeat(u) + line);
-                return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
-            }
-            const [left, n, p, x] = _displayAux(node.left);
-            const [right, m, q, y] = _displayAux(node.right);
-            const s = `${node.key}`;
-            const u = s.length;
-            const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
-            const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
-            if (p < q) {
-                left.push(...new Array(q - p).fill(' '.repeat(n)));
-            }
-            else if (q < p) {
-                right.push(...new Array(p - q).fill(' '.repeat(m)));
-            }
-            const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
-            return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
-        };
-        display(beginRoot);
-    }
 }
 exports.BinaryTree = BinaryTree;

package/dist/data-structures/binary-tree/rb-tree.d.ts

@@ -5,9 +5,9 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BiTreeDeleteResult, BTNCallback, BTNKey, IterationType, RBTNColor, RedBlackTreeNodeNested, RBTreeOptions } from '../../types';
-import { BST, BSTNode } from "./bst";
-import { IBinaryTree } from "../../interfaces";
+import { BiTreeDeleteResult, BTNCallback, BTNKey, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNodeNested } from '../../types';
+import { BST, BSTNode } from './bst';
+import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNodeNested<V>> extends BSTNode<V, N> {
     color: RBTNColor;
     constructor(key: BTNKey, value?: V, color?: RBTNColor);
@@ -20,6 +20,7 @@ export declare class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N>
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
 export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNode<V, RedBlackTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
+    NIL: N;
     /**
      * 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
@@ -30,7 +31,6 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
     get root(): N;
     protected _size: number;
     get size(): number;
-    NIL: N;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)

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

@@ -33,8 +33,8 @@ class RedBlackTree extends bst_1.BST {
      */
     constructor(options) {
         super(options);
-        this._size = 0;
         this.NIL = new RedBlackTreeNode(NaN);
+        this._size = 0;
         this._root = this.NIL;
     }
     get root() {

package/dist/data-structures/binary-tree/tree-multimap.d.ts

@@ -69,26 +69,6 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
      */
-    /**
-     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
-     *
-     * The function adds a new node to a binary tree, either as the left child or the right child of a
-     * given parent node.
-     * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
-     * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
-     * `undefined` if there is no node to add.
-     * @param {BTNKey | N | undefined} parent - The `parent` parameter represents the parent node to
-     * which the new node will be added as a child. It can be either a node object (`N`) or a key value
-     * (`BTNKey`).
-     * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
-     * added, or `undefined` if no node was added.
-     */
-    protected _addTo(newNode: N | undefined, parent: BTNKey | N | undefined): N | undefined;
-    /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-     */
     /**
      * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -104,8 +84,8 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      */
     addMany(keysOrNodes: (BTNKey | N | undefined)[], data?: V[]): (N | undefined)[];
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
+     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
      * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
@@ -120,8 +100,8 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      */
     perfectlyBalance(iterationType?: IterationType): boolean;
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
+     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
      */
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
@@ -143,10 +123,30 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * @returns an array of `BiTreeDeleteResult<N>`.
      */
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BiTreeDeleteResult<N>[];
+    /**
+     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
+     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     */
     /**
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear(): void;
+    /**
+     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
+     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     *
+     * The function adds a new node to a binary tree, either as the left child or the right child of a
+     * given parent node.
+     * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
+     * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
+     * `undefined` if there is no node to add.
+     * @param {BTNKey | N | undefined} parent - The `parent` parameter represents the parent node to
+     * which the new node will be added as a child. It can be either a node object (`N`) or a key value
+     * (`BTNKey`).
+     * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
+     * added, or `undefined` if no node was added.
+     */
+    protected _addTo(newNode: N | undefined, parent: BTNKey | N | undefined): N | undefined;
     /**
      * The `_swap` function swaps the key, value, count, and height properties between two nodes.
      * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from

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

@@ -150,52 +150,6 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
      */
-    /**
-     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
-     *
-     * The function adds a new node to a binary tree, either as the left child or the right child of a
-     * given parent node.
-     * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
-     * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
-     * `undefined` if there is no node to add.
-     * @param {BTNKey | N | undefined} parent - The `parent` parameter represents the parent node to
-     * which the new node will be added as a child. It can be either a node object (`N`) or a key value
-     * (`BTNKey`).
-     * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
-     * added, or `undefined` if no node was added.
-     */
-    _addTo(newNode, parent) {
-        parent = this.ensureNotKey(parent);
-        if (parent) {
-            if (parent.left === undefined) {
-                parent.left = newNode;
-                if (newNode !== undefined) {
-                    this._size = this.size + 1;
-                    this._count += newNode.count;
-                }
-                return parent.left;
-            }
-            else if (parent.right === undefined) {
-                parent.right = newNode;
-                if (newNode !== undefined) {
-                    this._size = this.size + 1;
-                    this._count += newNode.count;
-                }
-                return parent.right;
-            }
-            else {
-                return;
-            }
-        }
-        else {
-            return;
-        }
-    }
-    /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-     */
     /**
      * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -226,8 +180,8 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return inserted;
     }
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
+     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
      * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
@@ -277,8 +231,8 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         }
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
+     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
      */
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
@@ -357,6 +311,10 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         }
         return deletedResult;
     }
+    /**
+     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
+     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     */
     /**
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
@@ -364,6 +322,48 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         super.clear();
         this._count = 0;
     }
+    /**
+     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
+     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     *
+     * The function adds a new node to a binary tree, either as the left child or the right child of a
+     * given parent node.
+     * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
+     * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
+     * `undefined` if there is no node to add.
+     * @param {BTNKey | N | undefined} parent - The `parent` parameter represents the parent node to
+     * which the new node will be added as a child. It can be either a node object (`N`) or a key value
+     * (`BTNKey`).
+     * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
+     * added, or `undefined` if no node was added.
+     */
+    _addTo(newNode, parent) {
+        parent = this.ensureNotKey(parent);
+        if (parent) {
+            if (parent.left === undefined) {
+                parent.left = newNode;
+                if (newNode !== undefined) {
+                    this._size = this.size + 1;
+                    this._count += newNode.count;
+                }
+                return parent.left;
+            }
+            else if (parent.right === undefined) {
+                parent.right = newNode;
+                if (newNode !== undefined) {
+                    this._size = this.size + 1;
+                    this._count += newNode.count;
+                }
+                return parent.right;
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+    }
     /**
      * The `_swap` function swaps the key, value, count, and height properties between two nodes.
      * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from

package/dist/data-structures/graph/abstract-graph.d.ts

@@ -235,24 +235,24 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
      */
     /**
-    * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
-    * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-    *
-    * The function `dijkstraWithoutHeap` implements Dijkstra's algorithm to find the shortest path between two vertices in
-    * a graph without using a heap data structure.
-    * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
-    * vertex object or a vertex ID.
-    * @param {VO | VertexKey | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
-    * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
-    * identifier. If no destination is provided, the value is set to `null`.
-    * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
-    * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
-    * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
-    * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
-    * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
-    * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
-    * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
-    */
+     * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
+     * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
+     *
+     * The function `dijkstraWithoutHeap` implements Dijkstra's algorithm to find the shortest path between two vertices in
+     * a graph without using a heap data structure.
+     * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
+     * vertex object or a vertex ID.
+     * @param {VO | VertexKey | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+     * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
+     * identifier. If no destination is provided, the value is set to `null`.
+     * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
+     * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
+     * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
+     * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
+     * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
+     * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
+     * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
+     */
     dijkstraWithoutHeap(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
     /**
      *  Dijkstra algorithm time: O(logVE) space: O(VO + EO)
@@ -268,25 +268,25 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
      */
     /**
-    * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
-    * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
-    *
-    * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
-    * The `dijkstra` function implements Dijkstra's algorithm to find the shortest path between a source vertex and an
-    * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
-    * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
-    * start. It can be either a vertex object or a vertex ID.
-    * @param {VO | VertexKey | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
-    * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
-    * will calculate the shortest paths to all other vertices from the source vertex.
-    * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
-    * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
-    * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
-    * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
-    * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
-    * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
-    * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
-    */
+     * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
+     * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
+     *
+     * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
+     * The `dijkstra` function implements Dijkstra's algorithm to find the shortest path between a source vertex and an
+     * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
+     * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
+     * start. It can be either a vertex object or a vertex ID.
+     * @param {VO | VertexKey | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+     * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
+     * will calculate the shortest paths to all other vertices from the source vertex.
+     * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
+     * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
+     * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
+     * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
+     * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
+     * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
+     * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
+     */
     dijkstra(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
     /**
      * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).

package/dist/data-structures/graph/abstract-graph.js

@@ -416,24 +416,24 @@ class AbstractGraph {
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
      */
     /**
-    * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
-    * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-    *
-    * The function `dijkstraWithoutHeap` implements Dijkstra's algorithm to find the shortest path between two vertices in
-    * a graph without using a heap data structure.
-    * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
-    * vertex object or a vertex ID.
-    * @param {VO | VertexKey | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
-    * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
-    * identifier. If no destination is provided, the value is set to `null`.
-    * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
-    * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
-    * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
-    * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
-    * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
-    * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
-    * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
-    */
+     * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
+     * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
+     *
+     * The function `dijkstraWithoutHeap` implements Dijkstra's algorithm to find the shortest path between two vertices in
+     * a graph without using a heap data structure.
+     * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
+     * vertex object or a vertex ID.
+     * @param {VO | VertexKey | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+     * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
+     * identifier. If no destination is provided, the value is set to `null`.
+     * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
+     * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
+     * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
+     * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
+     * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
+     * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
+     * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
+     */
     dijkstraWithoutHeap(src, dest, getMinDist, genPaths) {
         if (getMinDist === undefined)
             getMinDist = false;
@@ -550,25 +550,25 @@ class AbstractGraph {
      * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
      */
     /**
-    * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
-    * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
-    *
-    * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
-    * The `dijkstra` function implements Dijkstra's algorithm to find the shortest path between a source vertex and an
-    * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
-    * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
-    * start. It can be either a vertex object or a vertex ID.
-    * @param {VO | VertexKey | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
-    * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
-    * will calculate the shortest paths to all other vertices from the source vertex.
-    * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
-    * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
-    * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
-    * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
-    * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
-    * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
-    * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
-    */
+     * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
+     * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
+     *
+     * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
+     * The `dijkstra` function implements Dijkstra's algorithm to find the shortest path between a source vertex and an
+     * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
+     * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
+     * start. It can be either a vertex object or a vertex ID.
+     * @param {VO | VertexKey | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+     * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
+     * will calculate the shortest paths to all other vertices from the source vertex.
+     * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
+     * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
+     * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
+     * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
+     * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
+     * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
+     * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
+     */
     dijkstra(src, dest, getMinDist, genPaths) {
         var _a;
         if (getMinDist === undefined)

package/dist/interfaces/binary-tree.d.ts

@@ -1,5 +1,5 @@
 import { BinaryTreeNode } from '../data-structures';
-import { BiTreeDeleteResult, BinaryTreeNodeNested, BTNCallback, BTNKey } from '../types';
+import { BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey } from '../types';
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
     createNode(key: BTNKey, value?: N['value']): N;
     add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graph-typed",
-  "version": "1.43.1",
+  "version": "1.44.0",
   "description": "Graph. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -136,6 +136,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.43.1"
+    "data-structure-typed": "^1.44.0"
   }
 }