data-structure-typed 1.34.7 → 1.34.9

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

@@ -1,164 +1,91 @@
 "use strict";
-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; }
-    }
-    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];
-        }
-    }
-    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 = (function () {
-    function AbstractVertex(id, val) {
-        this._id = id;
+const utils_1 = require("../../utils");
+const priority_queue_1 = require("../priority-queue");
+class AbstractVertex {
+    constructor(key, val) {
+        this._key = key;
         this._val = val;
     }
-    Object.defineProperty(AbstractVertex.prototype, "id", {
-        get: function () {
-            return this._id;
-        },
-        set: function (v) {
-            this._id = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractVertex.prototype, "val", {
-        get: function () {
-            return this._val;
-        },
-        set: function (value) {
-            this._val = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return AbstractVertex;
-}());
+    get key() {
+        return this._key;
+    }
+    set key(v) {
+        this._key = v;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(value) {
+        this._val = value;
+    }
+}
 exports.AbstractVertex = AbstractVertex;
-var AbstractEdge = (function () {
-    function AbstractEdge(weight, val) {
+class AbstractEdge {
+    constructor(weight, val) {
         this._weight = weight !== undefined ? weight : 1;
         this._val = val;
         this._hashCode = (0, utils_1.uuidV4)();
     }
-    Object.defineProperty(AbstractEdge.prototype, "val", {
-        get: function () {
-            return this._val;
-        },
-        set: function (value) {
-            this._val = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    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;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    AbstractEdge.prototype._setHashCode = function (v) {
+    get val() {
+        return this._val;
+    }
+    set val(value) {
+        this._val = value;
+    }
+    get weight() {
+        return this._weight;
+    }
+    set weight(v) {
+        this._weight = v;
+    }
+    get hashCode() {
+        return this._hashCode;
+    }
+    _setHashCode(v) {
         this._hashCode = v;
-    };
-    return AbstractEdge;
-}());
+    }
+}
 exports.AbstractEdge = AbstractEdge;
-var AbstractGraph = (function () {
-    function AbstractGraph() {
+class AbstractGraph {
+    constructor() {
         this._vertices = new Map();
     }
-    Object.defineProperty(AbstractGraph.prototype, "vertices", {
-        get: function () {
-            return this._vertices;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    AbstractGraph.prototype.getVertex = function (vertexId) {
-        return this._vertices.get(vertexId) || null;
-    };
-    AbstractGraph.prototype.hasVertex = function (vertexOrId) {
-        return this._vertices.has(this._getVertexId(vertexOrId));
-    };
-    AbstractGraph.prototype.addVertex = function (idOrVertex, val) {
-        if (idOrVertex instanceof AbstractVertex) {
-            return this._addVertexOnly(idOrVertex);
+    get vertices() {
+        return this._vertices;
+    }
+    getVertex(vertexKey) {
+        return this._vertices.get(vertexKey) || null;
+    }
+    hasVertex(vertexOrKey) {
+        return this._vertices.has(this._getVertexKey(vertexOrKey));
+    }
+    addVertex(keyOrVertex, val) {
+        if (keyOrVertex instanceof AbstractVertex) {
+            return this._addVertexOnly(keyOrVertex);
         }
         else {
-            var newVertex = this.createVertex(idOrVertex, val);
+            const newVertex = this.createVertex(keyOrVertex, val);
             return this._addVertexOnly(newVertex);
         }
-    };
-    AbstractGraph.prototype.removeVertex = function (vertexOrId) {
-        var vertexId = this._getVertexId(vertexOrId);
-        return this._vertices.delete(vertexId);
-    };
-    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; }
+    }
+    removeVertex(vertexOrKey) {
+        const vertexKey = this._getVertexKey(vertexOrKey);
+        return this._vertices.delete(vertexKey);
+    }
+    removeAllVertices(vertices) {
+        const removed = [];
+        for (const v of vertices) {
+            removed.push(this.removeVertex(v));
         }
         return removed.length > 0;
-    };
-    AbstractGraph.prototype.hasEdge = function (v1, v2) {
-        var edge = this.getEdge(v1, v2);
+    }
+    hasEdge(v1, v2) {
+        const edge = this.getEdge(v1, v2);
         return !!edge;
-    };
-    AbstractGraph.prototype.addEdge = function (srcOrEdge, dest, weight, val) {
+    }
+    addEdge(srcOrEdge, dest, weight, val) {
         if (srcOrEdge instanceof AbstractEdge) {
             return this._addEdgeOnly(srcOrEdge);
         }
@@ -167,19 +94,19 @@ var AbstractGraph = (function () {
                 if (!(this.hasVertex(srcOrEdge) && this.hasVertex(dest)))
                     return false;
                 if (srcOrEdge instanceof AbstractVertex)
-                    srcOrEdge = srcOrEdge.id;
+                    srcOrEdge = srcOrEdge.key;
                 if (dest instanceof AbstractVertex)
-                    dest = dest.id;
-                var newEdge = this.createEdge(srcOrEdge, dest, weight, val);
+                    dest = dest.key;
+                const newEdge = this.createEdge(srcOrEdge, dest, weight, val);
                 return this._addEdgeOnly(newEdge);
             }
             else {
-                throw new Error('dest must be a Vertex or vertex id while srcOrEdge is an Edge');
+                throw new Error('dest must be a Vertex or vertex key while srcOrEdge is an Edge');
             }
         }
-    };
-    AbstractGraph.prototype.setEdgeWeight = function (srcOrId, destOrId, weight) {
-        var edge = this.getEdge(srcOrId, destOrId);
+    }
+    setEdgeWeight(srcOrKey, destOrKey, weight) {
+        const edge = this.getEdge(srcOrKey, destOrKey);
         if (edge) {
             edge.weight = weight;
             return true;
@@ -187,281 +114,186 @@ var AbstractGraph = (function () {
         else {
             return false;
         }
-    };
-    AbstractGraph.prototype.getAllPathsBetween = function (v1, v2) {
-        var _this = this;
-        var paths = [];
-        var vertex1 = this._getVertex(v1);
-        var vertex2 = this._getVertex(v2);
+    }
+    getAllPathsBetween(v1, v2) {
+        const paths = [];
+        const vertex1 = this._getVertex(v1);
+        const vertex2 = this._getVertex(v2);
         if (!(vertex1 && vertex2)) {
             return [];
         }
-        var dfs = function (cur, dest, visiting, path) {
-            var e_2, _a;
+        const dfs = (cur, dest, visiting, path) => {
             visiting.set(cur, true);
             if (cur === dest) {
-                paths.push(__spreadArray([vertex1], __read(path), false));
+                paths.push([vertex1, ...path]);
             }
-            var neighbors = _this.getNeighbors(cur);
-            var _loop_1 = function (neighbor) {
+            const neighbors = this.getNeighbors(cur);
+            for (const neighbor of neighbors) {
                 if (!visiting.get(neighbor)) {
                     path.push(neighbor);
                     dfs(neighbor, dest, visiting, path);
-                    (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);
+                    (0, utils_1.arrayRemove)(path, (vertex) => vertex === neighbor);
                 }
-                finally { if (e_2) throw e_2.error; }
             }
             visiting.set(cur, false);
         };
         dfs(vertex1, vertex2, new Map(), []);
         return paths;
-    };
-    AbstractGraph.prototype.getPathSumWeight = function (path) {
+    }
+    getPathSumWeight(path) {
         var _a;
-        var sum = 0;
-        for (var i = 0; i < path.length; i++) {
+        let sum = 0;
+        for (let 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;
-    };
-    AbstractGraph.prototype.getMinCostBetween = function (v1, v2, isWeight) {
-        var e_3, _a, e_4, _b;
+    }
+    getMinCostBetween(v1, v2, isWeight) {
         if (isWeight === undefined)
             isWeight = false;
         if (isWeight) {
-            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; }
+            const allPaths = this.getAllPathsBetween(v1, v2);
+            let min = Infinity;
+            for (const path of allPaths) {
+                min = Math.min(this.getPathSumWeight(path), min);
             }
             return min;
         }
         else {
-            var vertex2 = this._getVertex(v2);
-            var vertex1 = this._getVertex(v1);
+            const vertex2 = this._getVertex(v2);
+            const vertex1 = this._getVertex(v1);
             if (!(vertex1 && vertex2)) {
                 return null;
             }
-            var visited = new Map();
-            var queue = [vertex1];
+            const visited = new Map();
+            const queue = [vertex1];
             visited.set(vertex1, true);
-            var cost = 0;
+            let cost = 0;
             while (queue.length > 0) {
-                for (var i = 0; i < queue.length; i++) {
-                    var cur = queue.shift();
+                for (let i = 0; i < queue.length; i++) {
+                    const cur = queue.shift();
                     if (cur === vertex2) {
                         return cost;
                     }
                     if (cur !== undefined) {
-                        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);
-                                }
+                        const neighbors = this.getNeighbors(cur);
+                        for (const neighbor of neighbors) {
+                            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; }
-                        }
                     }
                 }
                 cost++;
             }
             return null;
         }
-    };
-    AbstractGraph.prototype.getMinPathBetween = function (v1, v2, isWeight) {
-        var e_5, _a;
-        var _this = this;
+    }
+    getMinPathBetween(v1, v2, isWeight) {
         if (isWeight === undefined)
             isWeight = false;
         if (isWeight) {
-            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; }
+            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++;
             }
             return allPaths[minIndex] || null;
         }
         else {
-            var minPath_1 = [];
-            var vertex1_1 = this._getVertex(v1);
-            var vertex2 = this._getVertex(v2);
-            if (!(vertex1_1 && vertex2)) {
+            let minPath = [];
+            const vertex1 = this._getVertex(v1);
+            const vertex2 = this._getVertex(v2);
+            if (!(vertex1 && vertex2)) {
                 return [];
             }
-            var dfs_1 = function (cur, dest, visiting, path) {
-                var e_6, _a;
+            const dfs = (cur, dest, visiting, path) => {
                 visiting.set(cur, true);
                 if (cur === dest) {
-                    minPath_1 = __spreadArray([vertex1_1], __read(path), false);
+                    minPath = [vertex1, ...path];
                     return;
                 }
-                var neighbors = _this.getNeighbors(cur);
-                var _loop_2 = function (neighbor) {
+                const neighbors = this.getNeighbors(cur);
+                for (const neighbor of neighbors) {
                     if (!visiting.get(neighbor)) {
                         path.push(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);
+                        dfs(neighbor, dest, visiting, path);
+                        (0, utils_1.arrayRemove)(path, (vertex) => vertex === 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_1(vertex1_1, vertex2, new Map(), []);
-            return minPath_1;
+            dfs(vertex1, vertex2, new Map(), []);
+            return minPath;
         }
-    };
-    AbstractGraph.prototype.dijkstraWithoutHeap = function (src, dest, getMinDist, genPaths) {
-        var e_7, _a, e_8, _b;
+    }
+    dijkstraWithoutHeap(src, dest, getMinDist, genPaths) {
         if (getMinDist === undefined)
             getMinDist = false;
         if (genPaths === undefined)
             genPaths = false;
         if (dest === undefined)
             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();
-        var srcVertex = this._getVertex(src);
-        var destVertex = dest ? this._getVertex(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();
+        const srcVertex = this._getVertex(src);
+        const destVertex = dest ? this._getVertex(dest) : null;
         if (!srcVertex) {
             return null;
         }
-        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; }
+        for (const vertex of vertices) {
+            const vertexOrKey = vertex[1];
+            if (vertexOrKey instanceof AbstractVertex)
+                distMap.set(vertexOrKey, Infinity);
         }
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
-        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;
-                        }
+        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;
                     }
                 }
             }
-            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;
         };
-        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);
+        const getPaths = (minV) => {
+            for (const vertex of vertices) {
+                const vertexOrKey = vertex[1];
+                if (vertexOrKey instanceof AbstractVertex) {
+                    const path = [vertexOrKey];
+                    let parent = preMap.get(vertexOrKey);
+                    while (parent) {
+                        path.push(parent);
+                        parent = preMap.get(parent);
                     }
+                    const 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 (var i = 1; i < vertices.size; i++) {
-            var cur = getMinOfNoSeen();
+        for (let i = 1; i < vertices.size; i++) {
+            const cur = getMinOfNoSeen();
             if (cur) {
                 seen.add(cur);
                 if (destVertex && destVertex === cur) {
@@ -471,38 +303,28 @@ var AbstractGraph = (function () {
                     if (genPaths) {
                         getPaths(destVertex);
                     }
-                    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);
-                                if (curFromMap !== undefined && neighborFromMap !== undefined) {
-                                    if (edge.weight + curFromMap < neighborFromMap) {
-                                        distMap.set(neighbor, edge.weight + curFromMap);
-                                        preMap.set(neighbor, cur);
-                                    }
+                    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);
+                            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(function (d, v) {
+            distMap.forEach((d, v) => {
                 if (v !== srcVertex) {
                     if (d < minDist) {
                         minDist = d;
@@ -512,82 +334,60 @@ var AbstractGraph = (function () {
                 }
             });
         genPaths && getPaths(minDest);
-        return { distMap: distMap, preMap: preMap, seen: seen, paths: paths, minDist: minDist, minPath: minPath };
-    };
-    AbstractGraph.prototype.dijkstra = function (src, dest, getMinDist, genPaths) {
-        var e_11, _a, e_12, _b;
-        var _c;
+        return { distMap, preMap, seen, paths, minDist, minPath };
+    }
+    dijkstra(src, dest, getMinDist, genPaths) {
+        var _a;
         if (getMinDist === undefined)
             getMinDist = false;
         if (genPaths === undefined)
             genPaths = false;
         if (dest === undefined)
             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();
-        var srcVertex = this._getVertex(src);
-        var destVertex = dest ? this._getVertex(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();
+        const srcVertex = this._getVertex(src);
+        const destVertex = dest ? this._getVertex(dest) : null;
         if (!srcVertex)
             return null;
-        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);
-            }
+        for (const vertex of vertices) {
+            const vertexOrKey = vertex[1];
+            if (vertexOrKey instanceof AbstractVertex)
+                distMap.set(vertexOrKey, 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; }
-        }
-        var heap = new priority_queue_1.PriorityQueue({
-            comparator: function (a, b) { return a.id - b.id; }
+        const heap = new priority_queue_1.PriorityQueue({
+            comparator: (a, b) => a.key - b.key
         });
-        heap.add({ id: 0, val: srcVertex });
+        heap.add({ key: 0, val: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
-        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);
+        const getPaths = (minV) => {
+            for (const vertex of vertices) {
+                const vertexOrKey = vertex[1];
+                if (vertexOrKey instanceof AbstractVertex) {
+                    const path = [vertexOrKey];
+                    let parent = preMap.get(vertexOrKey);
+                    while (parent) {
+                        path.push(parent);
+                        parent = preMap.get(parent);
                     }
+                    const 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) {
-            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;
+            const curHeapNode = heap.poll();
+            const dist = curHeapNode === null || curHeapNode === void 0 ? void 0 : curHeapNode.key;
+            const cur = curHeapNode === null || curHeapNode === void 0 ? void 0 : curHeapNode.val;
             if (dist !== undefined) {
                 if (cur) {
                     seen.add(cur);
@@ -598,39 +398,29 @@ var AbstractGraph = (function () {
                         if (genPaths) {
                             getPaths(destVertex);
                         }
-                        return { distMap: distMap, preMap: preMap, seen: seen, paths: paths, minDist: minDist, minPath: minPath };
+                        return { distMap, preMap, seen, paths, minDist, minPath };
                     }
-                    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.add({ id: dist + weight, val: neighbor });
-                                            preMap.set(neighbor, cur);
-                                            distMap.set(neighbor, dist + weight);
-                                        }
+                    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.add({ key: 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(function (d, v) {
+            distMap.forEach((d, v) => {
                 if (v !== srcVertex) {
                     if (d < minDist) {
                         minDist = d;
@@ -643,41 +433,40 @@ var AbstractGraph = (function () {
         if (genPaths) {
             getPaths(minDest);
         }
-        return { distMap: distMap, preMap: preMap, seen: seen, paths: paths, minDist: minDist, minPath: minPath };
-    };
-    AbstractGraph.prototype.bellmanFord = function (src, scanNegativeCycle, getMin, genPath) {
-        var e_14, _a;
+        return { distMap, preMap, seen, paths, minDist, minPath };
+    }
+    bellmanFord(src, scanNegativeCycle, getMin, genPath) {
         if (getMin === undefined)
             getMin = false;
         if (genPath === undefined)
             genPath = false;
-        var srcVertex = this._getVertex(src);
-        var paths = [];
-        var distMap = new Map();
-        var preMap = new Map();
-        var min = Infinity;
-        var minPath = [];
-        var hasNegativeCycle;
+        const srcVertex = this._getVertex(src);
+        const paths = [];
+        const distMap = new Map();
+        const preMap = new Map();
+        let min = Infinity;
+        let minPath = [];
+        let hasNegativeCycle;
         if (scanNegativeCycle)
             hasNegativeCycle = false;
         if (!srcVertex)
-            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) {
+            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 => {
             distMap.set(vertex, Infinity);
         });
         distMap.set(srcVertex, 0);
-        for (var i = 1; i < numOfVertices; ++i) {
-            for (var j = 0; j < numOfEdges; ++j) {
-                var ends = this.getEndsOfEdge(edges[j]);
+        for (let i = 1; i < numOfVertices; ++i) {
+            for (let j = 0; j < numOfEdges; ++j) {
+                const ends = this.getEndsOfEdge(edges[j]);
                 if (ends) {
-                    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);
+                    const [s, d] = ends;
+                    const weight = edges[j].weight;
+                    const sWeight = distMap.get(s);
+                    const dWeight = distMap.get(d);
                     if (sWeight !== undefined && dWeight !== undefined) {
                         if (distMap.get(s) !== Infinity && sWeight + weight < dWeight) {
                             distMap.set(d, sWeight + weight);
@@ -687,9 +476,9 @@ var AbstractGraph = (function () {
                 }
             }
         }
-        var minDest = null;
+        let minDest = null;
         if (getMin) {
-            distMap.forEach(function (d, v) {
+            distMap.forEach((d, v) => {
                 if (v !== srcVertex) {
                     if (d < min) {
                         min = d;
@@ -700,67 +489,57 @@ var AbstractGraph = (function () {
             });
         }
         if (genPath) {
-            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);
+            for (const vertex of vertices) {
+                const vertexOrKey = vertex[1];
+                if (vertexOrKey instanceof AbstractVertex) {
+                    const path = [vertexOrKey];
+                    let parent = preMap.get(vertexOrKey);
+                    while (parent !== undefined) {
+                        path.push(parent);
+                        parent = preMap.get(parent);
                     }
+                    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 (var j = 0; j < numOfEdges; ++j) {
-            var ends = this.getEndsOfEdge(edges[j]);
+        for (let j = 0; j < numOfEdges; ++j) {
+            const ends = this.getEndsOfEdge(edges[j]);
             if (ends) {
-                var _c = __read(ends, 1), s = _c[0];
-                var weight = edges[j].weight;
-                var sWeight = distMap.get(s);
+                const [s] = ends;
+                const weight = edges[j].weight;
+                const sWeight = distMap.get(s);
                 if (sWeight) {
                     if (sWeight !== Infinity && sWeight + weight < sWeight)
                         hasNegativeCycle = true;
                 }
             }
         }
-        return { hasNegativeCycle: hasNegativeCycle, distMap: distMap, preMap: preMap, paths: paths, min: min, minPath: minPath };
-    };
-    AbstractGraph.prototype.floyd = function () {
+        return { hasNegativeCycle, distMap, preMap, paths, min, minPath };
+    }
+    floyd() {
         var _a;
-        var idAndVertices = __spreadArray([], __read(this._vertices), false);
-        var n = idAndVertices.length;
-        var costs = [];
-        var predecessor = [];
-        for (var i = 0; i < n; i++) {
+        const idAndVertices = [...this._vertices];
+        const n = idAndVertices.length;
+        const costs = [];
+        const predecessor = [];
+        for (let i = 0; i < n; i++) {
             costs[i] = [];
             predecessor[i] = [];
-            for (var j = 0; j < n; j++) {
+            for (let j = 0; j < n; j++) {
                 predecessor[i][j] = null;
             }
         }
-        for (var i = 0; i < n; i++) {
-            for (var j = 0; j < n; j++) {
+        for (let i = 0; i < n; i++) {
+            for (let 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 (var k = 0; k < n; k++) {
-            for (var i = 0; i < n; i++) {
-                for (var j = 0; j < n; j++) {
+        for (let k = 0; k < n; k++) {
+            for (let i = 0; i < n; i++) {
+                for (let 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];
@@ -768,11 +547,10 @@ var AbstractGraph = (function () {
                 }
             }
         }
-        return { costs: costs, predecessor: predecessor };
-    };
-    AbstractGraph.prototype.tarjan = function (needArticulationPoints, needBridges, needSCCs, needCycles) {
-        var _this = this;
-        var defaultConfig = false;
+        return { costs, predecessor };
+    }
+    tarjan(needArticulationPoints, needBridges, needSCCs, needCycles) {
+        const defaultConfig = false;
         if (needArticulationPoints === undefined)
             needArticulationPoints = defaultConfig;
         if (needBridges === undefined)
@@ -781,69 +559,58 @@ var AbstractGraph = (function () {
             needSCCs = defaultConfig;
         if (needCycles === undefined)
             needCycles = defaultConfig;
-        var dfnMap = new Map();
-        var lowMap = new Map();
-        var vertices = this._vertices;
-        vertices.forEach(function (v) {
+        const dfnMap = new Map();
+        const lowMap = new Map();
+        const vertices = this._vertices;
+        vertices.forEach(v => {
             dfnMap.set(v, -1);
             lowMap.set(v, Infinity);
         });
-        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;
+        const [root] = vertices.values();
+        const articulationPoints = [];
+        const bridges = [];
+        let dfn = 0;
+        const dfs = (cur, parent) => {
             dfn++;
             dfnMap.set(cur, dfn);
             lowMap.set(cur, dfn);
-            var neighbors = _this.getNeighbors(cur);
-            var childCount = 0;
-            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);
-                        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)) {
-                                    articulationPoints.push(cur);
-                                }
+            const neighbors = this.getNeighbors(cur);
+            let childCount = 0;
+            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);
+                    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)) {
+                                articulationPoints.push(cur);
                             }
-                            if (needBridges) {
-                                if (childLow > curFromMap) {
-                                    var edgeCurToNeighbor = _this.getEdge(cur, neighbor);
-                                    if (edgeCurToNeighbor) {
-                                        bridges.push(edgeCurToNeighbor);
-                                    }
+                        }
+                        if (needBridges) {
+                            if (childLow > curFromMap) {
+                                const 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);
-        var SCCs = new Map();
-        var getSCCs = function () {
-            var SCCs = new Map();
-            lowMap.forEach(function (low, vertex) {
+        let SCCs = new Map();
+        const getSCCs = () => {
+            const SCCs = new Map();
+            lowMap.forEach((low, vertex) => {
                 var _a;
                 if (!SCCs.has(low)) {
                     SCCs.set(low, [vertex]);
@@ -857,38 +624,37 @@ var AbstractGraph = (function () {
         if (needSCCs) {
             SCCs = getSCCs();
         }
-        var cycles = new Map();
+        const cycles = new Map();
         if (needCycles) {
-            var SCCs_1 = new Map();
-            if (SCCs_1.size < 1) {
-                SCCs_1 = getSCCs();
+            let SCCs = new Map();
+            if (SCCs.size < 1) {
+                SCCs = getSCCs();
             }
-            SCCs_1.forEach(function (SCC, low) {
+            SCCs.forEach((SCC, low) => {
                 if (SCC.length > 1) {
                     cycles.set(low, SCC);
                 }
             });
         }
-        return { dfnMap: dfnMap, lowMap: lowMap, bridges: bridges, articulationPoints: articulationPoints, SCCs: SCCs, cycles: cycles };
-    };
-    AbstractGraph.prototype._addVertexOnly = function (newVertex) {
+        return { dfnMap, lowMap, bridges, articulationPoints, SCCs, cycles };
+    }
+    _addVertexOnly(newVertex) {
         if (this.hasVertex(newVertex)) {
             return false;
         }
-        this._vertices.set(newVertex.id, newVertex);
+        this._vertices.set(newVertex.key, newVertex);
         return true;
-    };
-    AbstractGraph.prototype._getVertex = function (vertexOrId) {
-        var vertexId = this._getVertexId(vertexOrId);
-        return this._vertices.get(vertexId) || null;
-    };
-    AbstractGraph.prototype._getVertexId = function (vertexOrId) {
-        return vertexOrId instanceof AbstractVertex ? vertexOrId.id : vertexOrId;
-    };
-    AbstractGraph.prototype._setVertices = function (value) {
+    }
+    _getVertex(vertexOrKey) {
+        const vertexKey = this._getVertexKey(vertexOrKey);
+        return this._vertices.get(vertexKey) || null;
+    }
+    _getVertexKey(vertexOrKey) {
+        return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
+    }
+    _setVertices(value) {
         this._vertices = value;
-    };
-    return AbstractGraph;
-}());
+    }
+}
 exports.AbstractGraph = AbstractGraph;
 //# sourceMappingURL=abstract-graph.js.map