@appland/scanner 1.54.1 → 1.57.0

package/CHANGELOG.md

@@ -1,3 +1,34 @@
+# [@appland/scanner-v1.57.0](https://github.com/applandinc/appmap-js/compare/@appland/scanner-v1.56.1...@appland/scanner-v1.57.0) (2022-05-23)
+
+
+### Features
+
+* Collect scanning telemetry ([adc71b7](https://github.com/applandinc/appmap-js/commit/adc71b7d43ae302ac3b85b8577a01bdcfa0176ea))
+* Send telemetry on scanning errors ([0828a8a](https://github.com/applandinc/appmap-js/commit/0828a8a5a61247ab923e2fe9b302970accd3b10d))
+
+# [@appland/scanner-v1.56.1](https://github.com/applandinc/appmap-js/compare/@appland/scanner-v1.56.0...@appland/scanner-v1.56.1) (2022-05-16)
+
+
+### Bug Fixes
+
+* Have scanner prune AppMaps before uploading ([1de9f55](https://github.com/applandinc/appmap-js/commit/1de9f55fa25668a8bfe95def458bf8d5aa7dbae3))
+
+# [@appland/scanner-v1.56.0](https://github.com/applandinc/appmap-js/compare/@appland/scanner-v1.55.0...@appland/scanner-v1.56.0) (2022-05-11)
+
+
+### Features
+
+* Add --watch flag to scan command ([51cb6fc](https://github.com/applandinc/appmap-js/commit/51cb6fc168e1b416587077e26c09d4e54dc9565b))
+
+# [@appland/scanner-v1.55.0](https://github.com/applandinc/appmap-js/compare/@appland/scanner-v1.54.1...@appland/scanner-v1.55.0) (2022-05-10)
+
+
+### Features
+
+* Change default file names ([e173fbb](https://github.com/applandinc/appmap-js/commit/e173fbbe464c8076133f91e04ecdb531dd80c13f))
+* Read appmap_dir from appmap.yml ([b0b6b0d](https://github.com/applandinc/appmap-js/commit/b0b6b0db45eec8c0b8fa96d0f3005677a43f813b))
+* Support repeated appmap-file option ([62edf68](https://github.com/applandinc/appmap-js/commit/62edf68a00d2e169cfbfed5e63246b5fbec947d7))
+
 # [@appland/scanner-v1.54.1](https://github.com/applandinc/appmap-js/compare/@appland/scanner-v1.54.0...@appland/scanner-v1.54.1) (2022-05-03)
 
 

package/built/algorithms/dataStructures/graph/Graph.js

@@ -1,44 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var Graph = /** @class */ (function () {
+class Graph {
     /**
      * @param {boolean} isDirected
      */
-    function Graph(isDirected) {
-        if (isDirected === void 0) { isDirected = false; }
+    constructor(isDirected = false) {
         this.vertices = {};
         this.edges = {};
         this.vertices = {};
         this.edges = {};
         this.isDirected = isDirected;
     }
-    Object.defineProperty(Graph.prototype, "vertexCount", {
-        get: function () {
-            return Object.keys(this.vertices).length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Graph.prototype.addVertex = function (newVertex) {
+    get vertexCount() {
+        return Object.keys(this.vertices).length;
+    }
+    addVertex(newVertex) {
         this.vertices[newVertex.getKey()] = newVertex;
         return this;
-    };
-    Graph.prototype.getVertexByKey = function (vertexKey) {
+    }
+    getVertexByKey(vertexKey) {
         return this.vertices[vertexKey];
-    };
-    Graph.prototype.getNeighbors = function (vertex) {
+    }
+    getNeighbors(vertex) {
         return vertex.getNeighbors();
-    };
-    Graph.prototype.getAllVertices = function () {
+    }
+    getAllVertices() {
         return Object.values(this.vertices);
-    };
-    Graph.prototype.getAllEdges = function () {
+    }
+    getAllEdges() {
         return Object.values(this.edges);
-    };
-    Graph.prototype.addEdge = function (edge) {
+    }
+    addEdge(edge) {
         // Try to find and end start vertices.
-        var startVertex = this.getVertexByKey(edge.startVertex.getKey());
-        var endVertex = this.getVertexByKey(edge.endVertex.getKey());
+        let startVertex = this.getVertexByKey(edge.startVertex.getKey());
+        let endVertex = this.getVertexByKey(edge.endVertex.getKey());
         // Insert start vertex if it wasn't inserted.
         if (!startVertex) {
             this.addVertex(edge.startVertex);
@@ -67,8 +62,8 @@ var Graph = /** @class */ (function () {
             endVertex.addEdge(edge);
         }
         return this;
-    };
-    Graph.prototype.deleteEdge = function (edge) {
+    }
+    deleteEdge(edge) {
         // Delete edge from the list of edges.
         if (this.edges[edge.getKey()]) {
             delete this.edges[edge.getKey()];
@@ -77,79 +72,75 @@ var Graph = /** @class */ (function () {
             throw new Error('Edge not found in graph');
         }
         // Try to find and end start vertices and delete edge from them.
-        var startVertex = this.getVertexByKey(edge.startVertex.getKey());
-        var endVertex = this.getVertexByKey(edge.endVertex.getKey());
+        const startVertex = this.getVertexByKey(edge.startVertex.getKey());
+        const endVertex = this.getVertexByKey(edge.endVertex.getKey());
         if (startVertex) {
             startVertex.deleteEdge(edge);
         }
         if (endVertex) {
             endVertex.deleteEdge(edge);
         }
-    };
-    Graph.prototype.findEdge = function (startVertex, endVertex) {
-        var vertex = this.getVertexByKey(startVertex.getKey());
+    }
+    findEdge(startVertex, endVertex) {
+        const vertex = this.getVertexByKey(startVertex.getKey());
         if (!vertex) {
             return null;
         }
         return vertex.findEdge(endVertex);
-    };
-    Graph.prototype.findVertexByKey = function (vertexKey) {
+    }
+    findVertexByKey(vertexKey) {
         if (this.vertices[vertexKey]) {
             return this.vertices[vertexKey];
         }
         return null;
-    };
-    Graph.prototype.getWeight = function () {
-        return this.getAllEdges().reduce(function (weight, graphEdge) {
+    }
+    getWeight() {
+        return this.getAllEdges().reduce((weight, graphEdge) => {
             return weight + graphEdge.weight;
         }, 0);
-    };
+    }
     /**
      * Reverse all the edges in directed graph.
      */
-    Graph.prototype.reverse = function () {
-        var _this = this;
-        this.getAllEdges().forEach(function (edge) {
+    reverse() {
+        this.getAllEdges().forEach((edge) => {
             // Delete straight edge from graph and from vertices.
-            _this.deleteEdge(edge);
+            this.deleteEdge(edge);
             // Reverse the edge.
             edge.reverse();
             // Add reversed edge back to the graph and its vertices.
-            _this.addEdge(edge);
+            this.addEdge(edge);
         });
         return this;
-    };
-    Graph.prototype.getVerticesIndices = function () {
-        var verticesIndices = {};
-        this.getAllVertices().forEach(function (vertex, index) {
+    }
+    getVerticesIndices() {
+        const verticesIndices = {};
+        this.getAllVertices().forEach((vertex, index) => {
             verticesIndices[vertex.getKey()] = index;
         });
         return verticesIndices;
-    };
-    Graph.prototype.getAdjacencyMatrix = function () {
-        var _this = this;
-        var vertices = this.getAllVertices();
-        var verticesIndices = this.getVerticesIndices();
+    }
+    getAdjacencyMatrix() {
+        const vertices = this.getAllVertices();
+        const verticesIndices = this.getVerticesIndices();
         // Init matrix with infinities meaning that there is no ways of
         // getting from one vertex to another yet.
-        var adjacencyMatrix = Array(vertices.length)
+        const adjacencyMatrix = Array(vertices.length)
             .fill(null)
-            .map(function () {
+            .map(() => {
             return Array(vertices.length).fill(Infinity);
         });
         // Fill the columns.
-        vertices.forEach(function (vertex, vertexIndex) {
-            vertex.getNeighbors().forEach(function (neighbor) {
-                var neighborIndex = verticesIndices[neighbor.getKey()];
-                adjacencyMatrix[vertexIndex][neighborIndex] = _this.findEdge(vertex, neighbor).weight;
+        vertices.forEach((vertex, vertexIndex) => {
+            vertex.getNeighbors().forEach((neighbor) => {
+                const neighborIndex = verticesIndices[neighbor.getKey()];
+                adjacencyMatrix[vertexIndex][neighborIndex] = this.findEdge(vertex, neighbor).weight;
             });
         });
         return adjacencyMatrix;
-    };
-    Graph.prototype.toString = function () {
+    }
+    toString() {
         return Object.keys(this.vertices).toString();
-    };
-    return Graph;
-}());
+    }
+}
 exports.default = Graph;
-//# sourceMappingURL=Graph.js.map

package/built/algorithms/dataStructures/graph/GraphEdge.js

@@ -1,27 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var GraphEdge = /** @class */ (function () {
-    function GraphEdge(startVertex, endVertex, weight) {
-        if (weight === void 0) { weight = 0; }
+class GraphEdge {
+    constructor(startVertex, endVertex, weight = 0) {
         this.startVertex = startVertex;
         this.endVertex = endVertex;
         this.weight = weight;
     }
-    GraphEdge.prototype.getKey = function () {
-        var startVertexKey = this.startVertex.getKey();
-        var endVertexKey = this.endVertex.getKey();
-        return "".concat(startVertexKey, " - ").concat(endVertexKey);
-    };
-    GraphEdge.prototype.reverse = function () {
-        var tmp = this.startVertex;
+    getKey() {
+        const startVertexKey = this.startVertex.getKey();
+        const endVertexKey = this.endVertex.getKey();
+        return `${startVertexKey} - ${endVertexKey}`;
+    }
+    reverse() {
+        const tmp = this.startVertex;
         this.startVertex = this.endVertex;
         this.endVertex = tmp;
         return this;
-    };
-    GraphEdge.prototype.toString = function () {
+    }
+    toString() {
         return this.getKey();
-    };
-    return GraphEdge;
-}());
+    }
+}
 exports.default = GraphEdge;
-//# sourceMappingURL=GraphEdge.js.map

package/built/algorithms/dataStructures/graph/GraphVertex.js

@@ -3,16 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var LinkedList_1 = __importDefault(require("../linked-list/LinkedList"));
-var GraphVertex = /** @class */ (function () {
+const LinkedList_1 = __importDefault(require("../linked-list/LinkedList"));
+class GraphVertex {
     /**
      * @param {*} value
      */
-    function GraphVertex(value) {
+    constructor(value) {
         if (value === '') {
             throw new Error('Graph vertex must have a non-empty value');
         }
-        var edgeComparator = function (edgeA, edgeB) {
+        const edgeComparator = (edgeA, edgeB) => {
             if (edgeA.getKey() === edgeB.getKey()) {
                 return 0;
             }
@@ -23,57 +23,52 @@ var GraphVertex = /** @class */ (function () {
         this.value = value;
         this.edges = new LinkedList_1.default(edgeComparator);
     }
-    GraphVertex.prototype.addEdge = function (edge) {
+    addEdge(edge) {
         this.edges.append(edge);
         return this;
-    };
-    GraphVertex.prototype.deleteEdge = function (edge) {
+    }
+    deleteEdge(edge) {
         this.edges.delete(edge);
-    };
-    GraphVertex.prototype.getNeighbors = function () {
-        var _this = this;
-        var edges = this.edges.toArray();
-        var neighborsConverter = function (node) {
-            return node.value.startVertex === _this ? node.value.endVertex : node.value.startVertex;
+    }
+    getNeighbors() {
+        const edges = this.edges.toArray();
+        const neighborsConverter = (node) => {
+            return node.value.startVertex === this ? node.value.endVertex : node.value.startVertex;
         };
         // Return either start or end vertex.
         // For undirected graphs it is possible that current vertex will be the end one.
         return edges.map(neighborsConverter);
-    };
-    GraphVertex.prototype.getEdges = function () {
-        return this.edges.toArray().map(function (linkedListNode) { return linkedListNode.value; });
-    };
-    GraphVertex.prototype.getDegree = function () {
+    }
+    getEdges() {
+        return this.edges.toArray().map((linkedListNode) => linkedListNode.value);
+    }
+    getDegree() {
         return this.edges.toArray().length;
-    };
-    GraphVertex.prototype.hasEdge = function (requiredEdge) {
-        var edgeNode = this.edges.find(undefined, function (edge) { return edge === requiredEdge; });
+    }
+    hasEdge(requiredEdge) {
+        const edgeNode = this.edges.find(undefined, (edge) => edge === requiredEdge);
         return !!edgeNode;
-    };
-    GraphVertex.prototype.hasNeighbor = function (vertex) {
-        var vertexNode = this.edges.find(undefined, function (edge) { return edge.startVertex === vertex || edge.endVertex === vertex; });
+    }
+    hasNeighbor(vertex) {
+        const vertexNode = this.edges.find(undefined, (edge) => edge.startVertex === vertex || edge.endVertex === vertex);
         return !!vertexNode;
-    };
-    GraphVertex.prototype.findEdge = function (vertex) {
-        var edgeFinder = function (edge) {
+    }
+    findEdge(vertex) {
+        const edgeFinder = (edge) => {
             return edge.startVertex === vertex || edge.endVertex === vertex;
         };
-        var edge = this.edges.find(undefined, edgeFinder);
+        const edge = this.edges.find(undefined, edgeFinder);
         return edge ? edge.value : null;
-    };
-    GraphVertex.prototype.getKey = function () {
+    }
+    getKey() {
         return this.value;
-    };
-    GraphVertex.prototype.deleteAllEdges = function () {
-        var _this = this;
-        this.getEdges().forEach(function (edge) { return _this.deleteEdge(edge); });
+    }
+    deleteAllEdges() {
+        this.getEdges().forEach((edge) => this.deleteEdge(edge));
         return this;
-    };
-    GraphVertex.prototype.toString = function (callback) {
-        if (callback === void 0) { callback = undefined; }
-        return callback ? callback(this.value) : "".concat(this.value);
-    };
-    return GraphVertex;
-}());
+    }
+    toString(callback = undefined) {
+        return callback ? callback(this.value) : `${this.value}`;
+    }
+}
 exports.default = GraphVertex;
-//# sourceMappingURL=GraphVertex.js.map

package/built/algorithms/dataStructures/linked-list/LinkedList.js

@@ -3,21 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var LinkedListNode_1 = __importDefault(require("./LinkedListNode"));
-var Comparator_1 = __importDefault(require("../../utils/Comparator"));
-var LinkedList = /** @class */ (function () {
-    function LinkedList(comparatorFunction) {
+const LinkedListNode_1 = __importDefault(require("./LinkedListNode"));
+const Comparator_1 = __importDefault(require("../../utils/Comparator"));
+class LinkedList {
+    constructor(comparatorFunction) {
         this.head = null;
         this.tail = null;
         this.compare = new Comparator_1.default(comparatorFunction);
     }
-    LinkedList.prototype.prepend = function (value) {
+    prepend(value) {
         // Make new node to be a head.
         this.head = new LinkedListNode_1.default(value, this.head);
         return this;
-    };
-    LinkedList.prototype.append = function (value) {
-        var newNode = new LinkedListNode_1.default(value);
+    }
+    append(value) {
+        const newNode = new LinkedListNode_1.default(value);
         // If there is no head yet let's make new node a head.
         if (!this.head) {
             this.head = newNode;
@@ -28,18 +28,18 @@ var LinkedList = /** @class */ (function () {
         this.tail.next = newNode;
         this.tail = newNode;
         return this;
-    };
-    LinkedList.prototype.delete = function (value) {
+    }
+    delete(value) {
         if (!this.head) {
             return null;
         }
-        var deletedNode = null;
+        let deletedNode = null;
         // If the head must be deleted then make 2nd node to be a head.
         while (this.head && this.compare.equal(this.head.value, value)) {
             deletedNode = this.head;
             this.head = this.head.next;
         }
-        var currentNode = this.head;
+        let currentNode = this.head;
         if (currentNode !== null) {
             // If next node must be deleted then make next node to be a next next one.
             while (currentNode.next) {
@@ -57,14 +57,12 @@ var LinkedList = /** @class */ (function () {
             this.tail = currentNode;
         }
         return deletedNode;
-    };
-    LinkedList.prototype.find = function (value, callback) {
-        if (value === void 0) { value = undefined; }
-        if (callback === void 0) { callback = undefined; }
+    }
+    find(value = undefined, callback = undefined) {
         if (!this.head) {
             return null;
         }
-        var currentNode = this.head;
+        let currentNode = this.head;
         while (currentNode) {
             // If callback is specified then try to find node by callback.
             if (callback && callback(currentNode.value)) {
@@ -77,17 +75,17 @@ var LinkedList = /** @class */ (function () {
             currentNode = currentNode.next;
         }
         return null;
-    };
-    LinkedList.prototype.deleteTail = function () {
+    }
+    deleteTail() {
         if (this.head === this.tail) {
-            var deletedTail_1 = this.tail;
+            const deletedTail = this.tail;
             this.head = null;
             this.tail = null;
-            return deletedTail_1;
+            return deletedTail;
         }
-        var deletedTail = this.tail;
+        const deletedTail = this.tail;
         // Rewind to the last node and delete "next" link for the node before the last one.
-        var currentNode = this.head;
+        let currentNode = this.head;
         while (currentNode.next) {
             if (!currentNode.next.next) {
                 currentNode.next = null;
@@ -98,12 +96,12 @@ var LinkedList = /** @class */ (function () {
         }
         this.tail = currentNode;
         return deletedTail;
-    };
-    LinkedList.prototype.deleteHead = function () {
+    }
+    deleteHead() {
         if (!this.head) {
             return null;
         }
-        var deletedHead = this.head;
+        const deletedHead = this.head;
         if (this.head.next) {
             this.head = this.head.next;
         }
@@ -112,23 +110,20 @@ var LinkedList = /** @class */ (function () {
             this.tail = null;
         }
         return deletedHead;
-    };
-    LinkedList.prototype.toArray = function () {
-        var nodes = [];
-        var currentNode = this.head;
+    }
+    toArray() {
+        const nodes = [];
+        let currentNode = this.head;
         while (currentNode) {
             nodes.push(currentNode);
             currentNode = currentNode.next;
         }
         return nodes;
-    };
-    LinkedList.prototype.toString = function (callback) {
-        if (callback === void 0) { callback = undefined; }
+    }
+    toString(callback = undefined) {
         return this.toArray()
-            .map(function (node) { return node.toString(callback); })
+            .map((node) => node.toString(callback))
             .toString();
-    };
-    return LinkedList;
-}());
+    }
+}
 exports.default = LinkedList;
-//# sourceMappingURL=LinkedList.js.map

package/built/algorithms/dataStructures/linked-list/LinkedListNode.js

@@ -1,16 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var LinkedListNode = /** @class */ (function () {
-    function LinkedListNode(value, next) {
-        if (next === void 0) { next = null; }
+class LinkedListNode {
+    constructor(value, next = null) {
         this.value = value;
         this.next = next;
     }
-    LinkedListNode.prototype.toString = function (callback) {
-        if (callback === void 0) { callback = undefined; }
-        return callback ? callback(this.value) : "".concat(this.value);
-    };
-    return LinkedListNode;
-}());
+    toString(callback = undefined) {
+        return callback ? callback(this.value) : `${this.value}`;
+    }
+}
 exports.default = LinkedListNode;
-//# sourceMappingURL=LinkedListNode.js.map

package/built/algorithms/graph/depth-first-search/index.js

@@ -6,12 +6,12 @@ exports.depthFirstSearch = void 0;
  * @returns {Callbacks}
  */
 function initCallbacks(callbacks) {
-    var initiatedCallback = Object.assign({}, callbacks);
+    const initiatedCallback = Object.assign({}, callbacks);
     // eslint-disable-next-line @typescript-eslint/no-empty-function
-    var stubCallback = function () { };
-    var allowTraversalCallback = (function () {
-        var seen = {};
-        return function (_previousVertex, _currentVertex, nextVertex) {
+    const stubCallback = () => { };
+    const allowTraversalCallback = (() => {
+        const seen = {};
+        return (_previousVertex, _currentVertex, nextVertex) => {
             if (!seen[nextVertex.getKey()]) {
                 seen[nextVertex.getKey()] = true;
                 return true;
@@ -34,7 +34,7 @@ function depthFirstSearchRecursive(graph, currentVertex, previousVertex, callbac
     if (!callbacks.enterVertex(currentVertex, previousVertex)) {
         return;
     }
-    graph.getNeighbors(currentVertex).forEach(function (nextVertex) {
+    graph.getNeighbors(currentVertex).forEach((nextVertex) => {
         if (callbacks.allowTraversal(previousVertex, currentVertex, nextVertex)) {
             depthFirstSearchRecursive(graph, nextVertex, currentVertex, callbacks);
         }
@@ -42,8 +42,7 @@ function depthFirstSearchRecursive(graph, currentVertex, previousVertex, callbac
     callbacks.leaveVertex(currentVertex, previousVertex);
 }
 function depthFirstSearch(graph, startVertex, callbacks) {
-    var previousVertex = null;
+    const previousVertex = null;
     depthFirstSearchRecursive(graph, startVertex, previousVertex, initCallbacks(callbacks));
 }
 exports.depthFirstSearch = depthFirstSearch;
-//# sourceMappingURL=index.js.map

package/built/algorithms/graph/detect-cycle/index.js

@@ -1,40 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var depth_first_search_1 = require("../depth-first-search");
+const depth_first_search_1 = require("../depth-first-search");
 /**
  * Detect cycle in directed graph using Depth First Search.
  *
  * @returns the cycle of vertexes, not including the final vertex which is the same as the first.
  */
 function detectDirectedCycle(graph) {
-    var cycles = [];
+    const cycles = [];
     // Will store parents (previous vertices) for all visited nodes.
     // This will be needed in order to specify what path exactly is a cycle.
-    var dfsParentMap = new Map();
+    const dfsParentMap = new Map();
     // White set (UNVISITED) contains all the vertices that haven't been visited at all.
-    var whiteSet = new Map();
+    const whiteSet = new Map();
     // Gray set (VISITING) contains all the vertices that are being visited right now
     // (in current path).
-    var graySet = new Map();
+    const graySet = new Map();
     // Black set (VISITED) contains all the vertices that has been fully visited.
     // Meaning that all children of the vertex has been visited.
-    var blackSet = new Map();
+    const blackSet = new Map();
     // If we encounter vertex in gray set it means that we've found a cycle.
     // Because when vertex in gray set it means that its neighbors or its neighbors
     // neighbors are still being explored.
     // Init white set and add all vertices to it.
-    graph.getAllVertices().forEach(function (vertex) {
+    graph.getAllVertices().forEach((vertex) => {
         whiteSet.set(vertex.getKey(), vertex);
     });
     // Describe BFS callbacks.
-    var callbacks = {
-        enterVertex: function (currentVertex, previousVertex) {
+    const callbacks = {
+        enterVertex: (currentVertex, previousVertex) => {
             if (graySet.has(currentVertex.getKey())) {
                 // If current vertex already in grey set it means that cycle is detected.
                 // Let's detect cycle path.
-                var cycle = [];
-                var currentCycleVertex = currentVertex;
-                var previousCycleVertex = previousVertex;
+                const cycle = [];
+                let currentCycleVertex = currentVertex;
+                let previousCycleVertex = previousVertex;
                 while (previousCycleVertex.getKey() !== currentVertex.getKey()) {
                     cycle.push(currentCycleVertex);
                     currentCycleVertex = previousCycleVertex;
@@ -53,13 +53,13 @@ function detectDirectedCycle(graph) {
                 return true;
             }
         },
-        leaveVertex: function (currentVertex) {
+        leaveVertex: (currentVertex) => {
             // If all node's children has been visited let's remove it from gray set
             // and move it to the black set meaning that all its neighbors are visited.
             blackSet.set(currentVertex.getKey(), currentVertex);
             graySet.delete(currentVertex.getKey());
         },
-        allowTraversal: function (_previousVertex, _currentVertex, nextVertex) {
+        allowTraversal: (_previousVertex, _currentVertex, nextVertex) => {
             // Allow traversal only for the vertices that are not in black set
             // since all black set vertices have been already visited.
             return !blackSet.has(nextVertex.getKey());
@@ -67,11 +67,10 @@ function detectDirectedCycle(graph) {
     };
     // Start exploring vertices.
     while (whiteSet.size > 0) {
-        var startVertex = whiteSet.values().next().value;
+        const startVertex = whiteSet.values().next().value;
         // Do Depth First Search.
         (0, depth_first_search_1.depthFirstSearch)(graph, startVertex, callbacks);
     }
     return cycles;
 }
 exports.default = detectDirectedCycle;
-//# sourceMappingURL=index.js.map