From f454865b9773ce3843e42f3da929a0a907bfa1af Mon Sep 17 00:00:00 2001
From: saurabhg772244 <saurabh@mermaidchart.com>
Date: Wed, 12 Feb 2025 16:00:14 +0530
Subject: [PATCH] Updated unit tests to reflect new DB instance per parse.

---
 .../diagrams/sequence/sequenceDiagram.spec.js | 795 ++++++++----------
 1 file changed, 364 insertions(+), 431 deletions(-)

diff --git a/packages/mermaid/src/diagrams/sequence/sequenceDiagram.spec.js b/packages/mermaid/src/diagrams/sequence/sequenceDiagram.spec.js
index 474668edf..7fbf4f4e3 100644
--- a/packages/mermaid/src/diagrams/sequence/sequenceDiagram.spec.js
+++ b/packages/mermaid/src/diagrams/sequence/sequenceDiagram.spec.js
@@ -98,14 +98,15 @@ let diagram;
 describe('more than one sequence diagram', () => {
   it('should not have duplicated messages', async () => {
     const diagram1 = await Diagram.fromText(`
-         sequenceDiagram
-         Alice->Bob:Hello Bob, how are you?
+        sequenceDiagram
+        Alice->Bob:Hello Bob, how are you?
         Bob-->Alice: I am good thanks!`);
     expect(diagram1.db.getMessages()).toMatchInlineSnapshot(`
       [
         {
           "activate": false,
           "from": "Alice",
+          "id": "0",
           "message": "Hello Bob, how are you?",
           "to": "Bob",
           "type": 5,
@@ -114,6 +115,7 @@ describe('more than one sequence diagram', () => {
         {
           "activate": false,
           "from": "Bob",
+          "id": "1",
           "message": "I am good thanks!",
           "to": "Alice",
           "type": 6,
@@ -131,6 +133,7 @@ describe('more than one sequence diagram', () => {
         {
           "activate": false,
           "from": "Alice",
+          "id": "0",
           "message": "Hello Bob, how are you?",
           "to": "Bob",
           "type": 5,
@@ -139,6 +142,7 @@ describe('more than one sequence diagram', () => {
         {
           "activate": false,
           "from": "Bob",
+          "id": "1",
           "message": "I am good thanks!",
           "to": "Alice",
           "type": 6,
@@ -158,6 +162,7 @@ describe('more than one sequence diagram', () => {
         {
           "activate": false,
           "from": "Alice",
+          "id": "0",
           "message": "Hello John, how are you?",
           "to": "John",
           "type": 5,
@@ -166,6 +171,7 @@ describe('more than one sequence diagram', () => {
         {
           "activate": false,
           "from": "John",
+          "id": "1",
           "message": "I am good thanks!",
           "to": "Alice",
           "type": 6,
@@ -221,27 +227,27 @@ Alice->Bob:Hello Bob, how are you?
 Note right of Bob: Bob thinks
 Bob-->Alice: I am good thanks!`;
 
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram); // needs to be rendered for the correct value of visibility auto numbers
-    expect(diagram.db.showSequenceNumbers()).toBe(true);
+    const diagram1 = await Diagram.fromText(str);
+
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1); // needs to be rendered for the correct value of visibility auto numbers
+    expect(diagram1.db.showSequenceNumbers()).toBe(true);
   });
 
   it('should handle a sequenceDiagram definition with a title:', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 title: Diagram Title
 Alice->Bob:Hello Bob, how are you?
 Note right of Bob: Bob thinks
-Bob-->Alice: I am good thanks!`;
+Bob-->Alice: I am good thanks!`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    expect(diagram.db.getAccDescription()).toBe('');
-    const messages = diagram.db.getMessages();
-    const title = diagram.db.getDiagramTitle();
+    expect(diagram1.db.getAccDescription()).toBe('');
+    const messages = diagram1.db.getMessages();
+    const title = diagram1.db.getDiagramTitle();
 
     expect(messages.length).toBe(3);
     expect(messages[0].from).toBe('Alice');
@@ -250,21 +256,20 @@ Bob-->Alice: I am good thanks!`;
   });
 
   it('should handle a sequenceDiagram definition with a title without a :', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 title Diagram Title
 Alice->Bob:Hello Bob, how are you?
 Note right of Bob: Bob thinks
-Bob-->Alice: I am good thanks!`;
+Bob-->Alice: I am good thanks!`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    expect(diagram.db.getAccDescription()).toBe('');
-    const messages = diagram.db.getMessages();
-    const title = diagram.db.getDiagramTitle();
+    expect(diagram1.db.getAccDescription()).toBe('');
+    const messages = diagram1.db.getMessages();
+    const title = diagram1.db.getDiagramTitle();
 
     expect(messages.length).toBe(3);
     expect(messages[0].from).toBe('Alice');
@@ -273,22 +278,20 @@ Bob-->Alice: I am good thanks!`;
   });
 
   it('should handle a sequenceDiagram definition with a accessibility title and description (accDescr)', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 title: Diagram Title
 accTitle: This is the title
 accDescr: Accessibility Description
 Alice->Bob:Hello Bob, how are you?
-`;
+`);
 
-    await mermaidAPI.parse(str);
-    expect(diagram.db.getDiagramTitle()).toBe('Diagram Title');
-    expect(diagram.db.getAccTitle()).toBe('This is the title');
-    expect(diagram.db.getAccDescription()).toBe('Accessibility Description');
-    const messages = diagram.db.getMessages();
+    expect(diagram1.db.getDiagramTitle()).toBe('Diagram Title');
+    expect(diagram1.db.getAccTitle()).toBe('This is the title');
+    expect(diagram1.db.getAccDescription()).toBe('Accessibility Description');
   });
   it('should handle a sequenceDiagram definition with a accessibility title and multiline description (accDescr)', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 accTitle: This is the title
 accDescr {
@@ -296,43 +299,39 @@ Accessibility
 Description
 }
 Alice->Bob:Hello Bob, how are you?
-`;
+`);
 
