data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,71 +1,156 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DirectedGraph = exports.DirectedEdge = exports.DirectedVertex = void 0;
-const utils_1 = require("../../utils");
-const abstract_graph_1 = require("./abstract-graph");
-class DirectedVertex extends abstract_graph_1.AbstractVertex {
-    constructor(id) {
-        super(id);
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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);
     }
-}
-exports.DirectedVertex = DirectedVertex;
-class DirectedEdge extends abstract_graph_1.AbstractEdge {
-    constructor(src, dest, weight) {
-        super(weight);
-        this._src = src;
-        this._dest = dest;
-    }
-    get src() {
-        return this._src;
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
     }
-    set src(v) {
-        this._src = v;
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
     }
-    get dest() {
-        return this._dest;
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectedGraph = exports.DirectedEdge = exports.DirectedVertex = void 0;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+var utils_1 = require("../../utils");
+var abstract_graph_1 = require("./abstract-graph");
+var DirectedVertex = /** @class */ (function (_super) {
+    __extends(DirectedVertex, _super);
+    function DirectedVertex(id) {
+        return _super.call(this, id) || this;
     }
-    set dest(v) {
-        this._dest = v;
+    return DirectedVertex;
+}(abstract_graph_1.AbstractVertex));
+exports.DirectedVertex = DirectedVertex;
+var DirectedEdge = /** @class */ (function (_super) {
+    __extends(DirectedEdge, _super);
+    function DirectedEdge(src, dest, weight) {
+        var _this = _super.call(this, weight) || this;
+        _this._src = src;
+        _this._dest = dest;
+        return _this;
     }
-}
+    Object.defineProperty(DirectedEdge.prototype, "src", {
+        get: function () {
+            return this._src;
+        },
+        set: function (v) {
+            this._src = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DirectedEdge.prototype, "dest", {
+        get: function () {
+            return this._dest;
+        },
+        set: function (v) {
+            this._dest = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DirectedEdge;
+}(abstract_graph_1.AbstractEdge));
 exports.DirectedEdge = DirectedEdge;
 // Strongly connected, One direction connected, Weakly connected
-class DirectedGraph extends abstract_graph_1.AbstractGraph {
-    constructor() {
-        super();
-        this._outEdgeMap = new Map();
-        this._inEdgeMap = new Map();
+var DirectedGraph = /** @class */ (function (_super) {
+    __extends(DirectedGraph, _super);
+    function DirectedGraph() {
+        var _this = _super.call(this) || this;
+        _this._outEdgeMap = new Map();
+        _this._inEdgeMap = new Map();
+        return _this;
     }
-    getEdge(srcOrId, destOrId) {
-        let edges = [];
+    /**
+     * The function `getEdge` returns the first edge between two vertices, given their source and destination.
+     * @param {V | null | VertexId} srcOrId - The `srcOrId` parameter can be either a vertex object (`V`), a vertex ID
+     * (`VertexId`), or `null`. It represents the source vertex of the edge.
+     * @param {V | null | VertexId} destOrId - The `destOrId` parameter is either a vertex object (`V`), a vertex ID
+     * (`VertexId`), or `null`. It represents the destination vertex of the edge.
+     * @returns an edge (E) or null.
+     */
+    DirectedGraph.prototype.getEdge = function (srcOrId, destOrId) {
+        var edges = [];
         if (srcOrId !== null && destOrId !== null) {
-            const src = this.getVertex(srcOrId);
-            const dest = this.getVertex(destOrId);
-            if (src && dest) {
-                const srcOutEdges = this._outEdgeMap.get(src);
+            var src = this.getVertex(srcOrId);
+            var dest_1 = this.getVertex(destOrId);
+            if (src && dest_1) {
+                var srcOutEdges = this._outEdgeMap.get(src);
                 if (srcOutEdges) {
-                    edges = srcOutEdges.filter(edge => edge.dest === dest.id);
+                    edges = srcOutEdges.filter(function (edge) { return edge.dest === dest_1.id; });
                 }
             }
         }
         return edges[0] || null;
-    }
-    addEdge(edge) {
+    };
+    /**
+     * The `addEdge` function adds an edge to a graph if the source and destination vertices exist.
+     * @param {E} edge - The parameter `edge` is of type `E`, which represents an edge in the graph. It contains
+     * information about the source vertex (`src`) and the destination vertex (`dest`) of the edge.
+     * @returns The `addEdge` function returns a boolean value. It returns `true` if the edge was successfully added to the
+     * graph, and `false` if either the source or destination vertices of the edge are not present in the graph.
+     */
+    DirectedGraph.prototype.addEdge = function (edge) {
         if (!(this.containsVertex(edge.src) && this.containsVertex(edge.dest))) {
             return false;
         }
-        const srcVertex = this.getVertex(edge.src);
-        const destVertex = this.getVertex(edge.dest);
+        var srcVertex = this.getVertex(edge.src);
+        var destVertex = this.getVertex(edge.dest);
         // TODO after no-non-null-assertion not ensure the logic
         if (srcVertex && destVertex) {
-            const srcOutEdges = this._outEdgeMap.get(srcVertex);
+            var srcOutEdges = this._outEdgeMap.get(srcVertex);
             if (srcOutEdges) {
                 srcOutEdges.push(edge);
             }
             else {
                 this._outEdgeMap.set(srcVertex, [edge]);
             }
-            const destInEdges = this._inEdgeMap.get(destVertex);
+            var destInEdges = this._inEdgeMap.get(destVertex);
             if (destInEdges) {
                 destInEdges.push(edge);
             }
@@ -77,95 +162,194 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
         else {
             return false;
         }
-    }
-    removeEdgeBetween(srcOrId, destOrId) {
-        const src = this.getVertex(srcOrId);
-        const dest = this.getVertex(destOrId);
-        let removed = null;
+    };
+    /**
+     * The function removes an edge between two vertices in a directed graph and returns the removed edge.
+     * @param {V | VertexId} srcOrId - The source vertex or its ID.
+     * @param {V | VertexId} destOrId - The `destOrId` parameter in the `removeEdgeBetween` function represents the
+     * destination vertex of the edge that needs to be removed. It can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The function `removeEdgeBetween` returns the removed edge (`E`) if the edge between the source and
+     * destination vertices is successfully removed. If either the source or destination vertex is not found, or if the
+     * edge does not exist, it returns `null`.
+     */
+    DirectedGraph.prototype.removeEdgeBetween = function (srcOrId, destOrId) {
+        var src = this.getVertex(srcOrId);
+        var dest = this.getVertex(destOrId);
+        var removed = null;
         if (!src || !dest) {
             return null;
         }
-        const srcOutEdges = this._outEdgeMap.get(src);
+        var srcOutEdges = this._outEdgeMap.get(src);
         if (srcOutEdges) {
-            (0, utils_1.arrayRemove)(srcOutEdges, edge => edge.dest === dest.id);
+            /**
+             * The removeEdge function removes an edge from a graph and returns the removed edge, or null if the edge was not
+             * found.
+             * @param {E} edge - The `edge` parameter represents the edge that you want to remove from the graph. It should be an
+             * object that has `src` and `dest` properties, which represent the source and destination vertices of the edge,
+             * respectively.
+             * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+             */
+            (0, utils_1.arrayRemove)(srcOutEdges, function (edge) { return edge.dest === dest.id; });
         }
-        const destInEdges = this._inEdgeMap.get(dest);
+        var destInEdges = this._inEdgeMap.get(dest);
         if (destInEdges) {
-            removed = (0, utils_1.arrayRemove)(destInEdges, edge => edge.src === src.id)[0] || null;
+            removed = (0, utils_1.arrayRemove)(destInEdges, function (edge) { return edge.src === src.id; })[0] || null;
         }
         return removed;
-    }
-    removeEdge(edge) {
-        let removed = null;
-        const src = this.getVertex(edge.src);
-        const dest = this.getVertex(edge.dest);
+    };
+    /**
+     * The removeEdge function removes an edge from a graph and returns the removed edge, or null if the edge was not
+     * found.
+     * @param {E} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
+     * and `dest`, which represent the source and destination vertices of the edge, respectively.
+     * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+     */
+    DirectedGraph.prototype.removeEdge = function (edge) {
+        var removed = null;
+        var src = this.getVertex(edge.src);
+        var dest = this.getVertex(edge.dest);
         if (src && dest) {
-            const srcOutEdges = this._outEdgeMap.get(src);
+            var srcOutEdges = this._outEdgeMap.get(src);
             if (srcOutEdges && srcOutEdges.length > 0) {
-                (0, utils_1.arrayRemove)(srcOutEdges, edge => edge.src === src.id);
+                (0, utils_1.arrayRemove)(srcOutEdges, function (edge) { return edge.src === src.id; });
             }
-            const destInEdges = this._inEdgeMap.get(dest);
+            var destInEdges = this._inEdgeMap.get(dest);
             if (destInEdges && destInEdges.length > 0) {
-                removed = (0, utils_1.arrayRemove)(destInEdges, edge => edge.dest === dest.id)[0];
+                removed = (0, utils_1.arrayRemove)(destInEdges, function (edge) { return edge.dest === dest.id; })[0];
             }
         }
         return removed;
-    }
-    removeAllEdges(src, dest) {
+    };
+    /**
+     * The function removeAllEdges removes all edges between two vertices.
+     * @param {VertexId | V} src - The `src` parameter represents the source vertex from which the edges will be removed.
+     * It can be either a `VertexId` or a `V` type, which represents the identifier or object of the vertex.
+     * @param {VertexId | V} dest - The `dest` parameter represents the destination vertex of an edge. It can be either a
+     * `VertexId` or a vertex object `V`.
+     * @returns An empty array is being returned.
+     */
+    DirectedGraph.prototype.removeAllEdges = function (src, dest) {
         return [];
-    }
-    incomingEdgesOf(vertexOrId) {
-        const target = this.getVertex(vertexOrId);
+    };
+    /**
+     * The function `incomingEdgesOf` returns an array of incoming edges for a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `incomingEdgesOf` returns an array of edges (`E[]`).
+     */
+    DirectedGraph.prototype.incomingEdgesOf = function (vertexOrId) {
+        var target = this.getVertex(vertexOrId);
         if (target) {
             return this._inEdgeMap.get(target) || [];
         }
         return [];
-    }
-    outgoingEdgesOf(vertexOrId) {
-        const target = this.getVertex(vertexOrId);
+    };
+    /**
+     * The function `outgoingEdgesOf` returns an array of outgoing edges from a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `outgoingEdgesOf` returns an array of outgoing edges from a given vertex or vertex ID.
+     */
+    DirectedGraph.prototype.outgoingEdgesOf = function (vertexOrId) {
+        var target = this.getVertex(vertexOrId);
         if (target) {
             return this._outEdgeMap.get(target) || [];
         }
         return [];
-    }
-    degreeOf(vertexOrId) {
+    };
+    /**
+     * The function "degreeOf" returns the total degree of a vertex, which is the sum of its out-degree and in-degree.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns the sum of the out-degree and in-degree of the specified vertex or vertex ID.
+     */
+    DirectedGraph.prototype.degreeOf = function (vertexOrId) {
         return this.outDegreeOf(vertexOrId) + this.inDegreeOf(vertexOrId);
-    }
-    inDegreeOf(vertexOrId) {
+    };
+    /**
+     * The function "inDegreeOf" returns the number of incoming edges for a given vertex.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The number of incoming edges of the specified vertex or vertex ID.
+     */
+    DirectedGraph.prototype.inDegreeOf = function (vertexOrId) {
         return this.incomingEdgesOf(vertexOrId).length;
-    }
-    outDegreeOf(vertexOrId) {
+    };
+    /**
+     * The function `outDegreeOf` returns the number of outgoing edges from a given vertex.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The number of outgoing edges from the specified vertex or vertex ID.
+     */
+    DirectedGraph.prototype.outDegreeOf = function (vertexOrId) {
         return this.outgoingEdgesOf(vertexOrId).length;
-    }
-    edgesOf(vertexOrId) {
-        return [...this.outgoingEdgesOf(vertexOrId), ...this.incomingEdgesOf(vertexOrId)];
-    }
-    getEdgeSrc(e) {
+    };
+    /**
+     * The function "edgesOf" returns an array of both outgoing and incoming edges of a given vertex or vertex ID.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The function `edgesOf` returns an array of edges.
+     */
+    DirectedGraph.prototype.edgesOf = function (vertexOrId) {
+        return __spreadArray(__spreadArray([], __read(this.outgoingEdgesOf(vertexOrId)), false), __read(this.incomingEdgesOf(vertexOrId)), false);
+    };
+    /**
+     * The function "getEdgeSrc" returns the source vertex of an edge, or null if the edge does not exist.
+     * @param {E} e - E - an edge object
+     * @returns the source vertex of the given edge, or null if the edge does not exist.
+     */
+    DirectedGraph.prototype.getEdgeSrc = function (e) {
         return this.getVertex(e.src);
-    }
-    getEdgeDest(e) {
+    };
+    /**
+     * The function "getEdgeDest" returns the vertex associated with the destination of an edge.
+     * @param {E} e - The parameter `e` is of type `E`, which represents an edge in a graph.
+     * @returns either a vertex object (of type V) or null.
+     */
+    DirectedGraph.prototype.getEdgeDest = function (e) {
         return this.getVertex(e.dest);
-    }
-    getDestinations(vertex) {
+    };
+    /**
+     * The function `getDestinations` returns an array of destination vertices connected to a given vertex.
+     * @param {V | VertexId | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
+     * find the destinations. It can be either a `V` object, a `VertexId` (which is a unique identifier for a vertex), or
+     * `null` if we want to find destinations from all vertices.
+     * @returns an array of vertices (V[]).
+     */
+    DirectedGraph.prototype.getDestinations = function (vertex) {
+        var e_1, _a;
         if (vertex === null) {
             return [];
         }
-        const destinations = [];
-        const outgoingEdges = this.outgoingEdgesOf(vertex);
-        for (const outEdge of outgoingEdges) {
-            const child = this.getEdgeDest(outEdge);
-            if (child) {
-                destinations.push(child);
+        var destinations = [];
+        var outgoingEdges = this.outgoingEdgesOf(vertex);
+        try {
+            for (var outgoingEdges_1 = __values(outgoingEdges), outgoingEdges_1_1 = outgoingEdges_1.next(); !outgoingEdges_1_1.done; outgoingEdges_1_1 = outgoingEdges_1.next()) {
+                var outEdge = outgoingEdges_1_1.value;
+                var child = this.getEdgeDest(outEdge);
+                if (child) {
+                    destinations.push(child);
+                }
             }
         }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (outgoingEdges_1_1 && !outgoingEdges_1_1.done && (_a = outgoingEdges_1.return)) _a.call(outgoingEdges_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
         return destinations;
-    }
+    };
     /**--- start find cycles --- */
     /**
      * when stored with adjacency list time: O(V+E)
      * when stored with adjacency matrix time: O(V^2)
+     * The `topologicalSort` function performs a topological sort on a directed graph and returns the sorted vertices in
+     * reverse order, or null if the graph contains a cycle.
+     * @returns The function `topologicalSort()` returns an array of vertices in topological order if there is no cycle in
+     * the graph. If there is a cycle in the graph, it returns `null`.
      */
-    topologicalSort() {
+    DirectedGraph.prototype.topologicalSort = function () {
+        var e_2, _a, e_3, _b;
+        var _this = this;
         // vector<vector<int>> g;
         // vector<int> color;
         // int last;
@@ -197,72 +381,132 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
         // }
         // When judging whether there is a cycle in the undirected graph, all nodes with degree of **<= 1** are enqueued
         // When judging whether there is a cycle in the directed graph, all nodes with **in degree = 0** are enqueued
-        const statusMap = new Map();
-        for (const entry of this._vertices) {
-            statusMap.set(entry[1], 0);
+        var statusMap = new Map();
+        try {
+            for (var _c = __values(this._vertices), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var entry = _d.value;
+                statusMap.set(entry[1], 0);
+            }
         }
-        const sorted = [];
-        let hasCycle = false;
-        const dfs = (cur) => {
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        var sorted = [];
+        var hasCycle = false;
+        var dfs = function (cur) {
+            var e_4, _a;
             statusMap.set(cur, 1);
-            const children = this.getDestinations(cur);
-            for (const child of children) {
-                const childStatus = statusMap.get(child);
-                if (childStatus === 0) {
-                    dfs(child);
+            var children = _this.getDestinations(cur);
+            try {
+                for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
+                    var child = children_1_1.value;
+                    var childStatus = statusMap.get(child);
+                    if (childStatus === 0) {
+                        dfs(child);
+                    }
+                    else if (childStatus === 1) {
+                        hasCycle = true;
+                    }
                 }
-                else if (childStatus === 1) {
-                    hasCycle = true;
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
                 }
+                finally { if (e_4) throw e_4.error; }
             }
             statusMap.set(cur, 2);
             sorted.push(cur);
         };
-        for (const entry of this._vertices) {
-            if (statusMap.get(entry[1]) === 0) {
-                dfs(entry[1]);
+        try {
+            for (var _e = __values(this._vertices), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var entry = _f.value;
+                if (statusMap.get(entry[1]) === 0) {
+                    dfs(entry[1]);
+                }
             }
         }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
         if (hasCycle) {
             return null;
         }
         return sorted.reverse();
-    }
+    };
     /**--- end find cycles --- */
-    edgeSet() {
-        let edges = [];
-        this._outEdgeMap.forEach(outEdges => {
-            edges = [...edges, ...outEdges];
+    /**
+     * The `edgeSet` function returns an array of all the edges in the graph.
+     * @returns The `edgeSet()` method returns an array of edges (`E[]`).
+     */
+    DirectedGraph.prototype.edgeSet = function () {
+        var edges = [];
+        this._outEdgeMap.forEach(function (outEdges) {
+            edges = __spreadArray(__spreadArray([], __read(edges), false), __read(outEdges), false);
         });
         return edges;
-    }
-    getNeighbors(vertexOrId) {
-        const neighbors = [];
-        const vertex = this.getVertex(vertexOrId);
+    };
+    /**
+     * The function `getNeighbors` returns an array of neighboring vertices for a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns an array of vertices (V[]).
+     */
+    DirectedGraph.prototype.getNeighbors = function (vertexOrId) {
+        var e_5, _a;
+        var neighbors = [];
+        var vertex = this.getVertex(vertexOrId);
         if (vertex) {
-            const outEdges = this.outgoingEdgesOf(vertex);
-            for (const outEdge of outEdges) {
-                const neighbor = this.getVertex(outEdge.dest);
-                // TODO after no-non-null-assertion not ensure the logic
-                if (neighbor) {
-                    neighbors.push(neighbor);
+            var outEdges = this.outgoingEdgesOf(vertex);
+            try {
+                for (var outEdges_1 = __values(outEdges), outEdges_1_1 = outEdges_1.next(); !outEdges_1_1.done; outEdges_1_1 = outEdges_1.next()) {
+                    var outEdge = outEdges_1_1.value;
+                    var neighbor = this.getVertex(outEdge.dest);
+                    // TODO after no-non-null-assertion not ensure the logic
+                    if (neighbor) {
+                        neighbors.push(neighbor);
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (outEdges_1_1 && !outEdges_1_1.done && (_a = outEdges_1.return)) _a.call(outEdges_1);
                 }
+                finally { if (e_5) throw e_5.error; }
             }
         }
         return neighbors;
-    }
-    getEndsOfEdge(edge) {
+    };
+    /**
+     * The function "getEndsOfEdge" returns the source and destination vertices of an edge if it exists in the graph,
+     * otherwise it returns null.
+     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
+     * @returns an array containing two vertices [V, V] if the edge is found in the graph. If the edge is not found, it
+     * returns null.
+     */
+    DirectedGraph.prototype.getEndsOfEdge = function (edge) {
         if (!this.containsEdge(edge.src, edge.dest)) {
             return null;
         }
-        const v1 = this.getVertex(edge.src);
-        const v2 = this.getVertex(edge.dest);
+        var v1 = this.getVertex(edge.src);
+        var v2 = this.getVertex(edge.dest);
         if (v1 && v2) {
             return [v1, v2];
         }
         else {
             return null;
         }
-    }
-}
+    };
+    return DirectedGraph;
+}(abstract_graph_1.AbstractGraph));
 exports.DirectedGraph = DirectedGraph;