diff --git a/src/diagrams/example/example.spec.js b/src/diagrams/example/example.spec.js
index a0c4ebfab..eb1661ad8 100644
--- a/src/diagrams/example/example.spec.js
+++ b/src/diagrams/example/example.spec.js
@@ -8,13 +8,11 @@ describe('when parsing an info graph it', function () {
   })
 
   it('should handle an info definition', function () {
-    var str = 'info\nsay: hello'
-
+    const str = 'info\nsay: hello'
     parser.parse(str)
   })
   it('should handle an showMessage statement definition', function () {
-    var str = 'info\nshowInfo'
-
+    const str = 'info\nshowInfo'
     parser.parse(str)
   })
 })
diff --git a/src/diagrams/example/exampleDb.js b/src/diagrams/example/exampleDb.js
index 0bc9b7649..4e16892fd 100644
--- a/src/diagrams/example/exampleDb.js
+++ b/src/diagrams/example/exampleDb.js
@@ -1,7 +1,7 @@
 import { logger } from '../../logger'
 
-var message = ''
-var info = false
+let message = ''
+let info = false
 
 export const setMessage = function (txt) {
   logger.debug('Setting message to: ' + txt)
diff --git a/src/diagrams/example/exampleRenderer.js b/src/diagrams/example/exampleRenderer.js
index 8c3f024a2..9c069f8aa 100644
--- a/src/diagrams/example/exampleRenderer.js
+++ b/src/diagrams/example/exampleRenderer.js
@@ -10,17 +10,16 @@ import { logger } from '../../logger'
  * @param id
  */
 export const draw = function (txt, id, ver) {
-  var parser
-  parser = exampleParser.parser
+  const parser = exampleParser.parser
   parser.yy = db
   logger.debug('Renering example diagram')
   // Parse the graph definition
   parser.parse(txt)
 
   // Fetch the default direction, use TD if none was found
-  var svg = d3.select('#' + id)
+  const svg = d3.select('#' + id)
 
-  var g = svg.append('g')
+  const g = svg.append('g')
 
   g.append('text')      // text label for the x axis
     .attr('x', 100)
diff --git a/src/diagrams/flowchart/parser/flow.spec.js b/src/diagrams/flowchart/parser/flow.spec.js
index f125d27a8..66081bc36 100644
--- a/src/diagrams/flowchart/parser/flow.spec.js
+++ b/src/diagrams/flowchart/parser/flow.spec.js
@@ -8,10 +8,10 @@ describe('when parsing ', function () {
   })
 
   it('should handle a nodes and edges', function () {
-    var res = flow.parser.parse('graph TD;\nA-->B;')
+    const res = flow.parser.parse('graph TD;\nA-->B;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -23,11 +23,11 @@ describe('when parsing ', function () {
   })
 
   it('should handle angle bracket ' > ' as direction LR', function () {
-    var res = flow.parser.parse('graph >;A-->B;')
+    const res = flow.parser.parse('graph >;A-->B;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
-    var direction = flow.parser.yy.getDirection()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
+    const direction = flow.parser.yy.getDirection()
 
     expect(direction).toBe('LR')
 
@@ -41,11 +41,11 @@ describe('when parsing ', function () {
   })
 
   it('should handle angle bracket ' < ' as direction RL', function () {
-    var res = flow.parser.parse('graph <;A-->B;')
+    const res = flow.parser.parse('graph <;A-->B;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
-    var direction = flow.parser.yy.getDirection()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
+    const direction = flow.parser.yy.getDirection()
 
     expect(direction).toBe('RL')
 
@@ -59,11 +59,11 @@ describe('when parsing ', function () {
   })
 
   it('should handle caret ' ^ ' as direction BT', function () {
-    var res = flow.parser.parse('graph ^;A-->B;')
+    const res = flow.parser.parse('graph ^;A-->B;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
-    var direction = flow.parser.yy.getDirection()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
+    const direction = flow.parser.yy.getDirection()
 
     expect(direction).toBe('BT')
 
@@ -77,11 +77,11 @@ describe('when parsing ', function () {
   })
 
   it('should handle lower-case \'v\' as direction TB', function () {
-    var res = flow.parser.parse('graph v;A-->B;')
+    const res = flow.parser.parse('graph v;A-->B;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
-    var direction = flow.parser.yy.getDirection()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
+    const direction = flow.parser.yy.getDirection()
 
     expect(direction).toBe('TB')
 
@@ -95,10 +95,10 @@ describe('when parsing ', function () {
   })
 
   it('should handle a nodes and edges and a space between link and node', function () {
-    var res = flow.parser.parse('graph TD;A --> B;')
+    const res = flow.parser.parse('graph TD;A --> B;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -110,10 +110,10 @@ describe('when parsing ', function () {
   })
 
   it('should handle a nodes and edges, a space between link and node and each line ending without semicolon', function () {
-    var res = flow.parser.parse('graph TD\nA --> B\n style e red')
+    const res = flow.parser.parse('graph TD\nA --> B\n style e red')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -124,10 +124,10 @@ describe('when parsing ', function () {
     expect(edges[0].text).toBe('')
   })
   it('should handle statements ending without semicolon', function () {
-    var res = flow.parser.parse('graph TD\nA-->B\nB-->C')
+    const res = flow.parser.parse('graph TD\nA-->B\nB-->C')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -139,10 +139,10 @@ describe('when parsing ', function () {
   })
 
   it('should handle a comments', function () {
-    var res = flow.parser.parse('graph TD;\n%% CComment\n A-->B;')
+    const res = flow.parser.parse('graph TD;\n%% CComment\n A-->B;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -153,10 +153,10 @@ describe('when parsing ', function () {
     expect(edges[0].text).toBe('')
   })
   it('should handle comments a at the start', function () {
-    var res = flow.parser.parse('%% Comment\ngraph TD;\n A-->B;')
+    const res = flow.parser.parse('%% Comment\ngraph TD;\n A-->B;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -167,10 +167,10 @@ describe('when parsing ', function () {
     expect(edges[0].text).toBe('')
   })
   it('should handle comments at the end', function () {
-    var res = flow.parser.parse('graph TD;\n A-->B\n %% Comment at the find\n')
+    const res = flow.parser.parse('graph TD;\n A-->B\n %% Comment at the find\n')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -181,10 +181,10 @@ describe('when parsing ', function () {
     expect(edges[0].text).toBe('')
   })
   it('should handle comments at the end no trailing newline', function () {
-    var res = flow.parser.parse('graph TD;\n A-->B\n%% Commento')
+    const res = flow.parser.parse('graph TD;\n A-->B\n%% Commento')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -195,10 +195,10 @@ describe('when parsing ', function () {
     expect(edges[0].text).toBe('')
   })
   it('should handle comments at the end many trailing newlines', function () {
-    var res = flow.parser.parse('graph TD;\n A-->B\n%% Commento\n\n\n')
+    const res = flow.parser.parse('graph TD;\n A-->B\n%% Commento\n\n\n')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -209,10 +209,10 @@ describe('when parsing ', function () {
     expect(edges[0].text).toBe('')
   })
   it('should handle no trailing newlines', function () {
-    var res = flow.parser.parse('graph TD;\n A-->B')
+    const res = flow.parser.parse('graph TD;\n A-->B')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -223,10 +223,10 @@ describe('when parsing ', function () {
     expect(edges[0].text).toBe('')
   })
   it('should handle many trailing newlines', function () {
-    var res = flow.parser.parse('graph TD;\n A-->B\n\n')
+    const res = flow.parser.parse('graph TD;\n A-->B\n\n')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -237,10 +237,10 @@ describe('when parsing ', function () {
     expect(edges[0].text).toBe('')
   })
   it('should handle a comments with blank rows in-between', function () {
-    var res = flow.parser.parse('graph TD;\n\n\n %% Comment\n A-->B;')
+    const res = flow.parser.parse('graph TD;\n\n\n %% Comment\n A-->B;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -252,10 +252,10 @@ describe('when parsing ', function () {
   })
 
   it('should handle a comments mermaid flowchart code in them', function () {
-    var res = flow.parser.parse('graph TD;\n\n\n %% Test od>Odd shape]-->|Two line<br>edge comment|ro;\n A-->B;')
+    const res = flow.parser.parse('graph TD;\n\n\n %% Test od>Odd shape]-->|Two line<br>edge comment|ro;\n A-->B;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -267,10 +267,10 @@ describe('when parsing ', function () {
   })
 
   it('it should handle a trailing whitespaces after statememnts', function () {
-    var res = flow.parser.parse('graph TD;\n\n\n %% Comment\n A-->B; \n B-->C;')
+    const res = flow.parser.parse('graph TD;\n\n\n %% Comment\n A-->B; \n B-->C;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -282,10 +282,10 @@ describe('when parsing ', function () {
   })
 
   it('should handle node names with "end" substring', function () {
-    var res = flow.parser.parse('graph TD\nendpoint --> sender')
+    const res = flow.parser.parse('graph TD\nendpoint --> sender')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['endpoint'].id).toBe('endpoint')
     expect(vert['sender'].id).toBe('sender')
@@ -294,10 +294,10 @@ describe('when parsing ', function () {
   })
 
   it('should handle node names ending with keywords', function () {
-    var res = flow.parser.parse('graph TD\nblend --> monograph')
+    const res = flow.parser.parse('graph TD\nblend --> monograph')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['blend'].id).toBe('blend')
     expect(vert['monograph'].id).toBe('monograph')
@@ -306,98 +306,98 @@ describe('when parsing ', function () {
   })
 
   it('should handle open ended edges', function () {
-    var res = flow.parser.parse('graph TD;A---B;')
+    const res = flow.parser.parse('graph TD;A---B;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].type).toBe('arrow_open')
   })
 
   it('should handle cross ended edges', function () {
-    var res = flow.parser.parse('graph TD;A--xB;')
+    const res = flow.parser.parse('graph TD;A--xB;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].type).toBe('arrow_cross')
   })
 
   it('should handle open ended edges', function () {
-    var res = flow.parser.parse('graph TD;A--oB;')
+    const res = flow.parser.parse('graph TD;A--oB;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].type).toBe('arrow_circle')
   })
   it('should handle subgraphs', function () {
-    var res = flow.parser.parse('graph TD;A-->B;subgraph myTitle;c-->d;end;')
+    const res = flow.parser.parse('graph TD;A-->B;subgraph myTitle;c-->d;end;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].type).toBe('arrow')
   })
 
   it('should handle subgraphs', function () {
-    var res = flow.parser.parse('graph TD\nA-->B\nsubgraph myTitle\n\n c-->d \nend\n')
+    const res = flow.parser.parse('graph TD\nA-->B\nsubgraph myTitle\n\n c-->d \nend\n')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].type).toBe('arrow')
   })
 
   it('should handle nested subgraphs', function () {
-    var str = 'graph TD\n' +
+    const str = 'graph TD\n' +
             'A-->B\n' +
             'subgraph myTitle\n\n' +
             ' c-->d \n\n' +
             ' subgraph inner\n\n   e-->f \n end \n\n' +
             ' subgraph inner\n\n   h-->i \n end \n\n' +
             'end\n'
-    var res = flow.parser.parse(str)
+    const res = flow.parser.parse(str)
   })
 
   it('should handle subgraphs', function () {
-    var res = flow.parser.parse('graph TD\nA-->B\nsubgraph myTitle\nc-->d\nend;')
+    const res = flow.parser.parse('graph TD\nA-->B\nsubgraph myTitle\nc-->d\nend;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].type).toBe('arrow')
   })
 
   it('should handle subgraphs', function () {
-    var res = flow.parser.parse('graph TD\nA-->B\nsubgraph myTitle\nc-- text -->d\nd-->e\n end;')
+    const res = flow.parser.parse('graph TD\nA-->B\nsubgraph myTitle\nc-- text -->d\nd-->e\n end;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].type).toBe('arrow')
   })
 
   it('should handle classDefs with style in classes', function () {
-    var res = flow.parser.parse('graph TD\nA-->B\nclassDef exClass font-style:bold;')
+    const res = flow.parser.parse('graph TD\nA-->B\nclassDef exClass font-style:bold;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].type).toBe('arrow')
   })
 
   it('should handle classDefs with % in classes', function () {
-    var res = flow.parser.parse('graph TD\nA-->B\nclassDef exClass fill:#f96,stroke:#333,stroke-width:4px,font-size:50%,font-style:bold;')
+    const res = flow.parser.parse('graph TD\nA-->B\nclassDef exClass fill:#f96,stroke:#333,stroke-width:4px,font-size:50%,font-style:bold;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].type).toBe('arrow')
   })
 
   it('should handle style definitons with more then 1 digit in a row', function () {
-    var res = flow.parser.parse('graph TD\n' +
+    const res = flow.parser.parse('graph TD\n' +
         'A-->B1\n' +
         'A-->B2\n' +
         'A-->B3\n' +
@@ -411,57 +411,57 @@ describe('when parsing ', function () {
         'A-->B11\n' +
         'linkStyle 10 stroke-width:1px;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].type).toBe('arrow')
   })
 
   it('should handle line interpolation default definitions', function () {
-    var res = flow.parser.parse('graph TD\n' +
+    const res = flow.parser.parse('graph TD\n' +
         'A-->B\n' +
         'linkStyle default interpolate basis')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.defaultInterpolate).toBe('basis')
   })
 
   it('should handle line interpolation numbered definitions', function () {
-    var res = flow.parser.parse('graph TD\n' +
+    const res = flow.parser.parse('graph TD\n' +
         'A-->B\n' +
         'A-->C\n' +
         'linkStyle 0 interpolate basis\n' +
         'linkStyle 1 interpolate cardinal')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].interpolate).toBe('basis')
     expect(edges[1].interpolate).toBe('cardinal')
   })
 
   it('should handle line interpolation default with style', function () {
-    var res = flow.parser.parse('graph TD\n' +
+    const res = flow.parser.parse('graph TD\n' +
         'A-->B\n' +
         'linkStyle default interpolate basis stroke-width:1px;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.defaultInterpolate).toBe('basis')
   })
 
   it('should handle line interpolation numbered with style', function () {
-    var res = flow.parser.parse('graph TD\n' +
+    const res = flow.parser.parse('graph TD\n' +
         'A-->B\n' +
         'A-->C\n' +
         'linkStyle 0 interpolate basis stroke-width:1px;\n' +
         'linkStyle 1 interpolate cardinal stroke-width:1px;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].interpolate).toBe('basis')
     expect(edges[1].interpolate).toBe('cardinal')
@@ -470,39 +470,39 @@ describe('when parsing ', function () {
   describe('it should handle interaction, ', function () {
     it('it should be possible to use click to a callback', function () {
       spyOn(graphDb, 'setClickEvent')
-      var res = flow.parser.parse('graph TD\nA-->B\nclick A callback')
+      const res = flow.parser.parse('graph TD\nA-->B\nclick A callback')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(graphDb.setClickEvent).toHaveBeenCalledWith('A', 'callback', undefined, undefined)
     })
 
     it('it should be possible to use click to a callback with toolip', function () {
       spyOn(graphDb, 'setClickEvent')
-      var res = flow.parser.parse('graph TD\nA-->B\nclick A callback "tooltip"')
+      const res = flow.parser.parse('graph TD\nA-->B\nclick A callback "tooltip"')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(graphDb.setClickEvent).toHaveBeenCalledWith('A', 'callback', undefined, 'tooltip')
     })
 
     it('should handle interaction - click to a link', function () {
       spyOn(graphDb, 'setClickEvent')
-      var res = flow.parser.parse('graph TD\nA-->B\nclick A "click.html"')
+      const res = flow.parser.parse('graph TD\nA-->B\nclick A "click.html"')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(graphDb.setClickEvent).toHaveBeenCalledWith('A', undefined, 'click.html', undefined)
     })
     it('should handle interaction - click to a link with tooltip', function () {
       spyOn(graphDb, 'setClickEvent')
-      var res = flow.parser.parse('graph TD\nA-->B\nclick A "click.html" "tooltip"')
+      const res = flow.parser.parse('graph TD\nA-->B\nclick A "click.html" "tooltip"')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(graphDb.setClickEvent).toHaveBeenCalledWith('A', undefined, 'click.html', 'tooltip')
     })
@@ -510,211 +510,211 @@ describe('when parsing ', function () {
 
   describe('it should handle text on edges', function () {
     it('it should handle text without space', function () {
-      var res = flow.parser.parse('graph TD;A--x|textNoSpace|B;')
+      const res = flow.parser.parse('graph TD;A--x|textNoSpace|B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
     })
 
     it('should handle  with space', function () {
-      var res = flow.parser.parse('graph TD;A--x|text including space|B;')
+      const res = flow.parser.parse('graph TD;A--x|text including space|B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
     })
 
     it('it should handle text with /', function () {
-      var res = flow.parser.parse('graph TD;A--x|text with / should work|B;')
+      const res = flow.parser.parse('graph TD;A--x|text with / should work|B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].text).toBe('text with / should work')
     })
 
     it('it should handle space and space between vertices and link', function () {
-      var res = flow.parser.parse('graph TD;A --x|textNoSpace| B;')
+      const res = flow.parser.parse('graph TD;A --x|textNoSpace| B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
     })
 
     it('should handle space and CAPS', function () {
-      var res = flow.parser.parse('graph TD;A--x|text including CAPS space|B;')
+      const res = flow.parser.parse('graph TD;A--x|text including CAPS space|B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
     })
 
     it('should handle space and dir', function () {
-      var res = flow.parser.parse('graph TD;A--x|text including URL space|B;')
+      const res = flow.parser.parse('graph TD;A--x|text including URL space|B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
       expect(edges[0].text).toBe('text including URL space')
     })
 
     it('should handle space and send', function () {
-      var res = flow.parser.parse('graph TD;A--text including URL space and send-->B;')
+      const res = flow.parser.parse('graph TD;A--text including URL space and send-->B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow')
       expect(edges[0].text).toBe('text including URL space and send')
     })
     it('should handle space and send', function () {
-      var res = flow.parser.parse('graph TD;A-- text including URL space and send -->B;')
+      const res = flow.parser.parse('graph TD;A-- text including URL space and send -->B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow')
       expect(edges[0].text).toBe('text including URL space and send')
     })
 
     it('should handle space and dir (TD)', function () {
-      var res = flow.parser.parse('graph TD;A--x|text including R TD space|B;')
+      const res = flow.parser.parse('graph TD;A--x|text including R TD space|B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
       expect(edges[0].text).toBe('text including R TD space')
     })
     it('should handle `', function () {
-      var res = flow.parser.parse('graph TD;A--x|text including `|B;')
+      const res = flow.parser.parse('graph TD;A--x|text including `|B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
       expect(edges[0].text).toBe('text including `')
     })
     it('should handle v in node ids only v', function () {
             // only v
-      var res = flow.parser.parse('graph TD;A--xv(my text);')
+      const res = flow.parser.parse('graph TD;A--xv(my text);')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
       expect(vert['v'].text).toBe('my text')
     })
     it('should handle v in node ids v at end', function () {
             // v at end
-      var res = flow.parser.parse('graph TD;A--xcsv(my text);')
+      const res = flow.parser.parse('graph TD;A--xcsv(my text);')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
       expect(vert['csv'].text).toBe('my text')
     })
     it('should handle v in node ids v in middle', function () {
             // v in middle
-      var res = flow.parser.parse('graph TD;A--xava(my text);')
+      const res = flow.parser.parse('graph TD;A--xava(my text);')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
       expect(vert['ava'].text).toBe('my text')
     })
     it('should handle v in node ids, v at start', function () {
             // v at start
-      var res = flow.parser.parse('graph TD;A--xva(my text);')
+      const res = flow.parser.parse('graph TD;A--xva(my text);')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
       expect(vert['va'].text).toBe('my text')
     })
     it('should handle keywords', function () {
-      var res = flow.parser.parse('graph TD;A--x|text including graph space|B;')
+      const res = flow.parser.parse('graph TD;A--x|text including graph space|B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].text).toBe('text including graph space')
     })
     it('should handle keywords', function () {
-      var res = flow.parser.parse('graph TD;V-->a[v]')
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const res = flow.parser.parse('graph TD;V-->a[v]')
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
       expect(vert['a'].text).toBe('v')
     })
     it('should handle keywords', function () {
-      var res = flow.parser.parse('graph TD;V-->a[v]')
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const res = flow.parser.parse('graph TD;V-->a[v]')
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
       expect(vert['a'].text).toBe('v')
     })
     it('should handle quoted text', function () {
-      var res = flow.parser.parse('graph TD;V-- "test string()" -->a[v]')
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const res = flow.parser.parse('graph TD;V-- "test string()" -->a[v]')
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
       expect(edges[0].text).toBe('test string()')
     })
   })
 
   describe('it should handle new line type notation', function () {
     it('it should handle regular lines', function () {
-      var res = flow.parser.parse('graph TD;A-->B;')
+      const res = flow.parser.parse('graph TD;A-->B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].stroke).toBe('normal')
     })
     it('it should handle dotted lines', function () {
-      var res = flow.parser.parse('graph TD;A-.->B;')
+      const res = flow.parser.parse('graph TD;A-.->B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].stroke).toBe('dotted')
     })
     it('it should handle dotted lines', function () {
-      var res = flow.parser.parse('graph TD;A==>B;')
+      const res = flow.parser.parse('graph TD;A==>B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].stroke).toBe('thick')
     })
     it('it should handle text on lines', function () {
-      var res = flow.parser.parse('graph TD;A-- test text with == -->B;')
+      const res = flow.parser.parse('graph TD;A-- test text with == -->B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].stroke).toBe('normal')
     })
     it('it should handle text on lines', function () {
-      var res = flow.parser.parse('graph TD;A-. test text with == .->B;')
+      const res = flow.parser.parse('graph TD;A-. test text with == .->B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].stroke).toBe('dotted')
     })
     it('it should handle text on lines', function () {
-      var res = flow.parser.parse('graph TD;A== test text with - ==>B;')
+      const res = flow.parser.parse('graph TD;A== test text with - ==>B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].stroke).toBe('thick')
     })
@@ -722,99 +722,99 @@ describe('when parsing ', function () {
 
   describe('it should handle text on edges using the new notation', function () {
     it('it should handle text without space', function () {
-      var res = flow.parser.parse('graph TD;A-- textNoSpace --xB;')
+      const res = flow.parser.parse('graph TD;A-- textNoSpace --xB;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
     })
 
     it('it should handle text with multiple leading space', function () {
-      var res = flow.parser.parse('graph TD;A--    textNoSpace --xB;')
+      const res = flow.parser.parse('graph TD;A--    textNoSpace --xB;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
     })
 
     it('should handle  with space', function () {
-      var res = flow.parser.parse('graph TD;A-- text including space --xB;')
+      const res = flow.parser.parse('graph TD;A-- text including space --xB;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
     })
 
     it('it should handle text with /', function () {
-      var res = flow.parser.parse('graph TD;A -- text with / should work --x B;')
+      const res = flow.parser.parse('graph TD;A -- text with / should work --x B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].text).toBe('text with / should work')
     })
 
     it('it should handle space and space between vertices and link', function () {
-      var res = flow.parser.parse('graph TD;A -- textNoSpace --x B;')
+      const res = flow.parser.parse('graph TD;A -- textNoSpace --x B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
     })
 
     it('should handle space and CAPS', function () {
-      var res = flow.parser.parse('graph TD;A-- text including CAPS space --xB;')
+      const res = flow.parser.parse('graph TD;A-- text including CAPS space --xB;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
     })
 
     it('should handle space and dir', function () {
-      var res = flow.parser.parse('graph TD;A-- text including URL space --xB;')
+      const res = flow.parser.parse('graph TD;A-- text including URL space --xB;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
       expect(edges[0].text).toBe('text including URL space')
     })
 
     it('should handle space and dir (TD)', function () {
-      var res = flow.parser.parse('graph TD;A-- text including R TD space --xB;')
+      const res = flow.parser.parse('graph TD;A-- text including R TD space --xB;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].type).toBe('arrow_cross')
       expect(edges[0].text).toBe('text including R TD space')
     })
     it('should handle keywords', function () {
-      var res = flow.parser.parse('graph TD;A-- text including graph space and v --xB;')
+      const res = flow.parser.parse('graph TD;A-- text including graph space and v --xB;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].text).toBe('text including graph space and v')
     })
     it('should handle keywords', function () {
-      var res = flow.parser.parse('graph TD;A-- text including graph space and v --xB[blav]')
+      const res = flow.parser.parse('graph TD;A-- text including graph space and v --xB[blav]')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(edges[0].text).toBe('text including graph space and v')
     })
         // xit('should handle text on open links',function(){
-        //    var res = flow.parser.parse('graph TD;A-- text including graph space --B');
+        //    const res = flow.parser.parse('graph TD;A-- text including graph space --B');
         //
-        //    var vert = flow.parser.yy.getVertices();
-        //    var edges = flow.parser.yy.getEdges();
+        //    const vert = flow.parser.yy.getVertices();
+        //    const edges = flow.parser.yy.getEdges();
         //
         //    expect(edges[0].text).toBe('text including graph space');
         //
@@ -822,10 +822,10 @@ describe('when parsing ', function () {
   })
 
   it('should handle multi-line text', function () {
-    var res = flow.parser.parse('graph TD;A--o|text space|B;\n B-->|more text with space|C;')
+    const res = flow.parser.parse('graph TD;A--o|text space|B;\n B-->|more text with space|C;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges[0].type).toBe('arrow_circle')
     expect(edges[1].type).toBe('arrow')
@@ -842,9 +842,9 @@ describe('when parsing ', function () {
   })
 
   it('should handle multiple edges', function () {
-    var res = flow.parser.parse('graph TD;A---|This is the 123 s text|B;\nA---|This is the second edge|B;')
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const res = flow.parser.parse('graph TD;A---|This is the 123 s text|B;\nA---|This is the second edge|B;')
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].id).toBe('A')
     expect(vert['B'].id).toBe('B')
@@ -858,89 +858,89 @@ describe('when parsing ', function () {
   })
 
   it('should handle text in vertices with space', function () {
-    var res = flow.parser.parse('graph TD;A[chimpansen hoppar]-->C;')
+    const res = flow.parser.parse('graph TD;A[chimpansen hoppar]-->C;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].type).toBe('square')
     expect(vert['A'].text).toBe('chimpansen hoppar')
   })
 
   it('should handle text in vertices with space with spaces between vertices and link', function () {
-    var res = flow.parser.parse('graph TD;A[chimpansen hoppar] --> C;')
+    const res = flow.parser.parse('graph TD;A[chimpansen hoppar] --> C;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].type).toBe('square')
     expect(vert['A'].text).toBe('chimpansen hoppar')
   })
 
   it('should handle quoted text in vertices ', function () {
-    var res = flow.parser.parse('graph TD;A["chimpansen hoppar ()[]"] --> C;')
+    const res = flow.parser.parse('graph TD;A["chimpansen hoppar ()[]"] --> C;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].type).toBe('square')
     expect(vert['A'].text).toBe('chimpansen hoppar ()[]')
   })
 
   it('should handle text in circle vertices with space', function () {
-    var res = flow.parser.parse('graph TD;A((chimpansen hoppar))-->C;')
+    const res = flow.parser.parse('graph TD;A((chimpansen hoppar))-->C;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].type).toBe('circle')
     expect(vert['A'].text).toBe('chimpansen hoppar')
   })
 
   it('should handle text in ellipse vertices', function () {
-    var res = flow.parser.parse('graph TD\nA(-this is an ellipse-)-->B')
+    const res = flow.parser.parse('graph TD\nA(-this is an ellipse-)-->B')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].type).toBe('ellipse')
     expect(vert['A'].text).toBe('this is an ellipse')
   })
 
   it('should handle text in diamond vertices with space', function () {
-    var res = flow.parser.parse('graph TD;A(chimpansen hoppar)-->C;')
+    const res = flow.parser.parse('graph TD;A(chimpansen hoppar)-->C;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].type).toBe('round')
     expect(vert['A'].text).toBe('chimpansen hoppar')
   })
 
   it('should handle text in with ?', function () {
-    var res = flow.parser.parse('graph TD;A(?)-->|?|C;')
+    const res = flow.parser.parse('graph TD;A(?)-->|?|C;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].text).toBe('?')
     expect(edges[0].text).toBe('?')
   })
   it('should handle text in with éèêàçô', function () {
-    var res = flow.parser.parse('graph TD;A(éèêàçô)-->|éèêàçô|C;')
+    const res = flow.parser.parse('graph TD;A(éèêàçô)-->|éèêàçô|C;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].text).toBe('éèêàçô')
     expect(edges[0].text).toBe('éèêàçô')
   })
 
   it('should handle text in with ,.?!+-*', function () {
-    var res = flow.parser.parse('graph TD;A(,.?!+-*)-->|,.?!+-*|C;')
+    const res = flow.parser.parse('graph TD;A(,.?!+-*)-->|,.?!+-*|C;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['A'].text).toBe(',.?!+-*')
     expect(edges[0].text).toBe(',.?!+-*')
@@ -948,70 +948,70 @@ describe('when parsing ', function () {
 
   describe('it should handle text in vertices, ', function () {
     it('it should handle space', function () {
-      var res = flow.parser.parse('graph TD;A-->C(Chimpansen hoppar);')
+      const res = flow.parser.parse('graph TD;A-->C(Chimpansen hoppar);')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(vert['C'].type).toBe('round')
       expect(vert['C'].text).toBe('Chimpansen hoppar')
     })
     it('it should handle åäö and minus', function () {
-      var res = flow.parser.parse('graph TD;A-->C{Chimpansen hoppar åäö-ÅÄÖ};')
+      const res = flow.parser.parse('graph TD;A-->C{Chimpansen hoppar åäö-ÅÄÖ};')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(vert['C'].type).toBe('diamond')
       expect(vert['C'].text).toBe('Chimpansen hoppar åäö-ÅÄÖ')
     })
 
     it('it should handle with åäö, minus and space and br', function () {
-      var res = flow.parser.parse('graph TD;A-->C(Chimpansen hoppar åäö  <br> -  ÅÄÖ);')
+      const res = flow.parser.parse('graph TD;A-->C(Chimpansen hoppar åäö  <br> -  ÅÄÖ);')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(vert['C'].type).toBe('round')
       expect(vert['C'].text).toBe('Chimpansen hoppar åäö  <br> -  ÅÄÖ')
     })
         // xit('it should handle åäö, minus and space and br',function(){
-        //    var res = flow.parser.parse('graph TD; A[Object&#40;foo,bar&#41;]-->B(Thing);');
+        //    const res = flow.parser.parse('graph TD; A[Object&#40;foo,bar&#41;]-->B(Thing);');
         //
-        //    var vert = flow.parser.yy.getVertices();
-        //    var edges = flow.parser.yy.getEdges();
+        //    const vert = flow.parser.yy.getVertices();
+        //    const edges = flow.parser.yy.getEdges();
         //
         //    expect(vert['C'].type).toBe('round');
         //    expect(vert['C'].text).toBe(' A[Object&#40;foo,bar&#41;]-->B(Thing);');
         // });
     it('it should handle unicode chars', function () {
-      var res = flow.parser.parse('graph TD;A-->C(Начало);')
+      const res = flow.parser.parse('graph TD;A-->C(Начало);')
 
-      var vert = flow.parser.yy.getVertices()
+      const vert = flow.parser.yy.getVertices()
 
       expect(vert['C'].text).toBe('Начало')
     })
     it('it should handle backslask', function () {
-      var res = flow.parser.parse('graph TD;A-->C(c:\\windows);')
+      const res = flow.parser.parse('graph TD;A-->C(c:\\windows);')
 
-      var vert = flow.parser.yy.getVertices()
+      const vert = flow.parser.yy.getVertices()
 
       expect(vert['C'].text).toBe('c:\\windows')
     })
     it('it should handle CAPS', function () {
-      var res = flow.parser.parse('graph TD;A-->C(some CAPS);')
+      const res = flow.parser.parse('graph TD;A-->C(some CAPS);')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(vert['C'].type).toBe('round')
       expect(vert['C'].text).toBe('some CAPS')
     })
     it('it should handle directions', function () {
-      var res = flow.parser.parse('graph TD;A-->C(some URL);')
+      const res = flow.parser.parse('graph TD;A-->C(some URL);')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(vert['C'].type).toBe('round')
       expect(vert['C'].text).toBe('some URL')
@@ -1020,10 +1020,10 @@ describe('when parsing ', function () {
 
   it('should handle a single node', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;A;')
+    const res = flow.parser.parse('graph TD;A;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['A'].styles.length).toBe(0)
@@ -1031,10 +1031,10 @@ describe('when parsing ', function () {
 
   it('should handle a single square node', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;a[A];')
+    const res = flow.parser.parse('graph TD;a[A];')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['a'].styles.length).toBe(0)
@@ -1042,10 +1042,10 @@ describe('when parsing ', function () {
   })
   it('should handle a single round square node', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;a[A];')
+    const res = flow.parser.parse('graph TD;a[A];')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['a'].styles.length).toBe(0)
@@ -1053,50 +1053,50 @@ describe('when parsing ', function () {
   })
   it('should handle a single circle node', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;a((A));')
+    const res = flow.parser.parse('graph TD;a((A));')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['a'].type).toBe('circle')
   })
   it('should handle a single round node', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;a(A);')
+    const res = flow.parser.parse('graph TD;a(A);')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['a'].type).toBe('round')
   })
   it('should handle a single odd node', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;a>A];')
+    const res = flow.parser.parse('graph TD;a>A];')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['a'].type).toBe('odd')
   })
   it('should handle a single diamond node', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;a{A};')
+    const res = flow.parser.parse('graph TD;a{A};')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['a'].type).toBe('diamond')
   })
   it('should handle a single diamond node with html in it', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;a{A <br> end};')
+    const res = flow.parser.parse('graph TD;a{A <br> end};')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['a'].type).toBe('diamond')
@@ -1104,10 +1104,10 @@ describe('when parsing ', function () {
   })
   it('should handle a single round node with html in it', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;a(A <br> end);')
+    const res = flow.parser.parse('graph TD;a(A <br> end);')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['a'].type).toBe('round')
@@ -1115,42 +1115,42 @@ describe('when parsing ', function () {
   })
   it('should handle a single node with alphanumerics starting on a char', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;id1;')
+    const res = flow.parser.parse('graph TD;id1;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['id1'].styles.length).toBe(0)
   })
   it('should handle a single node with alphanumerics starting on a num', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;1id;')
+    const res = flow.parser.parse('graph TD;1id;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['1id'].styles.length).toBe(0)
   })
   it('should handle a single node with alphanumerics containing a minus sign', function () {
         // Silly but syntactically correct
-    var res = flow.parser.parse('graph TD;i-d;')
+    const res = flow.parser.parse('graph TD;i-d;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(0)
     expect(vert['i-d'].styles.length).toBe(0)
   })
     // log.debug(flow.parser.parse('graph TD;style Q background:#fff;'));
   it('should handle styles for vertices', function () {
-    var res = flow.parser.parse('graph TD;style Q background:#fff;')
+    const res = flow.parser.parse('graph TD;style Q background:#fff;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
-    var style = vert['Q'].styles[0]
+    const style = vert['Q'].styles[0]
 
     expect(vert['Q'].styles.length).toBe(1)
     expect(vert['Q'].styles[0]).toBe('background:#fff')
@@ -1158,18 +1158,18 @@ describe('when parsing ', function () {
 
     // log.debug(flow.parser.parse('graph TD;style Q background:#fff;'));
   it('should handle styles for edges', function () {
-    var res = flow.parser.parse('graph TD;a-->b;\nstyle #0 stroke: #f66;')
+    const res = flow.parser.parse('graph TD;a-->b;\nstyle #0 stroke: #f66;')
 
-    var edges = flow.parser.yy.getEdges()
+    const edges = flow.parser.yy.getEdges()
 
     expect(edges.length).toBe(1)
   })
 
   it('should handle multiple styles for a vortex', function () {
-    var res = flow.parser.parse('graph TD;style R background:#fff,border:1px solid red;')
+    const res = flow.parser.parse('graph TD;style R background:#fff,border:1px solid red;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['R'].styles.length).toBe(2)
     expect(vert['R'].styles[0]).toBe('background:#fff')
@@ -1177,10 +1177,10 @@ describe('when parsing ', function () {
   })
 
   it('should handle multiple styles in a graph', function () {
-    var res = flow.parser.parse('graph TD;style S background:#aaa;\nstyle T background:#bbb,border:1px solid red;')
+    const res = flow.parser.parse('graph TD;style S background:#aaa;\nstyle T background:#bbb,border:1px solid red;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['S'].styles.length).toBe(1)
     expect(vert['T'].styles.length).toBe(2)
@@ -1190,10 +1190,10 @@ describe('when parsing ', function () {
   })
 
   it('should handle styles and graph definitons in a graph', function () {
-    var res = flow.parser.parse('graph TD;S-->T;\nstyle S background:#aaa;\nstyle T background:#bbb,border:1px solid red;')
+    const res = flow.parser.parse('graph TD;S-->T;\nstyle S background:#aaa;\nstyle T background:#bbb,border:1px solid red;')
 
-    var vert = flow.parser.yy.getVertices()
-    var edges = flow.parser.yy.getEdges()
+    const vert = flow.parser.yy.getVertices()
+    const edges = flow.parser.yy.getEdges()
 
     expect(vert['S'].styles.length).toBe(1)
     expect(vert['T'].styles.length).toBe(2)
@@ -1202,10 +1202,10 @@ describe('when parsing ', function () {
     expect(vert['T'].styles[1]).toBe('border:1px solid red')
   })
   it('should handle styles and graph definitons in a graph', function () {
-    var res = flow.parser.parse('graph TD;style T background:#bbb,border:1px solid red;')
-        // var res = flow.parser.parse('graph TD;style T background: #bbb;');
+    const res = flow.parser.parse('graph TD;style T background:#bbb,border:1px solid red;')
+        // const res = flow.parser.parse('graph TD;style T background: #bbb;');
 
-    var vert = flow.parser.yy.getVertices()
+    const vert = flow.parser.yy.getVertices()
 
     expect(vert['T'].styles.length).toBe(2)
     expect(vert['T'].styles[0]).toBe('background:#bbb')
@@ -1213,11 +1213,11 @@ describe('when parsing ', function () {
   })
 
   describe('special characters should be be handled.', function () {
-    var charTest = function (char) {
-      var res = flow.parser.parse('graph TD;A(' + char + ')-->B;')
+    const charTest = function (char) {
+      const res = flow.parser.parse('graph TD;A(' + char + ')-->B;')
 
-      var vert = flow.parser.yy.getVertices()
-      var edges = flow.parser.yy.getEdges()
+      const vert = flow.parser.yy.getVertices()
+      const edges = flow.parser.yy.getEdges()
 
       expect(vert['A'].id).toBe('A')
       expect(vert['B'].id).toBe('B')
@@ -1267,10 +1267,10 @@ describe('when parsing ', function () {
   })
 
   it('should be possible to declare a class', function () {
-    var res = flow.parser.parse('graph TD;classDef exClass background:#bbb,border:1px solid red;')
-        // var res = flow.parser.parse('graph TD;style T background: #bbb;');
+    const res = flow.parser.parse('graph TD;classDef exClass background:#bbb,border:1px solid red;')
+        // const res = flow.parser.parse('graph TD;style T background: #bbb;');
 
-    var classes = flow.parser.yy.getClasses()
+    const classes = flow.parser.yy.getClasses()
 
     expect(classes['exClass'].styles.length).toBe(2)
     expect(classes['exClass'].styles[0]).toBe('background:#bbb')
@@ -1278,53 +1278,53 @@ describe('when parsing ', function () {
   })
 
   it('should be possible to declare a class with a dot in the style', function () {
-    var res = flow.parser.parse('graph TD;classDef exClass background:#bbb,border:1.5px solid red;')
-        // var res = flow.parser.parse('graph TD;style T background: #bbb;');
+    const res = flow.parser.parse('graph TD;classDef exClass background:#bbb,border:1.5px solid red;')
+        // const res = flow.parser.parse('graph TD;style T background: #bbb;');
 
-    var classes = flow.parser.yy.getClasses()
+    const classes = flow.parser.yy.getClasses()
 
     expect(classes['exClass'].styles.length).toBe(2)
     expect(classes['exClass'].styles[0]).toBe('background:#bbb')
     expect(classes['exClass'].styles[1]).toBe('border:1.5px solid red')
   })
   it('should be possible to declare a class with a space in the style', function () {
-    var res = flow.parser.parse('graph TD;classDef exClass background:  #bbb,border:1.5px solid red;')
-        // var res = flow.parser.parse('graph TD;style T background  :  #bbb;');
+    const res = flow.parser.parse('graph TD;classDef exClass background:  #bbb,border:1.5px solid red;')
+        // const res = flow.parser.parse('graph TD;style T background  :  #bbb;');
 
-    var classes = flow.parser.yy.getClasses()
+    const classes = flow.parser.yy.getClasses()
 
     expect(classes['exClass'].styles.length).toBe(2)
     expect(classes['exClass'].styles[0]).toBe('background:  #bbb')
     expect(classes['exClass'].styles[1]).toBe('border:1.5px solid red')
   })
   it('should be possible to apply a class to a vertex', function () {
-    var statement = ''
+    let statement = ''
 
     statement = statement + 'graph TD;' + '\n'
     statement = statement + 'classDef exClass background:#bbb,border:1px solid red;' + '\n'
     statement = statement + 'a-->b;' + '\n'
     statement = statement + 'class a exClass;'
 
-    var res = flow.parser.parse(statement)
+    const res = flow.parser.parse(statement)
 
-    var classes = flow.parser.yy.getClasses()
+    const classes = flow.parser.yy.getClasses()
 
     expect(classes['exClass'].styles.length).toBe(2)
     expect(classes['exClass'].styles[0]).toBe('background:#bbb')
     expect(classes['exClass'].styles[1]).toBe('border:1px solid red')
   })
   it('should be possible to apply a class to a comma separated list of vertices', function () {
-    var statement = ''
+    let statement = ''
 
     statement = statement + 'graph TD;' + '\n'
     statement = statement + 'classDef exClass background:#bbb,border:1px solid red;' + '\n'
     statement = statement + 'a-->b;' + '\n'
     statement = statement + 'class a,b exClass;'
 
-    var res = flow.parser.parse(statement)
+    const res = flow.parser.parse(statement)
 
-    var classes = flow.parser.yy.getClasses()
-    var vertices = flow.parser.yy.getVertices()
+    const classes = flow.parser.yy.getClasses()
+    const vertices = flow.parser.yy.getVertices()
 
     expect(classes['exClass'].styles.length).toBe(2)
     expect(classes['exClass'].styles[0]).toBe('background:#bbb')