data-structure-typed 0.8.18 → 0.9.16

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

@@ -1,88 +1,149 @@
 "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);
     }
-    set id(v) {
-        this._id = v;
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    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;
+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);
+    AbstractGraph.prototype.getVertex = function (vertexOrId) {
+        var vertexId = this.getVertexId(vertexOrId);
         return this._vertices.get(vertexId) || null;
-    }
-    getVertexId(vertexOrId) {
+    };
+    AbstractGraph.prototype.getVertexId = function (vertexOrId) {
         return vertexOrId instanceof AbstractVertex ? vertexOrId.id : vertexOrId;
-    }
-    containsVertex(vertexOrId) {
+    };
+    AbstractGraph.prototype.containsVertex = function (vertexOrId) {
         return this._vertices.has(this.getVertexId(vertexOrId));
-    }
-    vertexSet() {
+    };
+    AbstractGraph.prototype.vertexSet = function () {
         return this._vertices;
-    }
-    addVertex(newVertex) {
+    };
+    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);
+    };
+    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));
+    };
+    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);
+    };
+    AbstractGraph.prototype.containsEdge = function (v1, v2) {
+        var edge = this.getEdge(v1, v2);
         return !!edge;
-    }
-    setEdgeWeight(srcOrId, destOrId, weight) {
-        const edge = this.getEdge(srcOrId, destOrId);
+    };
+    AbstractGraph.prototype.setEdgeWeight = function (srcOrId, destOrId, weight) {
+        var edge = this.getEdge(srcOrId, destOrId);
         if (edge) {
             edge.weight = weight;
             return true;
@@ -90,76 +151,112 @@ class AbstractGraph {
         else {
             return false;
         }
-    }
-    getAllPathsBetween(v1, v2) {
-        const paths = [];
-        const vertex1 = this.getVertex(v1);
-        const vertex2 = this.getVertex(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) {
+    };
+    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) {
+    };
+    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,53 +264,79 @@ class AbstractGraph {
             }
             return null;
         }
-    }
-    getMinPathBetween(v1, v2, isWeight) {
+    };
+    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
@@ -221,60 +344,98 @@ class AbstractGraph {
      * @param getMinDist
      * @param genPaths
      */
-    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 +445,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,8 +486,8 @@ 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
@@ -324,52 +495,79 @@ class AbstractGraph {
      * @param getMinDist
      * @param genPaths
      */
-    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 +578,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,8 +623,8 @@ 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
@@ -425,39 +633,40 @@ class AbstractGraph {
      * @param getMin
      * @param genPath
      */
-    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 +676,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 +689,72 @@ 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);
+                    }
                 }
-                const 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);
+                }
+                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
      */
-    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 +762,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.
@@ -550,11 +772,12 @@ class AbstractGraph {
      * Tarjan solve the bi-connected components of undirected graphs;
      * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
      */
-    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 +786,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);
+                        }
+                        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));
                         }
-                        if (needBridges) {
-                            if (childLow > curFromMap) {
-                                const edgeCurToNeighbor = this.getEdge(cur, neighbor);
-                                if (edgeCurToNeighbor) {
-                                    bridges.push(edgeCurToNeighbor);
+                        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 +864,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;