-    await mermaidAPI.parse(str);
-    expect(diagram.db.getAccTitle()).toBe('This is the title');
-    expect(diagram.db.getAccDescription()).toBe('Accessibility\nDescription');
-    const messages = diagram.db.getMessages();
+    expect(diagram1.db.getAccTitle()).toBe('This is the title');
+    expect(diagram1.db.getAccDescription()).toBe('Accessibility\nDescription');
   });
 
   it('should space in actor names', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob:Hello Bob, how are - you?
-Bob-->Alice: I am good thanks!`;
+Bob-->Alice: I am good thanks!`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(2);
     expect(messages[0].from).toBe('Alice');
     expect(messages[1].from).toBe('Bob');
   });
   it('should handle dashes in actor names', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice-in-Wonderland->Bob:Hello Bob, how are - you?
-Bob-->Alice-in-Wonderland:I am good thanks!`;
+Bob-->Alice-in-Wonderland:I am good thanks!`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice-in-Wonderland').description).toBe('Alice-in-Wonderland');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(2);
     expect(messages[0].from).toBe('Alice-in-Wonderland');
@@ -340,20 +339,19 @@ Bob-->Alice-in-Wonderland:I am good thanks!`;
   });
 
   it('should handle dashes in participant names', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 participant Alice-in-Wonderland
 participant Bob
 Alice-in-Wonderland->Bob:Hello Bob, how are - you?
-Bob-->Alice-in-Wonderland:I am good thanks!`;
+Bob-->Alice-in-Wonderland:I am good thanks!`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect([...actors.keys()]).toEqual(['Alice-in-Wonderland', 'Bob']);
     expect(actors.get('Alice-in-Wonderland').description).toBe('Alice-in-Wonderland');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(2);
     expect(messages[0].from).toBe('Alice-in-Wonderland');
@@ -361,28 +359,26 @@ Bob-->Alice-in-Wonderland:I am good thanks!`;
   });
 
   it('should alias participants', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 participant A as Alice
 participant B as Bob
 A->B:Hello Bob, how are you?
-B-->A: I am good thanks!`;
+B-->A: I am good thanks!`);
 
-    await mermaidAPI.parse(str);
-
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
 
     expect([...actors.keys()]).toEqual(['A', 'B']);
     expect(actors.get('A').description).toBe('Alice');
     expect(actors.get('B').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages.length).toBe(2);
     expect(messages[0].from).toBe('A');
     expect(messages[1].from).toBe('B');
   });
   it('should alias a mix of actors and participants apa12', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
   actor Alice as Alice2
   actor Bob
@@ -392,11 +388,9 @@ sequenceDiagram
   Bob->>Alice: Hi Alice
   Alice->>John: Hi John
   John->>Mandy: Hi Mandy
-  Mandy ->>Joan: Hi Joan`;
+  Mandy ->>Joan: Hi Joan`);
 
-    await mermaidAPI.parse(str);
-
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect([...actors.keys()]).toEqual(['Alice', 'Bob', 'John', 'Mandy', 'Joan']);
     expect(actors.get('Alice').description).toBe('Alice2');
     expect(actors.get('Alice').type).toBe('actor');
@@ -404,219 +398,212 @@ sequenceDiagram
     expect(actors.get('John').type).toBe('participant');
     expect(actors.get('Joan').type).toBe('participant');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages.length).toBe(5);
     expect(messages[0].from).toBe('Alice');
     expect(messages[4].to).toBe('Joan');
   });
   it('should alias actors apa13', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 actor A as Alice
 actor B as Bob
 A->B:Hello Bob, how are you?
-B-->A: I am good thanks!`;
+B-->A: I am good thanks!`);
 
-    await mermaidAPI.parse(str);
-
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect([...actors.keys()]).toEqual(['A', 'B']);
     expect(actors.get('A').description).toBe('Alice');
     expect(actors.get('B').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages.length).toBe(2);
     expect(messages[0].from).toBe('A');
     expect(messages[1].from).toBe('B');
   });
   it('should handle in async messages', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
-Alice-xBob:Hello Bob, how are you?`;
+Alice-xBob:Hello Bob, how are you?`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(1);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.SOLID_CROSS);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.SOLID_CROSS);
   });
   it('should handle in async dotted messages', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
-Alice--xBob:Hello Bob, how are you?`;
+Alice--xBob:Hello Bob, how are you?`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(1);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.DOTTED_CROSS);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.DOTTED_CROSS);
   });
   it('should handle in sync messages', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
-Alice-)Bob:Hello Bob, how are you?`;
+Alice-)Bob:Hello Bob, how are you?`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(1);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.SOLID_POINT);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.SOLID_POINT);
   });
   it('should handle in sync dotted messages', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
-Alice--)Bob:Hello Bob, how are you?`;
+Alice--)Bob:Hello Bob, how are you?`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(1);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.DOTTED_POINT);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.DOTTED_POINT);
   });
   it('should handle in arrow messages', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
-Alice->>Bob:Hello Bob, how are you?`;
+Alice->>Bob:Hello Bob, how are you?`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(1);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.SOLID);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.SOLID);
   });
   it('should handle in arrow messages', async () => {
-    const str = 'sequenceDiagram\n' + 'Alice-->>Bob:Hello Bob, how are you?';
+    const diagram1 = await Diagram.fromText(
+      'sequenceDiagram\n' + 'Alice-->>Bob:Hello Bob, how are you?'
+    );
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(1);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.DOTTED);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.DOTTED);
   });
   it('should handle bidirectional arrow messages', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(
+      `
 sequenceDiagram
-Alice<<->>Bob:Hello Bob, how are you?`;
+Alice<<->>Bob:Hello Bob, how are you?`
+    );
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(1);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.BIDIRECTIONAL_SOLID);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.BIDIRECTIONAL_SOLID);
   });
   it('should handle bidirectional dotted arrow messages', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(
+      `
     sequenceDiagram
-    Alice<<-->>Bob:Hello Bob, how are you?`;
+    Alice<<-->>Bob:Hello Bob, how are you?`
+    );
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(1);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.BIDIRECTIONAL_DOTTED);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.BIDIRECTIONAL_DOTTED);
   });
   it('should handle actor activation', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice-->>Bob:Hello Bob, how are you?
 activate Bob
 Bob-->>Alice:Hello Alice, I'm fine and  you?
-deactivate Bob`;
+deactivate Bob`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(4);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.DOTTED);
-    expect(messages[1].type).toBe(diagram.db.LINETYPE.ACTIVE_START);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.DOTTED);
+    expect(messages[1].type).toBe(diagram1.db.LINETYPE.ACTIVE_START);
     expect(messages[1].from).toBe('Bob');
