data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,88 +1,216 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
-const utils_1 = require("../../utils");
-const priority_queue_1 = require("../priority-queue");
-class AbstractVertex {
-    get id() {
-        return this._id;
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
     }
-    set id(v) {
-        this._id = v;
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
     }
-    constructor(id) {
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+var utils_1 = require("../../utils");
+var priority_queue_1 = require("../priority-queue");
+var AbstractVertex = /** @class */ (function () {
+    function AbstractVertex(id) {
         this._id = id;
     }
-}
+    Object.defineProperty(AbstractVertex.prototype, "id", {
+        get: function () {
+            return this._id;
+        },
+        set: function (v) {
+            this._id = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AbstractVertex;
+}());
 exports.AbstractVertex = AbstractVertex;
-class AbstractEdge {
-    get weight() {
-        return this._weight;
-    }
-    set weight(v) {
-        this._weight = v;
-    }
-    get hashCode() {
-        return this._hashCode;
-    }
-    set hashCode(v) {
-        this._hashCode = v;
-    }
-    constructor(weight) {
+var AbstractEdge = /** @class */ (function () {
+    function AbstractEdge(weight) {
         if (weight === undefined)
             weight = AbstractEdge.DEFAULT_EDGE_WEIGHT;
         this._weight = weight;
         this._hashCode = (0, utils_1.uuidV4)();
     }
-}
+    Object.defineProperty(AbstractEdge.prototype, "weight", {
+        get: function () {
+            return this._weight;
+        },
+        set: function (v) {
+            this._weight = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractEdge.prototype, "hashCode", {
+        get: function () {
+            return this._hashCode;
+        },
+        set: function (v) {
+            this._hashCode = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractEdge.DEFAULT_EDGE_WEIGHT = 1;
+    return AbstractEdge;
+}());
 exports.AbstractEdge = AbstractEdge;
-AbstractEdge.DEFAULT_EDGE_WEIGHT = 1;
 // Connected Component === Largest Connected Sub-Graph
-class AbstractGraph {
-    constructor() {
+var AbstractGraph = /** @class */ (function () {
+    function AbstractGraph() {
         this._vertices = new Map();
         // unionFind() {
         // }
         /**--- end find cycles --- */
         // Minimum Spanning Tree
     }
-    getVertex(vertexOrId) {
-        const vertexId = this.getVertexId(vertexOrId);
+    /**
+     * The function `getVertex` returns the vertex object associated with a given vertex ID or vertex object, or null if it
+     * does not exist.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The function `getVertex` returns the vertex object (`V`) corresponding to the given `vertexOrId` parameter.
+     * If the vertex is found in the `_vertices` map, it is returned. Otherwise, `null` is returned.
+     */
+    AbstractGraph.prototype.getVertex = function (vertexOrId) {
+        var vertexId = this.getVertexId(vertexOrId);
         return this._vertices.get(vertexId) || null;
-    }
-    getVertexId(vertexOrId) {
+    };
+    /**
+     * The function `getVertexId` returns the id of a vertex, whether it is passed as an instance of `AbstractVertex` or as
+     * a `VertexId`.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns the id of the vertex.
+     */
+    AbstractGraph.prototype.getVertexId = function (vertexOrId) {
         return vertexOrId instanceof AbstractVertex ? vertexOrId.id : vertexOrId;
-    }
-    containsVertex(vertexOrId) {
+    };
+    /**
+     * The function checks if a vertex exists in a graph.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `containsVertex` returns a boolean value.
+     */
+    AbstractGraph.prototype.containsVertex = function (vertexOrId) {
         return this._vertices.has(this.getVertexId(vertexOrId));
-    }
-    vertexSet() {
+    };
+    /**
+     * The function `vertexSet()` returns a map of vertices.
+     * @returns The method `vertexSet()` returns a map of vertex IDs to vertex objects.
+     */
+    AbstractGraph.prototype.vertexSet = function () {
         return this._vertices;
-    }
-    addVertex(newVertex) {
+    };
+    /**
+     * The addVertex function adds a new vertex to a graph if it does not already exist.
+     * @param {V} newVertex - The parameter "newVertex" is of type V, which represents a vertex in a graph.
+     * @returns The method is returning a boolean value. If the newVertex is already contained in the graph, it will return
+     * false. Otherwise, it will add the newVertex to the graph and return true.
+     */
+    AbstractGraph.prototype.addVertex = function (newVertex) {
         if (this.containsVertex(newVertex)) {
             return false;
         }
         this._vertices.set(newVertex.id, newVertex);
         return true;
-    }
-    removeVertex(vertexOrId) {
-        const vertexId = this.getVertexId(vertexOrId);
+    };
+    /**
+     * The `removeVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `removeVertex` returns a boolean value.
+     */
+    AbstractGraph.prototype.removeVertex = function (vertexOrId) {
+        var vertexId = this.getVertexId(vertexOrId);
         return this._vertices.delete(vertexId);
-    }
-    removeAllVertices(vertices) {
-        const removed = [];
-        for (const v of vertices) {
-            removed.push(this.removeVertex(v));
+    };
+    /**
+     * The function removes all vertices from a graph and returns a boolean indicating if any vertices were removed.
+     * @param {V[] | VertexId[]} vertices - The `vertices` parameter can be either an array of vertices (`V[]`) or an array
+     * of vertex IDs (`VertexId[]`).
+     * @returns a boolean value. It returns true if at least one vertex was successfully removed, and false if no vertices
+     * were removed.
+     */
+    AbstractGraph.prototype.removeAllVertices = function (vertices) {
+        var e_1, _a;
+        var removed = [];
+        try {
+            for (var vertices_1 = __values(vertices), vertices_1_1 = vertices_1.next(); !vertices_1_1.done; vertices_1_1 = vertices_1.next()) {
+                var v = vertices_1_1.value;
+                removed.push(this.removeVertex(v));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (vertices_1_1 && !vertices_1_1.done && (_a = vertices_1.return)) _a.call(vertices_1);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
         return removed.length > 0;
-    }
-    containsEdge(v1, v2) {
-        const edge = this.getEdge(v1, v2);
+    };
+    /**
+     * The function checks if there is an edge between two vertices in a graph.
+     * @param {VertexId | V} v1 - The parameter v1 can be either a VertexId or a V. A VertexId represents the identifier of
+     * a vertex in a graph, while V represents the type of the vertex itself.
+     * @param {VertexId | V} v2 - The parameter `v2` represents the second vertex in an edge. It can be either a `VertexId`
+     * or a `V` type.
+     * @returns The function `containsEdge` returns a boolean value. It returns `true` if there is an edge between the
+     * vertices `v1` and `v2`, and `false` otherwise.
+     */
+    AbstractGraph.prototype.containsEdge = function (v1, v2) {
+        var edge = this.getEdge(v1, v2);
         return !!edge;
-    }
-    setEdgeWeight(srcOrId, destOrId, weight) {
-        const edge = this.getEdge(srcOrId, destOrId);
+    };
+    /**
+     * The function sets the weight of an edge between two vertices in a graph.
+     * @param {VertexId | V} srcOrId - The `srcOrId` parameter can be either a `VertexId` or a `V` object. It represents
+     * the source vertex of the edge.
+     * @param {VertexId | V} destOrId - The `destOrId` parameter represents the destination vertex of the edge. It can be
+     * either a `VertexId` or a vertex object `V`.
+     * @param {number} weight - The weight parameter represents the weight of the edge between the source vertex (srcOrId)
+     * and the destination vertex (destOrId).
+     * @returns a boolean value. If the edge exists between the source and destination vertices, the function will update
+     * the weight of the edge and return true. If the edge does not exist, the function will return false.
+     */
+    AbstractGraph.prototype.setEdgeWeight = function (srcOrId, destOrId, weight) {
+        var edge = this.getEdge(srcOrId, destOrId);
         if (edge) {
             edge.weight = weight;
             return true;
@@ -90,76 +218,140 @@ class AbstractGraph {
         else {
             return false;
         }
-    }
-    getAllPathsBetween(v1, v2) {
-        const paths = [];
-        const vertex1 = this.getVertex(v1);
-        const vertex2 = this.getVertex(v2);
+    };
+    /**
+     * The function `getAllPathsBetween` finds all paths between two vertices in a graph using depth-first search.
+     * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
+     * It is the starting vertex for finding paths.
+     * @param {V | VertexId} v2 - The parameter `v2` represents the destination vertex or its ID. It is the vertex that we
+     * want to find paths to from the starting vertex `v1`.
+     * @returns an array of arrays of vertices (V[][]). Each inner array represents a path between the given vertices (v1
+     * and v2).
+     */
+    AbstractGraph.prototype.getAllPathsBetween = function (v1, v2) {
+        var _this = this;
+        var paths = [];
+        var vertex1 = this.getVertex(v1);
+        var vertex2 = this.getVertex(v2);
         if (!(vertex1 && vertex2)) {
             return [];
         }
-        const dfs = (cur, dest, visiting, path) => {
+        var dfs = function (cur, dest, visiting, path) {
+            var e_2, _a;
             visiting.set(cur, true);
             if (cur === dest) {
-                paths.push([vertex1, ...path]);
+                paths.push(__spreadArray([vertex1], __read(path), false));
             }
-            const neighbors = this.getNeighbors(cur);
-            for (const neighbor of neighbors) {
+            var neighbors = _this.getNeighbors(cur);
+            var _loop_1 = function (neighbor) {
                 if (!visiting.get(neighbor)) {
                     path.push(neighbor);
                     dfs(neighbor, dest, visiting, path);
-                    (0, utils_1.arrayRemove)(path, vertex => vertex === neighbor);
+                    (0, utils_1.arrayRemove)(path, function (vertex) { return vertex === neighbor; });
+                }
+            };
+            try {
+                for (var neighbors_1 = __values(neighbors), neighbors_1_1 = neighbors_1.next(); !neighbors_1_1.done; neighbors_1_1 = neighbors_1.next()) {
+                    var neighbor = neighbors_1_1.value;
+                    _loop_1(neighbor);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (neighbors_1_1 && !neighbors_1_1.done && (_a = neighbors_1.return)) _a.call(neighbors_1);
                 }
+                finally { if (e_2) throw e_2.error; }
             }
             visiting.set(cur, false);
         };
         dfs(vertex1, vertex2, new Map(), []);
         return paths;
-    }
-    getPathSumWeight(path) {
+    };
+    /**
+     * The function calculates the sum of weights along a given path.
+     * @param {V[]} path - An array of vertices (V) representing a path in a graph.
+     * @returns The function `getPathSumWeight` returns the sum of the weights of the edges in the given path.
+     */
+    AbstractGraph.prototype.getPathSumWeight = function (path) {
         var _a;
-        let sum = 0;
-        for (let i = 0; i < path.length; i++) {
+        var sum = 0;
+        for (var i = 0; i < path.length; i++) {
             sum += ((_a = this.getEdge(path[i], path[i + 1])) === null || _a === void 0 ? void 0 : _a.weight) || 0;
         }
         return sum;
-    }
-    getMinCostBetween(v1, v2, isWeight) {
+    };
+    /**
+     * The function `getMinCostBetween` calculates the minimum cost between two vertices in a graph, either based on edge
+     * weights or using a breadth-first search algorithm.
+     * @param {V | VertexId} v1 - The parameter `v1` represents the starting vertex or vertex ID of the graph.
+     * @param {V | VertexId} v2 - The parameter `v2` represents the second vertex in the graph. It can be either a vertex
+     * object or a vertex ID.
+     * @param {boolean} [isWeight] - isWeight is an optional parameter that indicates whether the graph edges have weights.
+     * If isWeight is set to true, the function will calculate the minimum cost between v1 and v2 based on the weights of
+     * the edges. If isWeight is set to false or not provided, the function will calculate the
+     * @returns The function `getMinCostBetween` returns a number representing the minimum cost between two vertices (`v1`
+     * and `v2`) in a graph. If the `isWeight` parameter is `true`, it calculates the minimum weight between the vertices.
+     * If `isWeight` is `false` or not provided, it calculates the minimum number of edges between the vertices. If the
+     * vertices are not
+     */
+    AbstractGraph.prototype.getMinCostBetween = function (v1, v2, isWeight) {
+        var e_3, _a, e_4, _b;
         if (isWeight === undefined)
             isWeight = false;
         if (isWeight) {
-            const allPaths = this.getAllPathsBetween(v1, v2);
-            let min = Infinity;
-            for (const path of allPaths) {
-                min = Math.min(this.getPathSumWeight(path), min);
+            var allPaths = this.getAllPathsBetween(v1, v2);
+            var min = Infinity;
+            try {
+                for (var allPaths_1 = __values(allPaths), allPaths_1_1 = allPaths_1.next(); !allPaths_1_1.done; allPaths_1_1 = allPaths_1.next()) {
+                    var path = allPaths_1_1.value;
+                    min = Math.min(this.getPathSumWeight(path), min);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (allPaths_1_1 && !allPaths_1_1.done && (_a = allPaths_1.return)) _a.call(allPaths_1);
+                }
+                finally { if (e_3) throw e_3.error; }
             }
             return min;
         }
         else {
             // BFS
-            const vertex2 = this.getVertex(v2);
-            const vertex1 = this.getVertex(v1);
+            var vertex2 = this.getVertex(v2);
+            var vertex1 = this.getVertex(v1);
             if (!(vertex1 && vertex2)) {
                 return null;
             }
-            const visited = new Map();
-            const queue = [vertex1];
+            var visited = new Map();
+            var queue = [vertex1];
             visited.set(vertex1, true);
-            let cost = 0;
+            var cost = 0;
             while (queue.length > 0) {
-                for (let i = 0; i < queue.length; i++) {
-                    const cur = queue.shift();
+                for (var i = 0; i < queue.length; i++) {
+                    var cur = queue.shift();
                     if (cur === vertex2) {
                         return cost;
                     }
                     // TODO consider optimizing to AbstractGraph
                     if (cur !== undefined) {
-                        const neighbors = this.getNeighbors(cur);
-                        for (const neighbor of neighbors) {
-                            if (!visited.has(neighbor)) {
-                                visited.set(neighbor, true);
-                                queue.push(neighbor);
+                        var neighbors = this.getNeighbors(cur);
+                        try {
+                            for (var neighbors_2 = (e_4 = void 0, __values(neighbors)), neighbors_2_1 = neighbors_2.next(); !neighbors_2_1.done; neighbors_2_1 = neighbors_2.next()) {
+                                var neighbor = neighbors_2_1.value;
+                                if (!visited.has(neighbor)) {
+                                    visited.set(neighbor, true);
+                                    queue.push(neighbor);
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (neighbors_2_1 && !neighbors_2_1.done && (_b = neighbors_2.return)) _b.call(neighbors_2);
                             }
+                            finally { if (e_4) throw e_4.error; }
                         }
                     }
                 }
@@ -167,114 +359,200 @@ class AbstractGraph {
             }
             return null;
         }
-    }
-    getMinPathBetween(v1, v2, isWeight) {
+    };
+    /**
+     * The function `getMinPathBetween` returns the minimum path between two vertices in a graph, either based on weight or
+     * using a breadth-first search algorithm.
+     * @param {V | VertexId} v1 - The parameter `v1` represents the starting vertex or its ID.
+     * @param {V | VertexId} v2 - The parameter `v2` represents the destination vertex or its ID. It is the vertex that we
+     * want to find the minimum path to from the source vertex `v1`.
+     * @param {boolean} [isWeight] - A boolean flag indicating whether to consider the weight of edges in finding the
+     * minimum path. If set to true, the function will use Dijkstra's algorithm to find the minimum weighted path. If set
+     * to false, the function will use breadth-first search (BFS) to find the minimum path. If
+     * @returns The function `getMinPathBetween` returns an array of vertices (`V[]`) representing the minimum path between
+     * two vertices (`v1` and `v2`). If no path is found, it returns `null`.
+     */
+    AbstractGraph.prototype.getMinPathBetween = function (v1, v2, isWeight) {
+        var e_5, _a;
+        var _this = this;
         if (isWeight === undefined)
             isWeight = false;
         if (isWeight) {
-            const allPaths = this.getAllPathsBetween(v1, v2);
-            let min = Infinity;
-            let minIndex = -1;
-            let index = 0;
-            for (const path of allPaths) {
-                const pathSumWeight = this.getPathSumWeight(path);
-                if (pathSumWeight < min) {
-                    min = pathSumWeight;
-                    minIndex = index;
-                }
-                index++;
+            var allPaths = this.getAllPathsBetween(v1, v2);
+            var min = Infinity;
+            var minIndex = -1;
+            var index = 0;
+            try {
+                for (var allPaths_2 = __values(allPaths), allPaths_2_1 = allPaths_2.next(); !allPaths_2_1.done; allPaths_2_1 = allPaths_2.next()) {
+                    var path = allPaths_2_1.value;
+                    var pathSumWeight = this.getPathSumWeight(path);
+                    if (pathSumWeight < min) {
+                        min = pathSumWeight;
+                        minIndex = index;
+                    }
+                    index++;
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (allPaths_2_1 && !allPaths_2_1.done && (_a = allPaths_2.return)) _a.call(allPaths_2);
+                }
+                finally { if (e_5) throw e_5.error; }
             }
             return allPaths[minIndex] || null;
         }
         else {
             // BFS
-            let minPath = [];
-            const vertex1 = this.getVertex(v1);
-            const vertex2 = this.getVertex(v2);
-            if (!(vertex1 && vertex2)) {
+            var minPath_1 = [];
+            var vertex1_1 = this.getVertex(v1);
+            var vertex2 = this.getVertex(v2);
+            if (!(vertex1_1 && vertex2)) {
                 return [];
             }
-            const dfs = (cur, dest, visiting, path) => {
+            var dfs_1 = function (cur, dest, visiting, path) {
+                var e_6, _a;
                 visiting.set(cur, true);
                 if (cur === dest) {
-                    minPath = [vertex1, ...path];
+                    minPath_1 = __spreadArray([vertex1_1], __read(path), false);
                     return;
                 }
-                const neighbors = this.getNeighbors(cur);
-                for (const neighbor of neighbors) {
+                var neighbors = _this.getNeighbors(cur);
+                var _loop_2 = function (neighbor) {
                     if (!visiting.get(neighbor)) {
                         path.push(neighbor);
-                        dfs(neighbor, dest, visiting, path);
-                        (0, utils_1.arrayRemove)(path, vertex => vertex === neighbor);
+                        dfs_1(neighbor, dest, visiting, path);
+                        (0, utils_1.arrayRemove)(path, function (vertex) { return vertex === neighbor; });
                     }
+                };
+                try {
+                    for (var neighbors_3 = __values(neighbors), neighbors_3_1 = neighbors_3.next(); !neighbors_3_1.done; neighbors_3_1 = neighbors_3.next()) {
+                        var neighbor = neighbors_3_1.value;
+                        _loop_2(neighbor);
+                    }
+                }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                finally {
+                    try {
+                        if (neighbors_3_1 && !neighbors_3_1.done && (_a = neighbors_3.return)) _a.call(neighbors_3);
+                    }
+                    finally { if (e_6) throw e_6.error; }
                 }
                 visiting.set(cur, false);
             };
-            dfs(vertex1, vertex2, new Map(), []);
-            return minPath;
+            dfs_1(vertex1_1, vertex2, new Map(), []);
+            return minPath_1;
         }
-    }
+    };
     /**
      * Dijkstra algorithm time: O(VE) space: O(V + E)
-     * @param src
-     * @param dest
-     * @param getMinDist
-     * @param genPaths
+     * 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 {V | VertexId} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
+     * vertex object or a vertex ID.
+     * @param {V | VertexId | 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<V>`.
      */
-    dijkstraWithoutHeap(src, dest, getMinDist, genPaths) {
+    AbstractGraph.prototype.dijkstraWithoutHeap = function (src, dest, getMinDist, genPaths) {
+        var e_7, _a, e_8, _b;
         if (getMinDist === undefined)
             getMinDist = false;
         if (genPaths === undefined)
             genPaths = false;
         if (dest === undefined)
             dest = null;
-        let minDist = Infinity;
-        let minDest = null;
-        let minPath = [];
-        const paths = [];
-        const vertices = this._vertices;
-        const distMap = new Map();
-        const seen = new Set();
-        const preMap = new Map(); // predecessor
-        const srcVertex = this.getVertex(src);
-        const destVertex = dest ? this.getVertex(dest) : null;
+        var minDist = Infinity;
+        var minDest = null;
+        var minPath = [];
+        var paths = [];
+        var vertices = this._vertices;
+        var distMap = new Map();
+        var seen = new Set();
+        var preMap = new Map(); // predecessor
+        var srcVertex = this.getVertex(src);
+        var destVertex = dest ? this.getVertex(dest) : null;
         if (!srcVertex) {
             return null;
         }
-        for (const vertex of vertices) {
-            distMap.set(vertex[1], Infinity);
+        try {
+            for (var vertices_2 = __values(vertices), vertices_2_1 = vertices_2.next(); !vertices_2_1.done; vertices_2_1 = vertices_2.next()) {
+                var vertex = vertices_2_1.value;
+                var vertexOrId = vertex[1];
+                if (vertexOrId instanceof AbstractVertex)
+                    distMap.set(vertexOrId, Infinity);
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (vertices_2_1 && !vertices_2_1.done && (_a = vertices_2.return)) _a.call(vertices_2);
+            }
+            finally { if (e_7) throw e_7.error; }
         }
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
-        const getMinOfNoSeen = () => {
-            let min = Infinity;
-            let minV = null;
-            for (const [key, val] of distMap) {
-                if (!seen.has(key)) {
-                    if (val < min) {
-                        min = val;
-                        minV = key;
+        var getMinOfNoSeen = function () {
+            var e_9, _a;
+            var min = Infinity;
+            var minV = null;
+            try {
+                for (var distMap_1 = __values(distMap), distMap_1_1 = distMap_1.next(); !distMap_1_1.done; distMap_1_1 = distMap_1.next()) {
+                    var _b = __read(distMap_1_1.value, 2), key = _b[0], val = _b[1];
+                    if (!seen.has(key)) {
+                        if (val < min) {
+                            min = val;
+                            minV = key;
+                        }
                     }
                 }
             }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (distMap_1_1 && !distMap_1_1.done && (_a = distMap_1.return)) _a.call(distMap_1);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
             return minV;
         };
-        const getPaths = (minV) => {
-            for (const vertex of vertices) {
-                const path = [vertex[1]];
-                let parent = preMap.get(vertex[1]);
-                while (parent) {
-                    path.push(parent);
-                    parent = preMap.get(parent);
-                }
-                const reversed = path.reverse();
-                if (vertex[1] === minV)
-                    minPath = reversed;
-                paths.push(reversed);
+        var getPaths = function (minV) {
+            var e_10, _a;
+            try {
+                for (var vertices_3 = __values(vertices), vertices_3_1 = vertices_3.next(); !vertices_3_1.done; vertices_3_1 = vertices_3.next()) {
+                    var vertex = vertices_3_1.value;
+                    var vertexOrId = vertex[1];
+                    if (vertexOrId instanceof AbstractVertex) {
+                        var path = [vertexOrId];
+                        var parent = preMap.get(vertexOrId);
+                        while (parent) {
+                            path.push(parent);
+                            parent = preMap.get(parent);
+                        }
+                        var reversed = path.reverse();
+                        if (vertex[1] === minV)
+                            minPath = reversed;
+                        paths.push(reversed);
+                    }
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (vertices_3_1 && !vertices_3_1.done && (_a = vertices_3.return)) _a.call(vertices_3);
+                }
+                finally { if (e_10) throw e_10.error; }
             }
         };
-        for (let i = 1; i < vertices.size; i++) {
-            const cur = getMinOfNoSeen();
+        for (var i = 1; i < vertices.size; i++) {
+            var cur = getMinOfNoSeen();
             if (cur) {
                 seen.add(cur);
                 if (destVertex && destVertex === cur) {
@@ -284,28 +562,38 @@ class AbstractGraph {
                     if (genPaths) {
                         getPaths(destVertex);
                     }
-                    return { distMap, preMap, seen, paths, minDist, minPath };
-                }
-                const neighbors = this.getNeighbors(cur);
-                for (const neighbor of neighbors) {
-                    if (!seen.has(neighbor)) {
-                        const edge = this.getEdge(cur, neighbor);
-                        if (edge) {
-                            const curFromMap = distMap.get(cur);
-                            const neighborFromMap = distMap.get(neighbor);
-                            // TODO after no-non-null-assertion not ensure the logic
-                            if (curFromMap !== undefined && neighborFromMap !== undefined) {
-                                if (edge.weight + curFromMap < neighborFromMap) {
-                                    distMap.set(neighbor, edge.weight + curFromMap);
-                                    preMap.set(neighbor, cur);
+                    return { distMap: distMap, preMap: preMap, seen: seen, paths: paths, minDist: minDist, minPath: minPath };
+                }
+                var neighbors = this.getNeighbors(cur);
+                try {
+                    for (var neighbors_4 = (e_8 = void 0, __values(neighbors)), neighbors_4_1 = neighbors_4.next(); !neighbors_4_1.done; neighbors_4_1 = neighbors_4.next()) {
+                        var neighbor = neighbors_4_1.value;
+                        if (!seen.has(neighbor)) {
+                            var edge = this.getEdge(cur, neighbor);
+                            if (edge) {
+                                var curFromMap = distMap.get(cur);
+                                var neighborFromMap = distMap.get(neighbor);
+                                // TODO after no-non-null-assertion not ensure the logic
+                                if (curFromMap !== undefined && neighborFromMap !== undefined) {
+                                    if (edge.weight + curFromMap < neighborFromMap) {
+                                        distMap.set(neighbor, edge.weight + curFromMap);
+                                        preMap.set(neighbor, cur);
+                                    }
                                 }
                             }
                         }
                     }
                 }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (neighbors_4_1 && !neighbors_4_1.done && (_b = neighbors_4.return)) _b.call(neighbors_4);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
             }
         }
-        getMinDist && distMap.forEach((d, v) => {
+        getMinDist && distMap.forEach(function (d, v) {
             if (v !== srcVertex) {
                 if (d < minDist) {
                     minDist = d;
@@ -315,61 +603,98 @@ class AbstractGraph {
             }
         });
         genPaths && getPaths(minDest);
-        return { distMap, preMap, seen, paths, minDist, minPath };
-    }
+        return { distMap: distMap, preMap: preMap, seen: seen, paths: paths, minDist: minDist, minPath: minPath };
+    };
     /**
      * Dijkstra algorithm time: O(logVE) space: O(V + E)
-     * @param src
-     * @param dest
-     * @param getMinDist
-     * @param genPaths
+     * 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 {V | VertexId} 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 {V | VertexId | 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<V>`.
      */
-    dijkstra(src, dest, getMinDist, genPaths) {
-        var _a;
+    AbstractGraph.prototype.dijkstra = function (src, dest, getMinDist, genPaths) {
+        var e_11, _a, e_12, _b;
+        var _c;
         if (getMinDist === undefined)
             getMinDist = false;
         if (genPaths === undefined)
             genPaths = false;
         if (dest === undefined)
             dest = null;
-        let minDist = Infinity;
-        let minDest = null;
-        let minPath = [];
-        const paths = [];
-        const vertices = this._vertices;
-        const distMap = new Map();
-        const seen = new Set();
-        const preMap = new Map(); // predecessor
-        const srcVertex = this.getVertex(src);
-        const destVertex = dest ? this.getVertex(dest) : null;
+        var minDist = Infinity;
+        var minDest = null;
+        var minPath = [];
+        var paths = [];
+        var vertices = this._vertices;
+        var distMap = new Map();
+        var seen = new Set();
+        var preMap = new Map(); // predecessor
+        var srcVertex = this.getVertex(src);
+        var destVertex = dest ? this.getVertex(dest) : null;
         if (!srcVertex) {
             return null;
         }
-        for (const vertex of vertices) {
-            distMap.set(vertex[1], Infinity);
+        try {
+            for (var vertices_4 = __values(vertices), vertices_4_1 = vertices_4.next(); !vertices_4_1.done; vertices_4_1 = vertices_4.next()) {
+                var vertex = vertices_4_1.value;
+                var vertexOrId = vertex[1];
+                if (vertexOrId instanceof AbstractVertex)
+                    distMap.set(vertexOrId, Infinity);
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (vertices_4_1 && !vertices_4_1.done && (_a = vertices_4.return)) _a.call(vertices_4);
+            }
+            finally { if (e_11) throw e_11.error; }
         }
-        const heap = new priority_queue_1.PriorityQueue({ comparator: (a, b) => a.id - b.id });
+        var heap = new priority_queue_1.PriorityQueue({ comparator: function (a, b) { return a.id - b.id; } });
         heap.offer({ id: 0, val: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
-        const getPaths = (minV) => {
-            for (const vertex of vertices) {
-                const path = [vertex[1]];
-                let parent = preMap.get(vertex[1]);
-                while (parent) {
-                    path.push(parent);
-                    parent = preMap.get(parent);
-                }
-                const reversed = path.reverse();
-                if (vertex[1] === minV)
-                    minPath = reversed;
-                paths.push(reversed);
+        var getPaths = function (minV) {
+            var e_13, _a;
+            try {
+                for (var vertices_5 = __values(vertices), vertices_5_1 = vertices_5.next(); !vertices_5_1.done; vertices_5_1 = vertices_5.next()) {
+                    var vertex = vertices_5_1.value;
+                    var vertexOrId = vertex[1];
+                    if (vertexOrId instanceof AbstractVertex) {
+                        var path = [vertexOrId];
+                        var parent = preMap.get(vertexOrId);
+                        while (parent) {
+                            path.push(parent);
+                            parent = preMap.get(parent);
+                        }
+                        var reversed = path.reverse();
+                        if (vertex[1] === minV)
+                            minPath = reversed;
+                        paths.push(reversed);
+                    }
+                }
+            }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
+            finally {
+                try {
+                    if (vertices_5_1 && !vertices_5_1.done && (_a = vertices_5.return)) _a.call(vertices_5);
+                }
+                finally { if (e_13) throw e_13.error; }
             }
         };
         while (heap.size > 0) {
-            const curHeapNode = heap.poll();
-            const dist = curHeapNode === null || curHeapNode === void 0 ? void 0 : curHeapNode.id;
-            const cur = curHeapNode === null || curHeapNode === void 0 ? void 0 : curHeapNode.val;
+            var curHeapNode = heap.poll();
+            var dist = curHeapNode === null || curHeapNode === void 0 ? void 0 : curHeapNode.id;
+            var cur = curHeapNode === null || curHeapNode === void 0 ? void 0 : curHeapNode.val;
             if (dist !== undefined) {
                 if (cur) {
                     seen.add(cur);
@@ -380,29 +705,39 @@ class AbstractGraph {
                         if (genPaths) {
                             getPaths(destVertex);
                         }
-                        return { distMap, preMap, seen, paths, minDist, minPath };
+                        return { distMap: distMap, preMap: preMap, seen: seen, paths: paths, minDist: minDist, minPath: minPath };
                     }
-                    const neighbors = this.getNeighbors(cur);
-                    for (const neighbor of neighbors) {
-                        if (!seen.has(neighbor)) {
-                            const weight = (_a = this.getEdge(cur, neighbor)) === null || _a === void 0 ? void 0 : _a.weight;
-                            if (typeof weight === 'number') {
-                                const distSrcToNeighbor = distMap.get(neighbor);
-                                if (distSrcToNeighbor) {
-                                    if (dist + weight < distSrcToNeighbor) {
-                                        heap.offer({ id: dist + weight, val: neighbor });
-                                        preMap.set(neighbor, cur);
-                                        distMap.set(neighbor, dist + weight);
+                    var neighbors = this.getNeighbors(cur);
+                    try {
+                        for (var neighbors_5 = (e_12 = void 0, __values(neighbors)), neighbors_5_1 = neighbors_5.next(); !neighbors_5_1.done; neighbors_5_1 = neighbors_5.next()) {
+                            var neighbor = neighbors_5_1.value;
+                            if (!seen.has(neighbor)) {
+                                var weight = (_c = this.getEdge(cur, neighbor)) === null || _c === void 0 ? void 0 : _c.weight;
+                                if (typeof weight === 'number') {
+                                    var distSrcToNeighbor = distMap.get(neighbor);
+                                    if (distSrcToNeighbor) {
+                                        if (dist + weight < distSrcToNeighbor) {
+                                            heap.offer({ id: dist + weight, val: neighbor });
+                                            preMap.set(neighbor, cur);
+                                            distMap.set(neighbor, dist + weight);
+                                        }
                                     }
                                 }
                             }
                         }
                     }
+                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                    finally {
+                        try {
+                            if (neighbors_5_1 && !neighbors_5_1.done && (_b = neighbors_5.return)) _b.call(neighbors_5);
+                        }
+                        finally { if (e_12) throw e_12.error; }
+                    }
                 }
             }
         }
         if (getMinDist) {
-            distMap.forEach((d, v) => {
+            distMap.forEach(function (d, v) {
                 if (v !== srcVertex) {
                     if (d < minDist) {
                         minDist = d;
@@ -415,49 +750,57 @@ class AbstractGraph {
         if (genPaths) {
             getPaths(minDest);
         }
-        return { distMap, preMap, seen, paths, minDist, minPath };
-    }
+        return { distMap: distMap, preMap: preMap, seen: seen, paths: paths, minDist: minDist, minPath: minPath };
+    };
     /**
      * BellmanFord time:O(VE) space:O(V)
      * one to rest pairs
-     * @param src
-     * @param scanNegativeCycle
-     * @param getMin
-     * @param genPath
+     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+     * all other vertices in a graph, and optionally detects negative cycles and generates the minimum path.
+     * @param {V | VertexId} src - The `src` parameter is the source vertex from which the Bellman-Ford algorithm will
+     * start calculating the shortest paths. It can be either a vertex object or a vertex ID.
+     * @param {boolean} [scanNegativeCycle] - A boolean flag indicating whether to scan for negative cycles in the graph.
+     * @param {boolean} [getMin] - The `getMin` parameter is a boolean flag that determines whether the algorithm should
+     * calculate the minimum distance from the source vertex to all other vertices in the graph. If `getMin` is set to
+     * `true`, the algorithm will find the minimum distance and update the `min` variable with the minimum
+     * @param {boolean} [genPath] - A boolean flag indicating whether to generate paths for all vertices from the source
+     * vertex.
+     * @returns The function `bellmanFord` returns an object with the following properties:
      */
-    bellmanFord(src, scanNegativeCycle, getMin, genPath) {
+    AbstractGraph.prototype.bellmanFord = function (src, scanNegativeCycle, getMin, genPath) {
+        var e_14, _a;
         if (getMin === undefined)
             getMin = false;
         if (genPath === undefined)
             genPath = false;
-        const srcVertex = this.getVertex(src);
-        const paths = [];
-        const distMap = new Map();
-        const preMap = new Map(); // predecessor
-        let min = Infinity;
-        let minPath = [];
+        var srcVertex = this.getVertex(src);
+        var paths = [];
+        var distMap = new Map();
+        var preMap = new Map(); // predecessor
+        var min = Infinity;
+        var minPath = [];
         // TODO
-        let hasNegativeCycle = undefined;
+        var hasNegativeCycle;
         if (scanNegativeCycle)
             hasNegativeCycle = false;
         if (!srcVertex)
-            return { hasNegativeCycle, distMap, preMap, paths, min, minPath };
-        const vertices = this._vertices;
-        const numOfVertices = vertices.size;
-        const edges = this.edgeSet();
-        const numOfEdges = edges.length;
-        this._vertices.forEach(vertex => {
+            return { hasNegativeCycle: hasNegativeCycle, distMap: distMap, preMap: preMap, paths: paths, min: min, minPath: minPath };
+        var vertices = this._vertices;
+        var numOfVertices = vertices.size;
+        var edges = this.edgeSet();
+        var numOfEdges = edges.length;
+        this._vertices.forEach(function (vertex) {
             distMap.set(vertex, Infinity);
         });
         distMap.set(srcVertex, 0);
-        for (let i = 1; i < numOfVertices; ++i) {
-            for (let j = 0; j < numOfEdges; ++j) {
-                const ends = this.getEndsOfEdge(edges[j]);
+        for (var i = 1; i < numOfVertices; ++i) {
+            for (var j = 0; j < numOfEdges; ++j) {
+                var ends = this.getEndsOfEdge(edges[j]);
                 if (ends) {
-                    const [s, d] = ends;
-                    const weight = edges[j].weight;
-                    const sWeight = distMap.get(s);
-                    const dWeight = distMap.get(d);
+                    var _b = __read(ends, 2), s = _b[0], d = _b[1];
+                    var weight = edges[j].weight;
+                    var sWeight = distMap.get(s);
+                    var dWeight = distMap.get(d);
                     if (sWeight !== undefined && dWeight !== undefined) {
                         if (distMap.get(s) !== Infinity && sWeight + weight < dWeight) {
                             distMap.set(d, sWeight + weight);
@@ -467,9 +810,9 @@ class AbstractGraph {
                 }
             }
         }
-        let minDest = null;
+        var minDest = null;
         if (getMin) {
-            distMap.forEach((d, v) => {
+            distMap.forEach(function (d, v) {
                 if (v !== srcVertex) {
                     if (d < min) {
                         min = d;
@@ -480,59 +823,78 @@ class AbstractGraph {
             });
         }
         if (genPath) {
-            for (const vertex of vertices) {
-                const path = [vertex[1]];
-                let parent = preMap.get(vertex[1]);
-                while (parent !== undefined) {
-                    path.push(parent);
-                    parent = preMap.get(parent);
+            try {
+                for (var vertices_6 = __values(vertices), vertices_6_1 = vertices_6.next(); !vertices_6_1.done; vertices_6_1 = vertices_6.next()) {
+                    var vertex = vertices_6_1.value;
+                    var vertexOrId = vertex[1];
+                    if (vertexOrId instanceof AbstractVertex) {
+                        var path = [vertexOrId];
+                        var parent = preMap.get(vertexOrId);
+                        while (parent !== undefined) {
+                            path.push(parent);
+                            parent = preMap.get(parent);
+                        }
+                        var reversed = path.reverse();
+                        if (vertex[1] === minDest)
+                            minPath = reversed;
+                        paths.push(reversed);
+                    }
+                }
+            }
+            catch (e_14_1) { e_14 = { error: e_14_1 }; }
+            finally {
+                try {
+                    if (vertices_6_1 && !vertices_6_1.done && (_a = vertices_6.return)) _a.call(vertices_6);
                 }
-                const reversed = path.reverse();
-                if (vertex[1] === minDest)
-                    minPath = reversed;
-                paths.push(reversed);
+                finally { if (e_14) throw e_14.error; }
             }
         }
-        for (let j = 0; j < numOfEdges; ++j) {
-            const ends = this.getEndsOfEdge(edges[j]);
+        for (var j = 0; j < numOfEdges; ++j) {
+            var ends = this.getEndsOfEdge(edges[j]);
             if (ends) {
-                const [s] = ends;
-                const weight = edges[j].weight;
-                const sWeight = distMap.get(s);
+                var _c = __read(ends, 1), s = _c[0];
+                var weight = edges[j].weight;
+                var sWeight = distMap.get(s);
                 if (sWeight) {
                     if (sWeight !== Infinity && sWeight + weight < sWeight)
                         hasNegativeCycle = true;
                 }
             }
         }
-        return { hasNegativeCycle, distMap, preMap, paths, min, minPath };
-    }
+        return { hasNegativeCycle: hasNegativeCycle, distMap: distMap, preMap: preMap, paths: paths, min: min, minPath: minPath };
+    };
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
      * all pairs
+     * The function implements the Floyd-Warshall algorithm to find the shortest path between all pairs of vertices in a
+     * graph.
+     * @returns The function `floyd()` returns an object with two properties: `costs` and `predecessor`. The `costs`
+     * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
+     * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
+     * path between vertices in the
      */
-    floyd() {
+    AbstractGraph.prototype.floyd = function () {
         var _a;
-        const idAndVertices = [...this._vertices];
-        const n = idAndVertices.length;
-        const costs = [];
-        const predecessor = [];
+        var idAndVertices = __spreadArray([], __read(this._vertices), false);
+        var n = idAndVertices.length;
+        var costs = [];
+        var predecessor = [];
         // successors
-        for (let i = 0; i < n; i++) {
+        for (var i = 0; i < n; i++) {
             costs[i] = [];
             predecessor[i] = [];
-            for (let j = 0; j < n; j++) {
+            for (var j = 0; j < n; j++) {
                 predecessor[i][j] = null;
             }
         }
-        for (let i = 0; i < n; i++) {
-            for (let j = 0; j < n; j++) {
+        for (var i = 0; i < n; i++) {
+            for (var j = 0; j < n; j++) {
                 costs[i][j] = ((_a = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])) === null || _a === void 0 ? void 0 : _a.weight) || Infinity;
             }
         }
-        for (let k = 0; k < n; k++) {
-            for (let i = 0; i < n; i++) {
-                for (let j = 0; j < n; j++) {
+        for (var k = 0; k < n; k++) {
+            for (var i = 0; i < n; i++) {
+                for (var j = 0; j < n; j++) {
                     if (costs[i][j] > costs[i][k] + costs[k][j]) {
                         costs[i][j] = costs[i][k] + costs[k][j];
                         predecessor[i][j] = idAndVertices[k][1];
@@ -540,8 +902,8 @@ class AbstractGraph {
                 }
             }
         }
-        return { costs, predecessor };
-    }
+        return { costs: costs, predecessor: predecessor };
+    };
     /**--- start find cycles --- */
     /**
      * Tarjan is an algorithm based on DFS,which is used to solve the connectivity problem of graphs.
@@ -549,12 +911,27 @@ class AbstractGraph {
      * Tarjan can find the articulation points and bridges(critical edges) of undirected graphs in linear time,
      * Tarjan solve the bi-connected components of undirected graphs;
      * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
+     * The `tarjan` function is used to perform various graph analysis tasks such as finding articulation points, bridges,
+     * strongly connected components (SCCs), and cycles in a graph.
+     * @param {boolean} [needArticulationPoints] - A boolean value indicating whether or not to calculate and return the
+     * articulation points in the graph. Articulation points are the vertices in a graph whose removal would increase the
+     * number of connected components in the graph.
+     * @param {boolean} [needBridges] - A boolean flag indicating whether the algorithm should find and return the bridges
+     * (edges whose removal would increase the number of connected components in the graph).
+     * @param {boolean} [needSCCs] - A boolean value indicating whether the Strongly Connected Components (SCCs) of the
+     * graph are needed. If set to true, the function will calculate and return the SCCs of the graph. If set to false, the
+     * SCCs will not be calculated or returned.
+     * @param {boolean} [needCycles] - A boolean flag indicating whether the algorithm should find cycles in the graph. If
+     * set to true, the algorithm will return a map of cycles, where the keys are the low values of the SCCs and the values
+     * are arrays of vertices that form cycles within the SCCs.
+     * @returns The function `tarjan` returns an object with the following properties:
      */
-    tarjan(needArticulationPoints, needBridges, needSCCs, needCycles) {
+    AbstractGraph.prototype.tarjan = function (needArticulationPoints, needBridges, needSCCs, needCycles) {
         // !! in undirected graph we will not let child visit parent when DFS
         // !! articulation point(in DFS search tree not in graph): (cur !== root && cur.has(child)) && (low(child) >= dfn(cur)) || (cur === root && cur.children() >= 2)
         // !! bridge: low(child) > dfn(cur)
-        const defaultConfig = false;
+        var _this = this;
+        var defaultConfig = false;
         if (needArticulationPoints === undefined)
             needArticulationPoints = defaultConfig;
         if (needBridges === undefined)
@@ -563,60 +940,71 @@ class AbstractGraph {
             needSCCs = defaultConfig;
         if (needCycles === undefined)
             needCycles = defaultConfig;
-        const dfnMap = new Map();
-        const lowMap = new Map();
-        const vertices = this._vertices;
-        vertices.forEach(v => {
+        var dfnMap = new Map();
+        var lowMap = new Map();
+        var vertices = this._vertices;
+        vertices.forEach(function (v) {
             dfnMap.set(v, -1);
             lowMap.set(v, Infinity);
         });
-        const [root] = vertices.values();
-        const articulationPoints = [];
-        const bridges = [];
-        let dfn = 0;
-        const dfs = (cur, parent) => {
+        var _a = __read(vertices.values(), 1), root = _a[0];
+        var articulationPoints = [];
+        var bridges = [];
+        var dfn = 0;
+        var dfs = function (cur, parent) {
+            var e_15, _a;
             dfn++;
             dfnMap.set(cur, dfn);
             lowMap.set(cur, dfn);
-            const neighbors = this.getNeighbors(cur);
-            let childCount = 0; // child in DFS tree not child in graph
-            for (const neighbor of neighbors) {
-                if (neighbor !== parent) {
-                    if (dfnMap.get(neighbor) === -1) {
-                        childCount++;
-                        dfs(neighbor, cur);
-                    }
-                    const childLow = lowMap.get(neighbor);
-                    const curLow = lowMap.get(cur);
-                    // TODO after no-non-null-assertion not ensure the logic
-                    if (curLow !== undefined && childLow !== undefined) {
-                        lowMap.set(cur, Math.min(curLow, childLow));
-                    }
-                    const curFromMap = dfnMap.get(cur);
-                    if (childLow !== undefined && curFromMap !== undefined) {
-                        if (needArticulationPoints) {
-                            if ((cur === root && childCount >= 2) || ((cur !== root) && (childLow >= curFromMap))) {
-                                // todo not ensure the logic if (cur === root && childCount >= 2 || ((cur !== root) && (childLow >= curFromMap))) {
-                                articulationPoints.push(cur);
-                            }
+            var neighbors = _this.getNeighbors(cur);
+            var childCount = 0; // child in DFS tree not child in graph
+            try {
+                for (var neighbors_6 = __values(neighbors), neighbors_6_1 = neighbors_6.next(); !neighbors_6_1.done; neighbors_6_1 = neighbors_6.next()) {
+                    var neighbor = neighbors_6_1.value;
+                    if (neighbor !== parent) {
+                        if (dfnMap.get(neighbor) === -1) {
+                            childCount++;
+                            dfs(neighbor, cur);
                         }
-                        if (needBridges) {
-                            if (childLow > curFromMap) {
-                                const edgeCurToNeighbor = this.getEdge(cur, neighbor);
-                                if (edgeCurToNeighbor) {
-                                    bridges.push(edgeCurToNeighbor);
+                        var childLow = lowMap.get(neighbor);
+                        var curLow = lowMap.get(cur);
+                        // TODO after no-non-null-assertion not ensure the logic
+                        if (curLow !== undefined && childLow !== undefined) {
+                            lowMap.set(cur, Math.min(curLow, childLow));
+                        }
+                        var curFromMap = dfnMap.get(cur);
+                        if (childLow !== undefined && curFromMap !== undefined) {
+                            if (needArticulationPoints) {
+                                if ((cur === root && childCount >= 2) || ((cur !== root) && (childLow >= curFromMap))) {
+                                    // todo not ensure the logic if (cur === root && childCount >= 2 || ((cur !== root) && (childLow >= curFromMap))) {
+                                    articulationPoints.push(cur);
+                                }
+                            }
+                            if (needBridges) {
+                                if (childLow > curFromMap) {
+                                    var edgeCurToNeighbor = _this.getEdge(cur, neighbor);
+                                    if (edgeCurToNeighbor) {
+                                        bridges.push(edgeCurToNeighbor);
+                                    }
                                 }
                             }
                         }
                     }
                 }
             }
+            catch (e_15_1) { e_15 = { error: e_15_1 }; }
+            finally {
+                try {
+                    if (neighbors_6_1 && !neighbors_6_1.done && (_a = neighbors_6.return)) _a.call(neighbors_6);
+                }
+                finally { if (e_15) throw e_15.error; }
+            }
         };
         dfs(root, null);
-        let SCCs = new Map();
-        const getSCCs = () => {
-            const SCCs = new Map();
-            lowMap.forEach((low, vertex) => {
+        var SCCs = new Map();
+        var getSCCs = function () {
+            var SCCs = new Map();
+            lowMap.forEach(function (low, vertex) {
                 var _a;
                 if (!SCCs.has(low)) {
                     SCCs.set(low, [vertex]);
@@ -630,19 +1018,20 @@ class AbstractGraph {
         if (needSCCs) {
             SCCs = getSCCs();
         }
-        const cycles = new Map();
+        var cycles = new Map();
         if (needCycles) {
-            let SCCs = new Map();
-            if (SCCs.size < 1) {
-                SCCs = getSCCs();
+            var SCCs_1 = new Map();
+            if (SCCs_1.size < 1) {
+                SCCs_1 = getSCCs();
             }
-            SCCs.forEach((SCC, low) => {
+            SCCs_1.forEach(function (SCC, low) {
                 if (SCC.length > 1) {
                     cycles.set(low, SCC);
                 }
             });
         }
-        return { dfnMap, lowMap, bridges, articulationPoints, SCCs, cycles };
-    }
-}
+        return { dfnMap: dfnMap, lowMap: lowMap, bridges: bridges, articulationPoints: articulationPoints, SCCs: SCCs, cycles: cycles };
+    };
+    return AbstractGraph;
+}());
 exports.AbstractGraph = AbstractGraph;