chore(deps): update dependency vite to v7.1.11 [security]

CHANGELOG.md

@@ -1 +1 @@
-./packages/mermaid/CHANGELOG.md
+./packages/mermaid/CHANGELOG.md

CONTRIBUTING.md

@@ -1 +1 @@
-./packages/mermaid/src/docs/community/contributing.md
+./packages/mermaid/src/docs/community/contributing.md

packages/mermaid/src/diagrams/flowchart/parser/flow-arrows.spec.js

@@ -266,156 +266,4 @@ describe('[Arrows] when parsing', () => {
       });
     });
   });
-
-  describe('Issue #2492: Node names starting with o/x should not be consumed by arrow markers', () => {
-    it('should handle node names starting with "o" after plain arrows', function () {
-      const res = flow.parser.parse('graph TD;\ndev---ops;');
-
-      const vert = flow.parser.yy.getVertices();
-      const edges = flow.parser.yy.getEdges();
-
-      expect(vert.get('dev').id).toBe('dev');
-      expect(vert.get('ops').id).toBe('ops');
-      expect(edges.length).toBe(1);
-      expect(edges[0].start).toBe('dev');
-      expect(edges[0].end).toBe('ops');
-      expect(edges[0].type).toBe('arrow_open');
-      expect(edges[0].stroke).toBe('normal');
-    });
-
-    it('should handle node names starting with "x" after plain arrows', function () {
-      const res = flow.parser.parse('graph TD;\ndev---xerxes;');
-
-      const vert = flow.parser.yy.getVertices();
-      const edges = flow.parser.yy.getEdges();
-
-      expect(vert.get('dev').id).toBe('dev');
-      expect(vert.get('xerxes').id).toBe('xerxes');
-      expect(edges.length).toBe(1);
-      expect(edges[0].start).toBe('dev');
-      expect(edges[0].end).toBe('xerxes');
-      expect(edges[0].type).toBe('arrow_open');
-      expect(edges[0].stroke).toBe('normal');
-    });
-
-    it('should still support circle arrows with spaces', function () {
-      const res = flow.parser.parse('graph TD;\nA --o B;');
-
-      const vert = flow.parser.yy.getVertices();
-      const edges = flow.parser.yy.getEdges();
-
-      expect(vert.get('A').id).toBe('A');
-      expect(vert.get('B').id).toBe('B');
-      expect(edges.length).toBe(1);
-      expect(edges[0].start).toBe('A');
-      expect(edges[0].end).toBe('B');
-      expect(edges[0].type).toBe('arrow_circle');
-      expect(edges[0].stroke).toBe('normal');
-    });
-
-    it('should still support cross arrows with spaces', function () {
-      const res = flow.parser.parse('graph TD;\nC --x D;');
-
-      const vert = flow.parser.yy.getVertices();
-      const edges = flow.parser.yy.getEdges();
-
-      expect(vert.get('C').id).toBe('C');
-      expect(vert.get('D').id).toBe('D');
-      expect(edges.length).toBe(1);
-      expect(edges[0].start).toBe('C');
-      expect(edges[0].end).toBe('D');
-      expect(edges[0].type).toBe('arrow_cross');
-      expect(edges[0].stroke).toBe('normal');
-    });
-
-    it('should support circle arrows to uppercase nodes without spaces', function () {
-      const res = flow.parser.parse('graph TD;\nA--oB;');
-
-      const vert = flow.parser.yy.getVertices();
-      const edges = flow.parser.yy.getEdges();
-
-      expect(vert.get('A').id).toBe('A');
-      expect(vert.get('B').id).toBe('B');
-      expect(edges.length).toBe(1);
-      expect(edges[0].start).toBe('A');
-      expect(edges[0].end).toBe('B');
-      expect(edges[0].type).toBe('arrow_circle');
-      expect(edges[0].stroke).toBe('normal');
-    });
-
-    it('should support cross arrows to uppercase nodes without spaces', function () {
-      const res = flow.parser.parse('graph TD;\nA--xBar;');
-
-      const vert = flow.parser.yy.getVertices();
-      const edges = flow.parser.yy.getEdges();
-
-      expect(vert.get('A').id).toBe('A');
-      expect(vert.get('Bar').id).toBe('Bar');
-      expect(edges.length).toBe(1);
-      expect(edges[0].start).toBe('A');
-      expect(edges[0].end).toBe('Bar');
-      expect(edges[0].type).toBe('arrow_cross');
-      expect(edges[0].stroke).toBe('normal');
-    });
-
-    it('should handle thick arrows with lowercase node names starting with "o"', function () {
-      const res = flow.parser.parse('graph TD;\nalpha===omega;');
-
-      const vert = flow.parser.yy.getVertices();
-      const edges = flow.parser.yy.getEdges();
-
-      expect(vert.get('alpha').id).toBe('alpha');
-      expect(vert.get('omega').id).toBe('omega');
-      expect(edges.length).toBe(1);
-      expect(edges[0].start).toBe('alpha');
-      expect(edges[0].end).toBe('omega');
-      expect(edges[0].type).toBe('arrow_open');
-      expect(edges[0].stroke).toBe('thick');
-    });
-
-    it('should handle dotted arrows with lowercase node names starting with "o"', function () {
-      const res = flow.parser.parse('graph TD;\nfoo-.-opus;');
-
-      const vert = flow.parser.yy.getVertices();
-      const edges = flow.parser.yy.getEdges();
-
-      expect(vert.get('foo').id).toBe('foo');
-      expect(vert.get('opus').id).toBe('opus');
-      expect(edges.length).toBe(1);
-      expect(edges[0].start).toBe('foo');
-      expect(edges[0].end).toBe('opus');
-      expect(edges[0].type).toBe('arrow_open');
-      expect(edges[0].stroke).toBe('dotted');
-    });
-
-    it('should still support dotted circle arrows with spaces', function () {
-      const res = flow.parser.parse('graph TD;\nB -.-o C;');
-
-      const vert = flow.parser.yy.getVertices();
-      const edges = flow.parser.yy.getEdges();
-
-      expect(vert.get('B').id).toBe('B');
-      expect(vert.get('C').id).toBe('C');
-      expect(edges.length).toBe(1);
-      expect(edges[0].start).toBe('B');
-      expect(edges[0].end).toBe('C');
-      expect(edges[0].type).toBe('arrow_circle');
-      expect(edges[0].stroke).toBe('dotted');
-    });
-
-    it('should still support thick cross arrows with spaces', function () {
-      const res = flow.parser.parse('graph TD;\nC ==x D;');
-
-      const vert = flow.parser.yy.getVertices();
-      const edges = flow.parser.yy.getEdges();
-
-      expect(vert.get('C').id).toBe('C');
-      expect(vert.get('D').id).toBe('D');
-      expect(edges.length).toBe(1);
-      expect(edges[0].start).toBe('C');
-      expect(edges[0].end).toBe('D');
-      expect(edges[0].type).toBe('arrow_cross');
-      expect(edges[0].stroke).toBe('thick');
-    });
-  });
 });

