data-structure-typed 1.43.1 → 1.44.0

package/dist/mjs/{src/data-structures → data-structures}/binary-tree/rb-tree.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * data-structure-typed
  *
@@ -6,19 +5,16 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedBlackTree = exports.RedBlackTreeNode = void 0;
-const types_1 = require("../../types");
-const bst_1 = require("./bst");
-const binary_tree_1 = require("./binary-tree");
-class RedBlackTreeNode extends bst_1.BSTNode {
+import { RBTNColor } from '../../types';
+import { BST, BSTNode } from './bst';
+import { BinaryTreeNode } from './binary-tree';
+export class RedBlackTreeNode extends BSTNode {
     color;
-    constructor(key, value, color = types_1.RBTNColor.BLACK) {
+    constructor(key, value, color = RBTNColor.BLACK) {
         super(key, value);
         this.color = color;
     }
 }
-exports.RedBlackTreeNode = RedBlackTreeNode;
 /**
  * 1. Each node is either red or black.
  * 2. The root node is always black.
@@ -26,7 +22,8 @@ exports.RedBlackTreeNode = RedBlackTreeNode;
  * 4. Red nodes must have black children.
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
-class RedBlackTree extends bst_1.BST {
+export class RedBlackTree extends BST {
+    NIL = new RedBlackTreeNode(NaN);
     /**
      * 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
@@ -44,7 +41,6 @@ class RedBlackTree extends bst_1.BST {
     get size() {
         return this._size;
     }
-    NIL = new RedBlackTreeNode(NaN);
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -63,7 +59,7 @@ class RedBlackTree extends bst_1.BST {
     add(keyOrNode, value) {
         let node;
         if (this.isNodeKey(keyOrNode)) {
-            node = this.createNode(keyOrNode, value, types_1.RBTNColor.RED);
+            node = this.createNode(keyOrNode, value, RBTNColor.RED);
         }
         else if (keyOrNode instanceof RedBlackTreeNode) {
             node = keyOrNode;
@@ -101,7 +97,7 @@ class RedBlackTree extends bst_1.BST {
             y.right = node;
         }
         if (node.parent === undefined) {
-            node.color = types_1.RBTNColor.BLACK;
+            node.color = RBTNColor.BLACK;
             this._size++;
             return;
         }
@@ -112,7 +108,7 @@ class RedBlackTree extends bst_1.BST {
         this._fixInsert(node);
         this._size++;
     }
-    createNode(key, value, color = types_1.RBTNColor.BLACK) {
+    createNode(key, value, color = RBTNColor.BLACK) {
         return new RedBlackTreeNode(key, value, color);
     }
     /**
@@ -183,7 +179,7 @@ class RedBlackTree extends bst_1.BST {
                 y.left.parent = y;
                 y.color = z.color;
             }
-            if (yOriginalColor === types_1.RBTNColor.BLACK) {
+            if (yOriginalColor === RBTNColor.BLACK) {
                 this._fixDelete(x);
             }
             this._size--;
@@ -221,7 +217,7 @@ class RedBlackTree extends bst_1.BST {
      * @returns a value of type `N`, `null`, or `undefined`.
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-        if (identifier instanceof binary_tree_1.BinaryTreeNode)
+        if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         beginRoot = this.ensureNotKey(beginRoot);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
@@ -363,32 +359,32 @@ class RedBlackTree extends bst_1.BST {
      */
     _fixDelete(x) {
         let s;
-        while (x !== this.root && x.color === types_1.RBTNColor.BLACK) {
+        while (x !== this.root && x.color === RBTNColor.BLACK) {
             if (x.parent && x === x.parent.left) {
                 s = x.parent.right;
                 if (s.color === 1) {
-                    s.color = types_1.RBTNColor.BLACK;
-                    x.parent.color = types_1.RBTNColor.RED;
+                    s.color = RBTNColor.BLACK;
+                    x.parent.color = RBTNColor.RED;
                     this._leftRotate(x.parent);
                     s = x.parent.right;
                 }
-                if (s.left !== undefined && s.left.color === types_1.RBTNColor.BLACK && s.right && s.right.color === types_1.RBTNColor.BLACK) {
-                    s.color = types_1.RBTNColor.RED;
+                if (s.left !== undefined && s.left.color === RBTNColor.BLACK && s.right && s.right.color === RBTNColor.BLACK) {
+                    s.color = RBTNColor.RED;
                     x = x.parent;
                 }
                 else {
-                    if (s.right && s.right.color === types_1.RBTNColor.BLACK) {
+                    if (s.right && s.right.color === RBTNColor.BLACK) {
                         if (s.left)
-                            s.left.color = types_1.RBTNColor.BLACK;
-                        s.color = types_1.RBTNColor.RED;
+                            s.left.color = RBTNColor.BLACK;
+                        s.color = RBTNColor.RED;
                         this._rightRotate(s);
                         s = x.parent.right;
                     }
                     if (s)
                         s.color = x.parent.color;
-                    x.parent.color = types_1.RBTNColor.BLACK;
+                    x.parent.color = RBTNColor.BLACK;
                     if (s && s.right)
-                        s.right.color = types_1.RBTNColor.BLACK;
+                        s.right.color = RBTNColor.BLACK;
                     this._leftRotate(x.parent);
                     x = this.root;
                 }
@@ -396,34 +392,34 @@ class RedBlackTree extends bst_1.BST {
             else {
                 s = x.parent.left;
                 if (s.color === 1) {
-                    s.color = types_1.RBTNColor.BLACK;
-                    x.parent.color = types_1.RBTNColor.RED;
+                    s.color = RBTNColor.BLACK;
+                    x.parent.color = RBTNColor.RED;
                     this._rightRotate(x.parent);
                     s = x.parent.left;
                 }
-                if (s && s.right && s.right.color === types_1.RBTNColor.BLACK && s.right.color === types_1.RBTNColor.BLACK) {
-                    s.color = types_1.RBTNColor.RED;
+                if (s && s.right && s.right.color === RBTNColor.BLACK && s.right.color === RBTNColor.BLACK) {
+                    s.color = RBTNColor.RED;
                     x = x.parent;
                 }
                 else {
-                    if (s && s.left && s.left.color === types_1.RBTNColor.BLACK) {
+                    if (s && s.left && s.left.color === RBTNColor.BLACK) {
                         if (s.right)
-                            s.right.color = types_1.RBTNColor.BLACK;
-                        s.color = types_1.RBTNColor.RED;
+                            s.right.color = RBTNColor.BLACK;
+                        s.color = RBTNColor.RED;
                         this._leftRotate(s);
                         s = x.parent.left;
                     }
                     if (s)
                         s.color = x.parent.color;
-                    x.parent.color = types_1.RBTNColor.BLACK;
+                    x.parent.color = RBTNColor.BLACK;
                     if (s && s.left)
-                        s.left.color = types_1.RBTNColor.BLACK;
+                        s.left.color = RBTNColor.BLACK;
                     this._rightRotate(x.parent);
                     x = this.root;
                 }
             }
         }
-        x.color = types_1.RBTNColor.BLACK;
+        x.color = RBTNColor.BLACK;
     }
     /**
      * Time Complexity: O(1)
@@ -467,9 +463,9 @@ class RedBlackTree extends bst_1.BST {
             if (k.parent.parent && k.parent === k.parent.parent.right) {
                 u = k.parent.parent.left;
                 if (u && u.color === 1) {
-                    u.color = types_1.RBTNColor.BLACK;
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    u.color = RBTNColor.BLACK;
+                    k.parent.color = RBTNColor.BLACK;
+                    k.parent.parent.color = RBTNColor.RED;
                     k = k.parent.parent;
                 }
                 else {
@@ -477,17 +473,17 @@ class RedBlackTree extends bst_1.BST {
                         k = k.parent;
                         this._rightRotate(k);
                     }
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    k.parent.color = RBTNColor.BLACK;
+                    k.parent.parent.color = RBTNColor.RED;
                     this._leftRotate(k.parent.parent);
                 }
             }
             else {
                 u = k.parent.parent.right;
                 if (u && u.color === 1) {
-                    u.color = types_1.RBTNColor.BLACK;
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    u.color = RBTNColor.BLACK;
+                    k.parent.color = RBTNColor.BLACK;
+                    k.parent.parent.color = RBTNColor.RED;
                     k = k.parent.parent;
                 }
                 else {
@@ -495,8 +491,8 @@ class RedBlackTree extends bst_1.BST {
                         k = k.parent;
                         this._leftRotate(k);
                     }
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    k.parent.color = RBTNColor.BLACK;
+                    k.parent.parent.color = RBTNColor.RED;
                     this._rightRotate(k.parent.parent);
                 }
             }
@@ -504,7 +500,6 @@ class RedBlackTree extends bst_1.BST {
                 break;
             }
         }
-        this.root.color = types_1.RBTNColor.BLACK;
+        this.root.color = RBTNColor.BLACK;
     }
 }
-exports.RedBlackTree = RedBlackTree;

package/dist/mjs/{src/data-structures → data-structures}/binary-tree/segment-tree.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * data-structure-typed
  *
@@ -6,9 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SegmentTree = exports.SegmentTreeNode = void 0;
-class SegmentTreeNode {
+export class SegmentTreeNode {
     start = 0;
     end = 0;
     value = null;
@@ -22,8 +19,7 @@ class SegmentTreeNode {
         this.value = value || null;
     }
 }
-exports.SegmentTreeNode = SegmentTreeNode;
-class SegmentTree {
+export class SegmentTree {
     /**
      * The constructor initializes the values, start, end, and root properties of an object.
      * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
@@ -179,4 +175,3 @@ class SegmentTree {
         return dfs(root, indexA, indexB);
     }
 }
-exports.SegmentTree = SegmentTree;

package/dist/mjs/{src/data-structures → data-structures}/binary-tree/tree-multimap.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeMultimap = exports.TreeMultimapNode = void 0;
-const types_1 = require("../../types");
-const avl_tree_1 = require("./avl-tree");
-class TreeMultimapNode extends avl_tree_1.AVLTreeNode {
+import { CP, FamilyPosition, IterationType } from '../../types';
+import { AVLTree, AVLTreeNode } from './avl-tree';
+export class TreeMultimapNode extends AVLTreeNode {
     count;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
@@ -20,11 +17,10 @@ class TreeMultimapNode extends avl_tree_1.AVLTreeNode {
         this.count = count;
     }
 }
-exports.TreeMultimapNode = TreeMultimapNode;
 /**
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-class TreeMultimap extends avl_tree_1.AVLTree {
+export class TreeMultimap extends AVLTree {
     /**
      * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
      * merge duplicated values.
@@ -94,14 +90,14 @@ class TreeMultimap extends avl_tree_1.AVLTree {
             while (traversing) {
                 if (cur) {
                     if (newNode) {
-                        if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
+                        if (this._compare(cur.key, newNode.key) === CP.eq) {
                             cur.value = newNode.value;
                             cur.count += newNode.count;
                             this._count += newNode.count;
                             traversing = false;
                             inserted = cur;
                         }
-                        else if (this._compare(cur.key, newNode.key) === types_1.CP.gt) {
+                        else if (this._compare(cur.key, newNode.key) === CP.gt) {
                             // Traverse left of the node
                             if (cur.left === undefined) {
                                 //Add to the left of the current node
@@ -117,7 +113,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                                     cur = cur.left;
                             }
                         }
-                        else if (this._compare(cur.key, newNode.key) === types_1.CP.lt) {
+                        else if (this._compare(cur.key, newNode.key) === CP.lt) {
                             // Traverse right of the node
                             if (cur.right === undefined) {
                                 //Add to the right of the current node
@@ -151,52 +147,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.
@@ -227,8 +177,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.
@@ -246,7 +196,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         if (sorted.length < 1)
             return false;
         this.clear();
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -278,8 +228,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.
@@ -321,10 +271,10 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                 }
                 else {
                     const { familyPosition: fp } = curr;
-                    if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
+                    if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
                         parent.left = curr.right;
                     }
-                    else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
+                    else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
                         parent.right = curr.right;
                     }
                     needBalanced = parent;
@@ -357,6 +307,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 +318,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
@@ -395,4 +391,3 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return undefined;
     }
 }
-exports.TreeMultimap = TreeMultimap;

package/dist/{cjs/src → mjs}/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).