-    expect(messages[2].type).toBe(diagram.db.LINETYPE.DOTTED);
-    expect(messages[3].type).toBe(diagram.db.LINETYPE.ACTIVE_END);
+    expect(messages[2].type).toBe(diagram1.db.LINETYPE.DOTTED);
+    expect(messages[3].type).toBe(diagram1.db.LINETYPE.ACTIVE_END);
     expect(messages[3].from).toBe('Bob');
   });
   it('should handle actor one line notation activation', async () => {
-    const str = `
-      sequenceDiagram
-      Alice-->>+Bob:Hello Bob, how are you?
-      Bob-->>- Alice:Hello Alice, I'm fine and  you?`;
+    const diagram1 = await Diagram.fromText(`
+    sequenceDiagram
+    Alice-->>+Bob:Hello Bob, how are you?
+    Bob-->>- Alice:Hello Alice, I'm fine and  you?`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(4);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.DOTTED);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.DOTTED);
     expect(messages[0].activate).toBeTruthy();
-    expect(messages[1].type).toBe(diagram.db.LINETYPE.ACTIVE_START);
+    expect(messages[1].type).toBe(diagram1.db.LINETYPE.ACTIVE_START);
     expect(messages[1].from).toBe('Bob');
-    expect(messages[2].type).toBe(diagram.db.LINETYPE.DOTTED);
-    expect(messages[3].type).toBe(diagram.db.LINETYPE.ACTIVE_END);
+    expect(messages[2].type).toBe(diagram1.db.LINETYPE.DOTTED);
+    expect(messages[3].type).toBe(diagram1.db.LINETYPE.ACTIVE_END);
     expect(messages[3].from).toBe('Bob');
   });
   it('should handle stacked activations', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
       sequenceDiagram
       Alice-->>+Bob:Hello Bob, how are you?
       Bob-->>+Carol:Carol, let me introduce Alice?
       Bob-->>- Alice:Hello Alice, please meet Carol?
-      Carol->>- Bob:Oh Bob, I'm so happy to be here!`;
+      Carol->>- Bob:Oh Bob, I'm so happy to be here!`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(8);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.DOTTED);
-    expect(messages[1].type).toBe(diagram.db.LINETYPE.ACTIVE_START);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.DOTTED);
+    expect(messages[1].type).toBe(diagram1.db.LINETYPE.ACTIVE_START);
     expect(messages[1].from).toBe('Bob');
-    expect(messages[2].type).toBe(diagram.db.LINETYPE.DOTTED);
-    expect(messages[3].type).toBe(diagram.db.LINETYPE.ACTIVE_START);
+    expect(messages[2].type).toBe(diagram1.db.LINETYPE.DOTTED);
+    expect(messages[3].type).toBe(diagram1.db.LINETYPE.ACTIVE_START);
     expect(messages[3].from).toBe('Carol');
-    expect(messages[5].type).toBe(diagram.db.LINETYPE.ACTIVE_END);
+    expect(messages[5].type).toBe(diagram1.db.LINETYPE.ACTIVE_END);
     expect(messages[5].from).toBe('Bob');