packages/mermaid/src/diagrams/flowchart/parser/flow-arrows.spec.ts

@@ -1,129 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import flow from './flowParser.js';
-import { FlowDB } from '../flowDb.js';
-
-describe('Flowchart arrow parsing - Issue #2492', () => {
-  let flowDb: FlowDB;
-
-  beforeEach(() => {
-    flowDb = new FlowDB();
-    flow.parser.yy = flowDb;
-    flowDb.clear();
-  });
-
-  describe('Solid arrows with markers', () => {
-    it('should parse --> followed by uppercase node', () => {
-      const diagram = 'graph TD\nA-->B';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse --> followed by lowercase node', () => {
-      const diagram = 'graph TD\nA-->b';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse --> followed by space', () => {
-      const diagram = 'graph TD\nA--> B';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse --- followed by uppercase node (issue #2492)', () => {
-      const diagram = 'graph TD\ndev---Ops';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse --- followed by lowercase node (issue #2492)', () => {
-      const diagram = 'graph TD\ndev---ops';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse --o followed by uppercase node', () => {
-      const diagram = 'graph TD\nA--oB';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse --o followed by lowercase node', () => {
-      const diagram = 'graph TD\nA--ob';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse --x followed by uppercase node', () => {
-      const diagram = 'graph TD\nA--xBar';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse --x followed by lowercase node', () => {
-      const diagram = 'graph TD\nA--xbar';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-  });
-
-  describe('Thick arrows with markers', () => {
-    it('should parse ==> followed by uppercase node', () => {
-      const diagram = 'graph TD\nA==>B';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse ==> followed by lowercase node', () => {
-      const diagram = 'graph TD\nA==>b';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse === followed by lowercase node', () => {
-      const diagram = 'graph TD\nA===b';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-  });
-
-  describe('Dotted arrows with markers', () => {
-    it('should parse -.-> followed by uppercase node', () => {
-      const diagram = 'graph TD\nA-.->B';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse -.-> followed by lowercase node', () => {
-      const diagram = 'graph TD\nA-.->b';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse -.- followed by lowercase node', () => {
-      const diagram = 'graph TD\nA-.-b';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-  });
-
-  describe('Arrows with edge text', () => {
-    it('should parse arrow with edge text followed by uppercase node', () => {
-      const diagram = 'graph TD\nA-->|text|B';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse arrow with edge text followed by lowercase node', () => {
-      const diagram = 'graph TD\nA-->|text|b';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse multiple arrows with edge text (regression test)', () => {
-      const diagram = 'graph TD\nA-->|Get money|B\nB-->C\nC-->|One|D\nC-->|Two|E';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-  });
-
-  describe('Arrows followed by digits', () => {
-    it('should parse --> followed by digit', () => {
-      const diagram = 'graph LR\n47-->48';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse --> followed by node starting with digit', () => {
-      const diagram = 'graph LR\nA-->48(Node)';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-
-    it('should parse complex diagram with digit node IDs (Sample 4)', () => {
-      const diagram =
-        'graph LR\n47(SAM.CommonFA.FMESummary)-->48(SAM.CommonFA.CommonFAFinanceBudget)\n37(SAM.CommonFA.BudgetSubserviceLineVolume)-->48(SAM.CommonFA.CommonFAFinanceBudget)';
-      expect(() => flow.parser.parse(diagram)).not.toThrow();
-    });
-  });
-});

packages/mermaid/src/diagrams/flowchart/parser/flow.jison

@@ -152,29 +152,17 @@ that id.
 ","                          return 'COMMA';
 "*"                          return 'MULT';
 
-<INITIAL,edgeText>\s*[xo<]?\-\-+[-xo>]\s+                 { this.popState(); return 'LINK'; }
-<INITIAL>\s*[xo<]?\-\-+[-xo>](?=[A-Z])                    { return 'LINK'; }
-<INITIAL>\s*[xo<]?\-\-+[-xo>](?=[a-z])                    { return 'LINK'; }
-<INITIAL>\s*[xo<]?\-\-+[-xo>](?=[0-9])                    { return 'LINK'; }
-<INITIAL,edgeText>\s*[xo<]?\-\-+[-xo>](?=\s*\|)           { this.popState(); return 'LINK'; }
-<INITIAL>\s*[xo<]?\-\-\s*                              { this.pushState("edgeText"); return 'START_LINK'; }
-<edgeText>[^-]|\-(?!\-)+                              return 'EDGE_TEXT';
+<INITIAL,edgeText>\s*[xo<]?\-\-+[-xo>]\s*          { this.popState(); return 'LINK'; }
+<INITIAL>\s*[xo<]?\-\-\s*                          { this.pushState("edgeText"); return 'START_LINK'; }
+<edgeText>[^-]|\-(?!\-)+                           return 'EDGE_TEXT';
 
-<INITIAL,thickEdgeText>\s*[xo<]?\=\=+[=xo>]\s+            { this.popState(); return 'LINK'; }
-<INITIAL>\s*[xo<]?\=\=+[=xo>](?=[A-Z])                    { return 'LINK'; }
-<INITIAL>\s*[xo<]?\=\=+[=xo>](?=[a-z])                    { return 'LINK'; }
-<INITIAL>\s*[xo<]?\=\=+[=xo>](?=[0-9])                    { return 'LINK'; }
-<INITIAL,thickEdgeText>\s*[xo<]?\=\=+[=xo>](?=\s*\|)      { this.popState(); return 'LINK'; }
-<INITIAL>\s*[xo<]?\=\=\s*                              { this.pushState("thickEdgeText"); return 'START_LINK'; }
-<thickEdgeText>[^=]|\=(?!=)                            return 'EDGE_TEXT';
+<INITIAL,thickEdgeText>\s*[xo<]?\=\=+[=xo>]\s*      { this.popState(); return 'LINK'; }
+<INITIAL>\s*[xo<]?\=\=\s*                           { this.pushState("thickEdgeText"); return 'START_LINK'; }
+<thickEdgeText>[^=]|\=(?!=)                         return 'EDGE_TEXT';
 
-<INITIAL,dottedEdgeText>\s*[xo<]?\-?\.+\-[xo>]?\s+         { this.popState(); return 'LINK'; }
-<INITIAL>\s*[xo<]?\-?\.+\-[xo>]?(?=[A-Z])                  { return 'LINK'; }
-<INITIAL>\s*[xo<]?\-?\.+\-[xo>]?(?=[a-z])                  { return 'LINK'; }
-<INITIAL>\s*[xo<]?\-?\.+\-[xo>]?(?=[0-9])                  { return 'LINK'; }
-<INITIAL,dottedEdgeText>\s*[xo<]?\-?\.+\-[xo>]?(?=\s*\|)   { this.popState(); return 'LINK'; }
-<INITIAL>\s*[xo<]?\-\.\s*                               { this.pushState("dottedEdgeText"); return 'START_LINK'; }
-<dottedEdgeText>[^\.]|\.(?!-)                           return 'EDGE_TEXT';
+<INITIAL,dottedEdgeText>\s*[xo<]?\-?\.+\-[xo>]?\s*   { this.popState(); return 'LINK'; }
+<INITIAL>\s*[xo<]?\-\.\s*                            { this.pushState("dottedEdgeText"); return 'START_LINK'; }
+<dottedEdgeText>[^\.]|\.(?!-)                        return 'EDGE_TEXT';
 
 
 <*>\s*\~\~[\~]+\s*              return 'LINK';