-    expect(messages[7].type).toBe(diagram.db.LINETYPE.ACTIVE_END);
+    expect(messages[7].type).toBe(diagram1.db.LINETYPE.ACTIVE_END);
     expect(messages[7].from).toBe('Carol');
   });
   it('should handle fail parsing when activating an inactive participant', async () => {
@@ -646,102 +633,97 @@ deactivate Bob`;
   });
 
   it('should handle comments in a sequenceDiagram', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
       sequenceDiagram
       Alice->Bob: Hello Bob, how are you?
       %% Comment
       Note right of Bob: Bob thinks
-      Bob-->Alice: I am good thanks!`;
+      Bob-->Alice: I am good thanks!`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(3);
     expect(messages[0].from).toBe('Alice');
     expect(messages[2].from).toBe('Bob');
   });
   it('should handle new lines in a sequenceDiagram', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
       sequenceDiagram
       Alice->Bob: Hello Bob, how are you?
 
       %% Comment
       Note right of Bob: Bob thinks
       Bob-->Alice: I am good thanks!
-      `;
+      `);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(3);
     expect(messages[0].from).toBe('Alice');
     expect(messages[2].from).toBe('Bob');
   });
   it('should handle semicolons', async () => {
-    const str = `
-sequenceDiagram;Alice->Bob: Hello Bob, how are you?;Note right of Bob: Bob thinks;Bob-->Alice: I am good thanks!;`;
+    const diagram1 = await Diagram.fromText(`
+sequenceDiagram;Alice->Bob: Hello Bob, how are you?;Note right of Bob: Bob thinks;Bob-->Alice: I am good thanks!;`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(3);
     expect(messages[0].from).toBe('Alice');
     expect(messages[2].from).toBe('Bob');
   });
   it('should handle one leading space in lines in a sequenceDiagram', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
  Alice->Bob: Hello Bob, how are you?
 
 %% Comment
 Note right of Bob: Bob thinks
-Bob-->Alice: I am good thanks!`;
+Bob-->Alice: I am good thanks!`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(3);
     expect(messages[0].from).toBe('Alice');
     expect(messages[2].from).toBe('Bob');
   });
   it('should handle several leading spaces in lines in a sequenceDiagram', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
    Alice->Bob: Hello Bob, how are you?
 
 %% Comment
 Note right of Bob: Bob thinks
-Bob-->Alice: I am good thanks!`;
+Bob-->Alice: I am good thanks!`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(3);
     expect(messages[0].from).toBe('Alice');
     expect(messages[2].from).toBe('Bob');
   });
   it('should handle several leading spaces in lines in a sequenceDiagram', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 participant Alice
 participant Bob
@@ -752,21 +734,20 @@ John->John: Fight against hypochondria
 Note right of John: Rational thoughts<br/>prevail...
     John-->Alice: Great!
     John->Bob: How about you?
-Bob-->John: Jolly good!`;
+Bob-->John: Jolly good!`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(8);
     expect(messages[0].from).toBe('Alice');
     expect(messages[2].from).toBe('John');
   });
   it('should handle different line breaks', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 participant 1 as multiline<br>text
 participant 2 as multiline<br/>text
@@ -780,17 +761,15 @@ note right of 3: multiline<br/>text
 note right of 4: multiline<br />text
 4->>1: multiline<br \t/>text
 note right of 1: multiline<br \t/>text
-`;
+`);
 
-    await mermaidAPI.parse(str);
-
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('1').description).toBe('multiline<br>text');
     expect(actors.get('2').description).toBe('multiline<br/>text');
     expect(actors.get('3').description).toBe('multiline<br />text');
     expect(actors.get('4').description).toBe('multiline<br \t/>text');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[0].message).toBe('multiline<br>text');
     expect(messages[1].message).toBe('multiline<br>text');
     expect(messages[2].message).toBe('multiline<br/>text');
@@ -801,7 +780,7 @@ note right of 1: multiline<br \t/>text
     expect(messages[7].message).toBe('multiline<br \t/>text');
   });
   it('should handle notes and messages without wrap specified', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 participant 1
 participant 2
@@ -815,11 +794,9 @@ note right of 3:nowrap: single-line text
 note right of 4: multiline<br/>text
 4->>1:nowrap: multiline<br/>text
 note right of 1:nowrap: multiline<br/>text
-`;
+`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[0].message).toBe('single-line text');
     expect(messages[1].message).toBe('single-line text');
     expect(messages[2].message).toBe('single-line text');
@@ -840,7 +817,7 @@ note right of 1:nowrap: multiline<br/>text
     expect(messages[7].wrap).toBe(false);
   });
   it('should handle notes and messages with wrap specified', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 participant 1
 participant 2
@@ -850,11 +827,9 @@ participant 4
 note right of 2:wrap: single-line text
 2->>3:wrap: multiline<br/>text
 note right of 3:wrap: multiline<br/>text
-`;
+`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[0].message).toBe('single-line text');
     expect(messages[1].message).toBe('single-line text');
     expect(messages[2].message).toBe('multiline<br/>text');
@@ -865,53 +840,47 @@ note right of 3:wrap: multiline<br/>text
     expect(messages[3].wrap).toBe(true);
   });
   it('should handle notes and messages with nowrap or line breaks', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 participant 1
 participant 2
 1->>2: single-line text
 note right of 2: single-line text
-`;
+`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[0].message).toBe('single-line text');
     expect(messages[1].message).toBe('single-line text');
     expect(messages[0].wrap).toBe(false);
     expect(messages[1].wrap).toBe(false);
   });
   it('should handle notes over a single actor', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 Note over Bob: Bob thinks
-`;
+`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[1].from).toBe('Bob');
     expect(messages[1].to).toBe('Bob');
   });
   it('should handle notes over multiple actors', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 Note over Alice,Bob: confusion
 Note over Bob,Alice: resolution
-`;
+`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[1].from).toBe('Alice');
     expect(messages[1].to).toBe('Bob');
     expect(messages[2].from).toBe('Bob');
     expect(messages[2].to).toBe('Alice');
   });
   it('should handle loop statements', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 
@@ -920,21 +889,20 @@ Note right of Bob: Bob thinks
 loop Multiple happy responses
 
 Bob-->Alice: I am good thanks!
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(5);
     expect(messages[0].from).toBe('Alice');
     expect(messages[1].from).toBe('Bob');
   });
   it('should add a rect around sequence', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
       sequenceDiagram
         Alice->Bob: Hello Bob, how are you?
         %% Comment
@@ -942,23 +910,22 @@ end`;
         Note right of Bob: Bob thinks
         Bob-->Alice: I am good thanks
         end
-    `;
+    `);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
-    expect(messages[1].type).toEqual(diagram.db.LINETYPE.RECT_START);
+    const messages = diagram1.db.getMessages();
+    expect(messages[1].type).toEqual(diagram1.db.LINETYPE.RECT_START);
     expect(messages[1].message).toBe('rgb(200, 255, 200)');
-    expect(messages[2].type).toEqual(diagram.db.LINETYPE.NOTE);
-    expect(messages[3].type).toEqual(diagram.db.LINETYPE.DOTTED_OPEN);
-    expect(messages[4].type).toEqual(diagram.db.LINETYPE.RECT_END);
+    expect(messages[2].type).toEqual(diagram1.db.LINETYPE.NOTE);
+    expect(messages[3].type).toEqual(diagram1.db.LINETYPE.DOTTED_OPEN);
+    expect(messages[4].type).toEqual(diagram1.db.LINETYPE.RECT_END);
   });
 
   it('should allow for nested rects', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
       sequenceDiagram
         Alice->Bob: Hello Bob, how are you?
         %% Comment
@@ -968,24 +935,24 @@ end`;
         end
         Bob-->Alice: I am good thanks
         end
-    `;
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    `);
+
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
-    expect(messages[1].type).toEqual(diagram.db.LINETYPE.RECT_START);
+    const messages = diagram1.db.getMessages();
+    expect(messages[1].type).toEqual(diagram1.db.LINETYPE.RECT_START);
     expect(messages[1].message).toBe('rgb(200, 255, 200)');
-    expect(messages[2].type).toEqual(diagram.db.LINETYPE.RECT_START);
+    expect(messages[2].type).toEqual(diagram1.db.LINETYPE.RECT_START);
     expect(messages[2].message).toBe('rgb(0, 0, 0)');
-    expect(messages[3].type).toEqual(diagram.db.LINETYPE.NOTE);
-    expect(messages[4].type).toEqual(diagram.db.LINETYPE.RECT_END);
-    expect(messages[5].type).toEqual(diagram.db.LINETYPE.DOTTED_OPEN);
-    expect(messages[6].type).toEqual(diagram.db.LINETYPE.RECT_END);
+    expect(messages[3].type).toEqual(diagram1.db.LINETYPE.NOTE);
+    expect(messages[4].type).toEqual(diagram1.db.LINETYPE.RECT_END);
+    expect(messages[5].type).toEqual(diagram1.db.LINETYPE.DOTTED_OPEN);
+    expect(messages[6].type).toEqual(diagram1.db.LINETYPE.RECT_END);
   });
   it('should handle opt statements', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 
@@ -994,21 +961,20 @@ Note right of Bob: Bob thinks
 opt Perhaps a happy response
 
 Bob-->Alice: I am good thanks!
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(5);
     expect(messages[0].from).toBe('Alice');
     expect(messages[1].from).toBe('Bob');
   });
   it('should handle alt statements', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 
@@ -1019,22 +985,21 @@ alt isWell
 Bob-->Alice: I am good thanks!
 else isSick
 Bob-->Alice: Feel sick...
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
 
     expect(actors.get('Alice').description).toBe('Alice');
     actors.get('Bob').description = 'Bob';
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(7);
     expect(messages[0].from).toBe('Alice');
     expect(messages[1].from).toBe('Bob');
   });
   it('should handle alt statements with multiple elses', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 
@@ -1047,41 +1012,40 @@ else isSick
 Bob-->Alice: Feel sick...
 else default
 Bob-->Alice: :-)
-end`;
-    await mermaidAPI.parse(str);
-    const messages = diagram.db.getMessages();
+end`);
+
+    const messages = diagram1.db.getMessages();
     expect(messages.length).toBe(9);
     expect(messages[1].from).toBe('Bob');
-    expect(messages[2].type).toBe(diagram.db.LINETYPE.ALT_START);
+    expect(messages[2].type).toBe(diagram1.db.LINETYPE.ALT_START);
     expect(messages[3].from).toBe('Bob');
-    expect(messages[4].type).toBe(diagram.db.LINETYPE.ALT_ELSE);
+    expect(messages[4].type).toBe(diagram1.db.LINETYPE.ALT_ELSE);
     expect(messages[5].from).toBe('Bob');
-    expect(messages[6].type).toBe(diagram.db.LINETYPE.ALT_ELSE);
+    expect(messages[6].type).toBe(diagram1.db.LINETYPE.ALT_ELSE);
     expect(messages[7].from).toBe('Bob');
-    expect(messages[8].type).toBe(diagram.db.LINETYPE.ALT_END);
+    expect(messages[8].type).toBe(diagram1.db.LINETYPE.ALT_END);
   });
   it('should handle critical statements without options', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
     critical Establish a connection to the DB
         Service-->DB: connect
-    end`;
+    end`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
 
     expect(actors.get('Service').description).toBe('Service');
     expect(actors.get('DB').description).toBe('DB');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(3);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.CRITICAL_START);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.CRITICAL_START);
     expect(messages[1].from).toBe('Service');
-    expect(messages[2].type).toBe(diagram.db.LINETYPE.CRITICAL_END);
+    expect(messages[2].type).toBe(diagram1.db.LINETYPE.CRITICAL_END);
   });
   it('should handle critical statements with options', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
     critical Establish a connection to the DB
         Service-->DB: connect
@@ -1089,53 +1053,51 @@ sequenceDiagram
         Service-->Service: Log error
     option Credentials rejected
         Service-->Service: Log different error
-    end`;
+    end`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
 
     expect(actors.get('Service').description).toBe('Service');
     expect(actors.get('DB').description).toBe('DB');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(7);
-    expect(messages[0].type).toBe(diagram.db.LINETYPE.CRITICAL_START);
+    expect(messages[0].type).toBe(diagram1.db.LINETYPE.CRITICAL_START);
     expect(messages[1].from).toBe('Service');
-    expect(messages[2].type).toBe(diagram.db.LINETYPE.CRITICAL_OPTION);
+    expect(messages[2].type).toBe(diagram1.db.LINETYPE.CRITICAL_OPTION);
     expect(messages[3].from).toBe('Service');
-    expect(messages[4].type).toBe(diagram.db.LINETYPE.CRITICAL_OPTION);
+    expect(messages[4].type).toBe(diagram1.db.LINETYPE.CRITICAL_OPTION);
     expect(messages[5].from).toBe('Service');
-    expect(messages[6].type).toBe(diagram.db.LINETYPE.CRITICAL_END);
+    expect(messages[6].type).toBe(diagram1.db.LINETYPE.CRITICAL_END);
   });
   it('should handle break statements', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
     Consumer-->API: Book something
     API-->BookingService: Start booking process
     break when the booking process fails
         API-->Consumer: show failure
     end
-    API-->BillingService: Start billing process`;
+    API-->BillingService: Start billing process`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
 
     expect(actors.get('Consumer').description).toBe('Consumer');
     expect(actors.get('API').description).toBe('API');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(6);
     expect(messages[0].from).toBe('Consumer');
     expect(messages[1].from).toBe('API');
-    expect(messages[2].type).toBe(diagram.db.LINETYPE.BREAK_START);
+    expect(messages[2].type).toBe(diagram1.db.LINETYPE.BREAK_START);
     expect(messages[3].from).toBe('API');
-    expect(messages[4].type).toBe(diagram.db.LINETYPE.BREAK_END);
+    expect(messages[4].type).toBe(diagram1.db.LINETYPE.BREAK_END);
     expect(messages[5].from).toBe('API');
   });
   it('should handle par statements a sequenceDiagram', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 par Parallel one
 Alice->>Bob: Hello Bob, how are you?
@@ -1146,15 +1108,14 @@ Bob-->>Alice: Fine!
 and Parallel three
 Alice->>Bob: What do you think about it?
 Bob-->>Alice: It's good!
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
 
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(10);
     expect(messages[0].message).toBe('Parallel one');
@@ -1162,21 +1123,20 @@ end`;
     expect(messages[2].from).toBe('Bob');
   });
   it('it should handle par_over statements', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 par_over Parallel overlap
 Alice ->> Bob: Message
 Note left of Alice: Alice note
 Note right of Bob: Bob note
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
 
     expect(actors.get('Alice').description).toBe('Alice');
     expect(actors.get('Bob').description).toBe('Bob');
 
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
 
     expect(messages.length).toBe(5);
     expect(messages[0].message).toBe('Parallel overlap');
@@ -1185,139 +1145,119 @@ end`;
     expect(messages[3].from).toBe('Bob');
   });
   it('should handle special characters in signals', async () => {
-    const str = 'sequenceDiagram\n' + 'Alice->Bob: -:<>,;# comment';
+    const diagram1 = await Diagram.fromText('sequenceDiagram\n' + 'Alice->Bob: -:<>,;# comment');
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[0].message).toBe('-:<>,');
   });
   it('should handle special characters in notes', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
-Note right of Bob: -:<>,;# comment`;
+Note right of Bob: -:<>,;# comment`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[1].message).toBe('-:<>,');
   });
   it('should handle special characters in loop', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 loop -:<>,;# comment
 Bob-->Alice: I am good thanks!
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[1].message).toBe('-:<>,');
   });
   it('should handle special characters in opt', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 opt -:<>,;# comment
 Bob-->Alice: I am good thanks!
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[1].message).toBe('-:<>,');
   });
   it('should handle special characters in alt', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 alt -:<>,;# comment
 Bob-->Alice: I am good thanks!
 else ,<>:-#; comment
 Bob-->Alice: I am good thanks!
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[1].message).toBe('-:<>,');
     expect(messages[3].message).toBe(',<>:-');
   });
   it('should handle special characters in par', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 par -:<>,;# comment
 Bob-->Alice: I am good thanks!
 and ,<>:-#; comment
 Bob-->Alice: I am good thanks!
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[1].message).toBe('-:<>,');
     expect(messages[3].message).toBe(',<>:-');
   });
   it('should handle no-label loop', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 loop
 Bob-->Alice: I am good thanks!
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[1].message).toBe('');
     expect(messages[2].message).toBe('I am good thanks!');
   });
   it('should handle no-label opt', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 opt # comment
 Bob-->Alice: I am good thanks!
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[1].message).toBe('');
     expect(messages[2].message).toBe('I am good thanks!');
   });
   it('should handle no-label alt', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 alt;Bob-->Alice: I am good thanks!
 else # comment
 Bob-->Alice: I am good thanks!
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[1].message).toBe('');
     expect(messages[2].message).toBe('I am good thanks!');
     expect(messages[3].message).toBe('');
     expect(messages[4].message).toBe('I am good thanks!');
   });
   it('should handle no-label par', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 par;Bob-->Alice: I am good thanks!
 and # comment
 Bob-->Alice: I am good thanks!
-end`;
+end`);
 
-    await mermaidAPI.parse(str);
-
-    const messages = diagram.db.getMessages();
+    const messages = diagram1.db.getMessages();
     expect(messages[1].message).toBe('');
     expect(messages[2].message).toBe('I am good thanks!');
     expect(messages[3].message).toBe('');
@@ -1325,7 +1265,7 @@ end`;
   });
 
   it('should handle links', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 participant a as Alice
 participant b as Bob
@@ -1336,10 +1276,9 @@ links a: { "On-Call": "https://oncall.contoso.com/?svc=alice" }
 link a: Endpoint @ https://alice.contoso.com
 link a: Swagger @ https://swagger.contoso.com
 link a: Tests @ https://tests.contoso.com/?svc=alice@contoso.com
-`;
+`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('a').links.Repo).toBe('https://repo.contoso.com/');
     expect(actors.get('b').links.Repo).toBe(undefined);
     expect(actors.get('a').links.Dashboard).toBe('https://dashboard.contoso.com/');
@@ -1353,17 +1292,16 @@ link a: Tests @ https://tests.contoso.com/?svc=alice@contoso.com
 
   it('should handle properties EXPERIMENTAL: USE WITH CAUTION', async () => {
     //Be aware that the syntax for "properties" is likely to be changed.
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 participant a as Alice
 participant b as Bob
 participant c as Charlie
 properties a: {"class": "internal-service-actor", "icon": "@clock"}
 properties b: {"class": "external-service-actor", "icon": "@computer"}
-`;
+`);
 
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect(actors.get('a').properties.class).toBe('internal-service-actor');
     expect(actors.get('b').properties.class).toBe('external-service-actor');
     expect(actors.get('a').properties.icon).toBe('@clock');
@@ -1372,7 +1310,7 @@ properties b: {"class": "external-service-actor", "icon": "@computer"}
   });
 
   it('should handle box', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 box green Group 1
 participant a as Alice
@@ -1385,17 +1323,16 @@ links a: { "On-Call": "https://oncall.contoso.com/?svc=alice" }
 link a: Endpoint @ https://alice.contoso.com
 link a: Swagger @ https://swagger.contoso.com
 link a: Tests @ https://tests.contoso.com/?svc=alice@contoso.com
-`;
+`);
 
-    await mermaidAPI.parse(str);
-    const boxes = diagram.db.getBoxes();
+    const boxes = diagram1.db.getBoxes();
     expect(boxes[0].name).toEqual('Group 1');
     expect(boxes[0].actorKeys).toEqual(['a', 'b']);
     expect(boxes[0].fill).toEqual('green');
   });
 
   it('should handle box without color', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
   sequenceDiagram
   box Group 1
   participant a as Alice
@@ -1408,17 +1345,16 @@ link a: Tests @ https://tests.contoso.com/?svc=alice@contoso.com
   link a: Endpoint @ https://alice.contoso.com
   link a: Swagger @ https://swagger.contoso.com
   link a: Tests @ https://tests.contoso.com/?svc=alice@contoso.com
-  `;
+  `);
 
-    await mermaidAPI.parse(str);
-    const boxes = diagram.db.getBoxes();
+    const boxes = diagram1.db.getBoxes();
     expect(boxes[0].name).toEqual('Group 1');
     expect(boxes[0].actorKeys).toEqual(['a', 'b']);
     expect(boxes[0].fill).toEqual('transparent');
   });
 
   it('should handle box without description', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
   sequenceDiagram
   box Aqua
   participant a as Alice
@@ -1431,17 +1367,16 @@ link a: Tests @ https://tests.contoso.com/?svc=alice@contoso.com
   link a: Endpoint @ https://alice.contoso.com
   link a: Swagger @ https://swagger.contoso.com
   link a: Tests @ https://tests.contoso.com/?svc=alice@contoso.com
-  `;
+  `);
 
-    await mermaidAPI.parse(str);
-    const boxes = diagram.db.getBoxes();
+    const boxes = diagram1.db.getBoxes();
     expect(boxes[0].name).toBeFalsy();
     expect(boxes[0].actorKeys).toEqual(['a', 'b']);
     expect(boxes[0].fill).toEqual('Aqua');
   });
 
   it('should handle simple actor creation', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
   sequenceDiagram
   participant a as Alice
   a ->>b: Hello Bob?
@@ -1450,10 +1385,9 @@ link a: Tests @ https://tests.contoso.com/?svc=alice@contoso.com
   c ->> b: Hello b?
   create actor d as Donald
   a ->> d: Hello Donald?
-  `;
-    await mermaidAPI.parse(str);
-    const actors = diagram.db.getActors();
-    const createdActors = diagram.db.getCreatedActors();
+  `);
+    const actors = diagram1.db.getActors();
+    const createdActors = diagram1.db.getCreatedActors();
     expect(actors.get('c').name).toEqual('c');
     expect(actors.get('c').description).toEqual('c');
     expect(actors.get('c').type).toEqual('participant');
@@ -1464,7 +1398,7 @@ link a: Tests @ https://tests.contoso.com/?svc=alice@contoso.com
     expect(createdActors.get('d')).toEqual(3);
   });
   it('should handle simple actor destruction', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
   sequenceDiagram
   participant a as Alice
   a ->>b: Hello Bob?
@@ -1473,14 +1407,13 @@ link a: Tests @ https://tests.contoso.com/?svc=alice@contoso.com
   b ->> c: Where is Alice?
   destroy c
   b ->> c: Where are you?
-  `;
-    await mermaidAPI.parse(str);
-    const destroyedActors = diagram.db.getDestroyedActors();
+  `);
+    const destroyedActors = diagram1.db.getDestroyedActors();
     expect(destroyedActors.get('a')).toEqual(1);
     expect(destroyedActors.get('c')).toEqual(3);
   });
   it('should handle the creation and destruction of the same actor', async () => {
-    const str = `
+    const diagram2 = await Diagram.fromText(`
   sequenceDiagram
   a ->>b: Hello Bob?
   create participant c
@@ -1488,10 +1421,9 @@ link a: Tests @ https://tests.contoso.com/?svc=alice@contoso.com
   c ->> b: Hello b?
   destroy c
   b ->> c : Bye c !
-  `;
-    await mermaidAPI.parse(str);
-    const createdActors = diagram.db.getCreatedActors();
-    const destroyedActors = diagram.db.getDestroyedActors();
+  `);
+    const createdActors = diagram2.db.getCreatedActors();
+    const destroyedActors = diagram2.db.getDestroyedActors();
     expect(createdActors.get('c')).toEqual(1);
     expect(destroyedActors.get('c')).toEqual(3);
   });
@@ -1571,7 +1503,7 @@ describe('when checking the bounds in a sequenceDiagram', function () {
     expect(bounds.stopx).toBe(300);
     expect(bounds.stopy).toBe(400);
   });
-  it('should handle multiple loops withtout expanding the bounds', () => {
+  it('should handle multiple loops without expanding the bounds', () => {
     diagram.renderer.bounds.insert(100, 100, 1000, 1000);
     diagram.renderer.bounds.verticalPos = 200;
     diagram.renderer.bounds.newLoop();
@@ -1676,11 +1608,11 @@ it should handle one actor, when textPlacement is ${textPlacement}`, async () =>
 sequenceDiagram
 participant Alice`;
 
-      await mermaidAPI.parse(str);
+      const diagram1 = await Diagram.fromText(str);
       // diagram.renderer.setConf(mermaidAPI.getConfig().sequence);
-      await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+      await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-      const { bounds } = diagram.renderer.bounds.getBounds();
+      const { bounds } = diagram1.renderer.bounds.getBounds();
       expect(bounds.startx).toBe(0);
       expect(bounds.starty).toBe(0);
       expect(bounds.stopx).toBe(conf.width);
@@ -1688,16 +1620,14 @@ participant Alice`;
     });
   });
   it('should handle same actor with different whitespace properly', async () => {
-    const str = `
+    const diagram1 = await Diagram.fromText(`
 sequenceDiagram
 participant Alice
 participant Alice
 participant Alice
-`;
+`);
 
-    await mermaidAPI.parse(str);
-
-    const actors = diagram.db.getActors();
+    const actors = diagram1.db.getActors();
     expect([...actors.keys()]).toEqual(['Alice']);
   });
   it('should handle one actor and a centered note', async () => {
@@ -1706,12 +1636,12 @@ sequenceDiagram
 participant Alice
 Note over Alice: Alice thinks
 `;
+    const diagram1 = await Diagram.fromText(str);
 
     expect(mermaidAPI.getConfig().sequence.mirrorActors).toBeFalsy();
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     expect(bounds.startx).toBe(0);
     expect(bounds.starty).toBe(0);
     expect(bounds.stopx).toBe(conf.width);
@@ -1724,10 +1654,10 @@ sequenceDiagram
 participant Alice
 Note left of Alice: Alice thinks`;
 
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     expect(bounds.startx).toBe(-(conf.width / 2) - conf.actorMargin / 2);
     expect(bounds.starty).toBe(0);
     expect(bounds.stopx).toBe(conf.width);
@@ -1740,10 +1670,10 @@ sequenceDiagram
 participant Alice
 Note right of Alice: Alice thinks`;
 
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     expect(bounds.startx).toBe(0);
     expect(bounds.starty).toBe(0);
     expect(bounds.stopx).toBe(conf.width / 2 + conf.actorMargin / 2 + conf.width);
@@ -1755,10 +1685,10 @@ Note right of Alice: Alice thinks`;
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?`;
 
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     expect(bounds.startx).toBe(0);
     expect(bounds.starty).toBe(0);
     expect(bounds.stopx).toBe(conf.width * 2 + conf.actorMargin);
@@ -1773,10 +1703,10 @@ participant Bob
 end
 Alice->Bob: Hello Bob, how are you?`;
 
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     expect(bounds.startx).toBe(0);
     expect(bounds.starty).toBe(0);
     expect(bounds.stopx).toBe(conf.width * 2 + conf.actorMargin + conf.boxTextMargin * 2);
@@ -1787,11 +1717,11 @@ Alice->Bob: Hello Bob, how are you?`;
 %%{init: {'logLevel': 0}}%%
 sequenceDiagram
 Alice->Bob: Hello Bob, how are you?`;
-
     await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     const mermaid = mermaidAPI.getConfig();
     expect(mermaid.logLevel).toBe(0);
     expect(bounds.startx).toBe(0);
@@ -1803,16 +1733,15 @@ Alice->Bob: Hello Bob, how are you?`;
     const str = `
 %%{init: { 'logLevel': 0}}%%
 sequenceDiagram
-%%{
-wrap
-}%%
+%%{wrap}%%
 Alice->Bob: Hello Bob, how are you?`;
 
     await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const msgs = diagram.db.getMessages();
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const msgs = diagram1.db.getMessages();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     const mermaid = mermaidAPI.getConfig();
     expect(mermaid.logLevel).toBe(0);
     expect(bounds.startx).toBe(0);
@@ -1828,11 +1757,11 @@ Alice->Bob: Hello Bob, how are you?
 Note over Alice,Bob: Looks
 Note over Bob,Alice: Looks back
 `;
+    const diagram1 = await Diagram.fromText(str);
     // mermaidAPI.initialize({logLevel:0})
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     expect(bounds.startx).toBe(0);
     expect(bounds.starty).toBe(0);
     expect(bounds.stopx).toBe(conf.width * 2 + conf.actorMargin);
@@ -1844,10 +1773,10 @@ sequenceDiagram
 Alice->Bob: Hello Bob, how are you?
 Bob->Alice: Fine!`;
 
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     expect(bounds.startx).toBe(0);
     expect(bounds.starty).toBe(0);
     expect(bounds.stopx).toBe(conf.width * 2 + conf.actorMargin);
@@ -1860,10 +1789,10 @@ Alice->Bob: Hello Bob, how are you?
 Note right of Bob: Bob thinks
 Bob->Alice: Fine!`;
 
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     expect(bounds.startx).toBe(0);
     expect(bounds.starty).toBe(0);
 
@@ -1879,10 +1808,10 @@ Alice->Bob: Hello Bob, how are you?
 Note left of Alice: Bob thinks
 Bob->Alice: Fine!`;
 
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     expect(bounds.startx).toBe(-(conf.width / 2) - conf.actorMargin / 2);
     expect(bounds.starty).toBe(0);
 
@@ -1896,11 +1825,11 @@ Alice->>Bob:wrap: Hello Bob, how are you? If you are not available right now, I
 Note left of Alice: Bob thinks
 Bob->>Alice: Fine!`;
 
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
-    const msgs = diagram.db.getMessages();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
+    const msgs = diagram1.db.getMessages();
     expect(bounds.startx).toBe(-(conf.width / 2) - conf.actorMargin / 2);
     expect(bounds.starty).toBe(0);
     expect(msgs[0].wrap).toBe(true);
@@ -1918,10 +1847,11 @@ Note left of Alice: Bob thinks
 Bob->>Alice: Fine!`;
 
     await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
-    const msgs = diagram.db.getMessages();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
+    const msgs = diagram1.db.getMessages();
     const mermaid = mermaidAPI.getConfig();
     expect(bounds.startx).toBe(-(conf.width / 2) - conf.actorMargin / 2);
     expect(bounds.starty).toBe(0);
@@ -1941,10 +1871,12 @@ Note left of Alice: Bob thinks
 Bob->>Alice: Fine!`;
 
     await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
-    const msgs = diagram.db.getMessages();
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
+
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
+    const msgs = diagram1.db.getMessages();
     const mermaid = mermaidAPI.getConfig();
     expect(bounds.startx).toBe(-(conf.width / 2) - conf.actorMargin / 2);
     expect(bounds.starty).toBe(0);
@@ -1963,10 +1895,11 @@ Note left of Alice: Bob thinks
 Bob->>Alice: Fine!`;
     // mermaidAPI.initialize({ logLevel: 0 });
     await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
-    const msgs = diagram.db.getMessages();
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
+    const msgs = diagram1.db.getMessages();
     const mermaid = mermaidAPI.getConfig();
     expect(bounds.startx).toBe(-(conf.width / 2) - conf.actorMargin / 2);
     expect(bounds.starty).toBe(0);
@@ -1986,10 +1919,10 @@ Alice->Bob: Hello Bob, how are you?
 loop Cheers
 Bob->Alice: Fine!
 end`;
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
 
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     expect(bounds.startx).toBe(0);
     expect(bounds.starty).toBe(0);
 
@@ -2004,9 +1937,9 @@ end`;
           Bob->Alice: I feel surrounded by darkness
         end
     `;
-    await mermaidAPI.parse(str);
-    await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
-    const { bounds, models } = diagram.renderer.bounds.getBounds();
+    const diagram1 = await Diagram.fromText(str);
+    await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
+    const { bounds, models } = diagram1.renderer.bounds.getBounds();
     expect(bounds.startx).toBe(0);
     expect(bounds.starty).toBe(0);
 
@@ -2050,11 +1983,11 @@ describe('when rendering a sequenceDiagram with actor mirror activated', () => {
       const str = `
 sequenceDiagram
 participant Alice`;
-      diagram.renderer.bounds.init();
-      await mermaidAPI.parse(str);
-      await diagram.renderer.draw(str, 'tst', '1.2.3', diagram);
+      const diagram1 = await Diagram.fromText(str);
+      diagram1.renderer.bounds.init();
+      await diagram1.renderer.draw(str, 'tst', '1.2.3', diagram1);
 
-      const { bounds, models } = diagram.renderer.bounds.getBounds();
+      const { bounds, models } = diagram1.renderer.bounds.getBounds();
       expect(bounds.startx).toBe(0);
       expect(bounds.starty).toBe(0);
       expect(bounds.stopx).toBe(conf.width);