Merge branch 'develop' of https://github.com/mermaid-js/mermaid into fix-markdown-labels-6087

on-behalf-of: @Mermaid-Chart <hello@mermaidchart.com>

.changeset/chilly-words-march.md

@@ -1,5 +0,0 @@
----
-'mermaid': patch
----
-
-fix: Correct viewBox casing and make SVGs responsive

.changeset/gold-ducks-sort.md

@@ -0,0 +1,5 @@
+---
+'mermaid': patch
+---
+
+fix: Proper separation between strings and markdown strings

cypress/helpers/util.ts

@@ -99,7 +99,6 @@ export const openURLAndVerifyRendering = (
   cy.visit(url);
   cy.window().should('have.property', 'rendered', true);
   cy.get('svg').should('be.visible');
-  cy.get('svg').should('not.have.attr', 'viewbox');
 
   if (validation) {
     cy.get('svg').should(validation);

cypress/integration/rendering/flowchart-v2.spec.js

@@ -1174,8 +1174,8 @@ end
     end
     githost["Github, Gitlab, BitBucket, etc."]
     githost2["\`Github, Gitlab, BitBucket, etc.\`"]
-    a["1."]
-    b["- x"]
+    a["\`1.\`"]
+    b["\`- x\`"]
       `;
 
     it('should render raw strings', () => {

cypress/integration/rendering/flowchart.spec.js

@@ -1003,4 +1003,49 @@ graph TD
       }
     );
   });
+  it('#5824: should be able to render string and markdown labels', () => {
+    imgSnapshotTest(
+      `
+flowchart TB
+    mermaid{"What is\nyourmermaid version?"} --> v10["<11"] --"\`<**1**1\`"--> fine["No bug"]
+    mermaid --> v11[">= v11"] -- ">= v11" --> broken["Affected by https://github.com/mermaid-js/mermaid/issues/5824"]
+    subgraph subgraph1["\`How to fix **fix**\`"]
+        broken --> B["B"]
+    end
+    githost["Github, Gitlab, BitBucket, etc."]
+    githost2["\`Github, Gitlab, BitBucket, etc.\`"]
+    a["1."]
+    b["- x"]
+    `,
+      {
+        flowchart: { htmlLabels: true },
+        securityLevel: 'loose',
+      }
+    );
+  });
+  it('69: should render subgraphs with adhoc list headings', () => {
+    imgSnapshotTest(
+      `
+    graph TB
+      subgraph "1. first"
+        a1-->a2
+      end
+      subgraph 2. second
+        b1-->b2
+      end
+      `,
+      { fontFamily: 'courier' }
+    );
+  });
+  it('70: should render subgraphs with markdown headings', () => {
+    imgSnapshotTest(
+      `
+    graph TB
+      subgraph "\`**strong**\`"
+        a1-->a2
+      end
+      `,
+      { fontFamily: 'courier' }
+    );
+  });
 });

docs/config/setup/mermaid/interfaces/ParseOptions.md

@@ -10,7 +10,7 @@
 
 # Interface: ParseOptions
 
-Defined in: [packages/mermaid/src/types.ts:88](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L88)
+Defined in: [packages/mermaid/src/types.ts:89](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L89)
 
 ## Properties
 
@@ -18,7 +18,7 @@ Defined in: [packages/mermaid/src/types.ts:88](https://github.com/mermaid-js/mer
 
 > `optional` **suppressErrors**: `boolean`
 
-Defined in: [packages/mermaid/src/types.ts:93](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L93)
+Defined in: [packages/mermaid/src/types.ts:94](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L94)
 
 If `true`, parse will return `false` instead of throwing error when the diagram is invalid.
 The `parseError` function will not be called.

docs/config/setup/mermaid/interfaces/ParseResult.md

@@ -10,7 +10,7 @@
 
 # Interface: ParseResult
 
-Defined in: [packages/mermaid/src/types.ts:96](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L96)
+Defined in: [packages/mermaid/src/types.ts:97](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L97)
 
 ## Properties
 
@@ -18,7 +18,7 @@ Defined in: [packages/mermaid/src/types.ts:96](https://github.com/mermaid-js/mer
 
 > **config**: [`MermaidConfig`](MermaidConfig.md)
 
-Defined in: [packages/mermaid/src/types.ts:104](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L104)
+Defined in: [packages/mermaid/src/types.ts:105](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L105)
 
 The config passed as YAML frontmatter or directives
 
@@ -28,6 +28,6 @@ The config passed as YAML frontmatter or directives
 
 > **diagramType**: `string`
 
-Defined in: [packages/mermaid/src/types.ts:100](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L100)
+Defined in: [packages/mermaid/src/types.ts:101](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L101)
 
 The diagram type, e.g. 'flowchart', 'sequence', etc.

docs/config/setup/mermaid/interfaces/RenderResult.md

@@ -10,7 +10,7 @@
 
 # Interface: RenderResult
 
-Defined in: [packages/mermaid/src/types.ts:114](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L114)
+Defined in: [packages/mermaid/src/types.ts:115](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L115)
 
 ## Properties
 
@@ -18,7 +18,7 @@ Defined in: [packages/mermaid/src/types.ts:114](https://github.com/mermaid-js/me
 
 > `optional` **bindFunctions**: (`element`) => `void`
 
-Defined in: [packages/mermaid/src/types.ts:132](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L132)
+Defined in: [packages/mermaid/src/types.ts:133](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L133)
 
 Bind function to be called after the svg has been inserted into the DOM.
 This is necessary for adding event listeners to the elements in the svg.
@@ -45,7 +45,7 @@ bindFunctions?.(div); // To call bindFunctions only if it's present.
 
 > **diagramType**: `string`
 
-Defined in: [packages/mermaid/src/types.ts:122](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L122)
+Defined in: [packages/mermaid/src/types.ts:123](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L123)
 
 The diagram type, e.g. 'flowchart', 'sequence', etc.
 
@@ -55,6 +55,6 @@ The diagram type, e.g. 'flowchart', 'sequence', etc.
 
 > **svg**: `string`
 
-Defined in: [packages/mermaid/src/types.ts:118](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L118)
+Defined in: [packages/mermaid/src/types.ts:119](https://github.com/mermaid-js/mermaid/blob/master/packages/mermaid/src/types.ts#L119)
 
 The svg code for the rendered graph.

docs/syntax/classDiagram.md

@@ -21,7 +21,7 @@ title: Animal example
 classDiagram
     note "From Duck till Zebra"
     Animal <|-- Duck
-    note for Duck "can fly<br>can swim<br>can dive<br>can help in debugging"
+    note for Duck "can fly\ncan swim\ncan dive\ncan help in debugging"
     Animal <|-- Fish
     Animal <|-- Zebra
     Animal : +int age
@@ -50,7 +50,7 @@ title: Animal example
 classDiagram
     note "From Duck till Zebra"
     Animal <|-- Duck
-    note for Duck "can fly<br>can swim<br>can dive<br>can help in debugging"
+    note for Duck "can fly\ncan swim\ncan dive\ncan help in debugging"
     Animal <|-- Fish
     Animal <|-- Zebra
     Animal : +int age
@@ -287,7 +287,6 @@ To describe the visibility (or encapsulation) of an attribute or method/function
 >
 > - `*` Abstract e.g.: `someAbstractMethod()*` or `someAbstractMethod() int*`
 > - `$` Static e.g.: `someStaticMethod()$` or `someStaticMethod() String$`
-> - `$*` OR `*$` Both e.g: `someAbstractStaticMethod()$*` or `someAbstractStaticMethod() int$*`
 
 > _note_ you can also include additional _classifiers_ to a field definition by adding the following notation to the very end:
 >

packages/mermaid/src/diagrams/class/classDb.ts

@@ -265,10 +265,6 @@ export class ClassDB implements DiagramDB {
         theClass.annotations.push(sanitizeText(memberString.substring(2, memberString.length - 2)));
       } else if (memberString.indexOf(')') > 0) {
         //its a method
-        if (memberString.length < 2) {
-          // Too short to be a method, ignore
-          return;
-        }
         theClass.methods.push(new ClassMember(memberString, 'method'));
       } else if (memberString) {
         theClass.members.push(new ClassMember(memberString, 'attribute'));

packages/mermaid/src/diagrams/class/classTypes.attribute.spec.ts

@@ -1,317 +0,0 @@
-import { ClassMember } from './classTypes.js';
-import { vi, describe, it, expect } from 'vitest';
-const spyOn = vi.spyOn;
-
-const staticCssStyle = 'text-decoration:underline;';
-const abstractCssStyle = 'font-style:italic;';
-const abstractStaticCssStyle = 'text-decoration:underline;font-style:italic;';
-
-describe('ClassTypes - Attribute Tests', () => {
-  describe('Basic attribute parsing without classifiers', () => {
-    it('should parse attribute with no modifiers', () => {
-      const str = 'name String';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('name String');
-      expect(displayDetails.cssStyle).toBe('');
-    });
-
-    it('should parse attribute with public "+" visibility', () => {
-      const str = '+name String';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('+name String');
-      expect(displayDetails.cssStyle).toBe('');
-    });
-
-    it('should parse attribute with protected "#" visibility', () => {
-      const str = '#name String';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('#name String');
-      expect(displayDetails.cssStyle).toBe('');
-    });
-
-    it('should parse attribute with private "-" visibility', () => {
-      const str = '-name String';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('-name String');
-      expect(displayDetails.cssStyle).toBe('');
-    });
-
-    it('should parse attribute with internal "~" visibility', () => {
-      const str = '~name String';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('~name String');
-      expect(displayDetails.cssStyle).toBe('');
-    });
-
-    it('should parse simple attribute name only', () => {
-      const str = 'id';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('id');
-      expect(displayDetails.cssStyle).toBe('');
-    });
-
-    it('should parse attribute with visibility and name only', () => {
-      const str = '+id';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('+id');
-      expect(displayDetails.cssStyle).toBe('');
-    });
-  });
-
-  describe('Static classifier ($) attributes', () => {
-    it('should parse static attribute without visibility', () => {
-      const str = 'count int$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('count int');
-      expect(displayDetails.cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should parse static attribute with public visibility', () => {
-      const str = '+count int$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('+count int');
-      expect(displayDetails.cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should parse static attribute with protected visibility', () => {
-      const str = '#count int$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('#count int');
-      expect(displayDetails.cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should parse static attribute with private visibility', () => {
-      const str = '-count int$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('-count int');
-      expect(displayDetails.cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should parse static attribute with internal visibility', () => {
-      const str = '~count int$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('~count int');
-      expect(displayDetails.cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should parse static attribute name only', () => {
-      const str = 'MAX_SIZE$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('MAX_SIZE');
-      expect(displayDetails.cssStyle).toBe(staticCssStyle);
-    });
-  });
-
-  describe('Abstract classifier (*) attributes', () => {
-    it('should parse abstract attribute without visibility', () => {
-      const str = 'data String*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('data String');
-      expect(displayDetails.cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should parse abstract attribute with public visibility', () => {
-      const str = '+data String*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('+data String');
-      expect(displayDetails.cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should parse abstract attribute with protected visibility', () => {
-      const str = '#data String*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('#data String');
-      expect(displayDetails.cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should parse abstract attribute with private visibility', () => {
-      const str = '-data String*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('-data String');
-      expect(displayDetails.cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should parse abstract attribute with internal visibility', () => {
-      const str = '~data String*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('~data String');
-      expect(displayDetails.cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should parse abstract attribute name only', () => {
-      const str = 'value*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('value');
-      expect(displayDetails.cssStyle).toBe(abstractCssStyle);
-    });
-  });
-
-  describe('Abstract and Static combined classifiers', () => {
-    it('should parse abstract+static ($*) attribute without visibility', () => {
-      const str = 'config Map$*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('config Map');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse static+abstract (*$) attribute without visibility', () => {
-      const str = 'config Map*$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('config Map');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse abstract+static ($*) attribute with public visibility', () => {
-      const str = '+config Map$*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('+config Map');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse static+abstract (*$) attribute with public visibility', () => {
-      const str = '+config Map*$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('+config Map');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse abstract+static ($*) attribute with protected visibility', () => {
-      const str = '#registry HashMap$*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('#registry HashMap');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse static+abstract (*$) attribute with protected visibility', () => {
-      const str = '#registry HashMap*$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('#registry HashMap');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse abstract+static ($*) attribute with private visibility', () => {
-      const str = '-cache LRUCache$*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('-cache LRUCache');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse static+abstract (*$) attribute with private visibility', () => {
-      const str = '-cache LRUCache*$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('-cache LRUCache');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse abstract+static ($*) attribute with internal visibility', () => {
-      const str = '~pool ThreadPool$*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('~pool ThreadPool');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse static+abstract (*$) attribute with internal visibility', () => {
-      const str = '~pool ThreadPool*$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('~pool ThreadPool');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse abstract+static ($*) attribute name only', () => {
-      const str = 'INSTANCE$*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('INSTANCE');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse static+abstract (*$) attribute name only', () => {
-      const str = 'INSTANCE*$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('INSTANCE');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-
-  describe('Complex attribute type scenarios', () => {
-    it('should parse generic type attribute with static classifier', () => {
-      const str = '+items List~String~$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('+items List<String>');
-      expect(displayDetails.cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should parse nested generic type attribute with abstract classifier', () => {
-      const str = '#mapping Map~String, List~Integer~~*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('#mapping Map~String, List<Integer~>');
-      expect(displayDetails.cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should parse complex generic type with abstract+static classifiers', () => {
-      const str = '+factory Function~Map~String, Object~, Promise~Result~~$*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe(
-        '+factory Function<Map>String, Object~, Promise<Result~>'
-      );
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should parse attribute with spaces in type name', () => {
-      const str = '+fullName Full Name String$';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('+fullName Full Name String');
-      expect(displayDetails.cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should parse attribute with special characters in name', () => {
-      const str = '+user_name String*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('+user_name String');
-      expect(displayDetails.cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should parse attribute with numeric suffix', () => {
-      const str = '-value123 int$*';
-      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-      expect(displayDetails.displayText).toBe('-value123 int');
-      expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-});

packages/mermaid/src/diagrams/class/classTypes.classifiers.spec.ts

@@ -1,170 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ClassMember } from './classTypes.js';
-
-describe('ClassTypes - Enhanced Abstract and Static Combinations', () => {
-  // Test constants to match original test structure
-  const staticCssStyle = 'text-decoration:underline;';
-  const abstractCssStyle = 'font-style:italic;';
-  const abstractStaticCssStyle = 'text-decoration:underline;font-style:italic;';
-
-  describe('Enhanced parseClassifier functionality', () => {
-    describe('when the attribute has static "$" modifier', () => {
-      it('should parse the display text correctly and apply static css style', () => {
-        const str = 'name String$';
-
-        const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-        expect(displayDetails.displayText).toBe('name String');
-        expect(displayDetails.cssStyle).toBe(staticCssStyle);
-      });
-    });
-
-    describe('when the attribute has abstract "*" modifier', () => {
-      it('should parse the display text correctly and apply abstract css style', () => {
-        const str = 'name String*';
-
-        const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-        expect(displayDetails.displayText).toBe('name String');
-        expect(displayDetails.cssStyle).toBe(abstractCssStyle);
-      });
-    });
-
-    describe('when the attribute has abstract static "*$" modifier', () => {
-      it('should parse the display text correctly and apply abstract static css style', () => {
-        const str = 'name String*$';
-
-        const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-        expect(displayDetails.displayText).toBe('name String');
-        expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-      });
-    });
-
-    describe('when the attribute has static abstract "$*" modifier', () => {
-      it('should parse the display text correctly and apply abstract static css style', () => {
-        const str = 'name String$*';
-
-        const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
-
-        expect(displayDetails.displayText).toBe('name String');
-        expect(displayDetails.cssStyle).toBe(abstractStaticCssStyle);
-      });
-
-      it('should handle abstract and static combined (*$) on methods', () => {
-        const str = 'getTime()*$';
-        const classMember = new ClassMember(str, 'method');
-        const details = classMember.getDisplayDetails();
-
-        expect(details.displayText).toBe('getTime()');
-        expect(details.cssStyle).toBe(abstractStaticCssStyle);
-      });
-
-      it('should handle static and abstract combined ($*) on methods', () => {
-        const str = 'getTime()$*';
-        const classMember = new ClassMember(str, 'method');
-        const details = classMember.getDisplayDetails();
-
-        expect(details.displayText).toBe('getTime()');
-        expect(details.cssStyle).toBe(abstractStaticCssStyle);
-      });
-
-      it('should handle abstract and static combined (*$) on attributes', () => {
-        const str = 'data String*$';
-        const classMember = new ClassMember(str, 'attribute');
-        const details = classMember.getDisplayDetails();
-
-        expect(details.displayText).toBe('data String');
-        expect(details.cssStyle).toBe(abstractStaticCssStyle);
-      });
-
-      it('should handle static and abstract combined ($*) on attributes', () => {
-        const str = 'data String$*';
-        const classMember = new ClassMember(str, 'attribute');
-        const details = classMember.getDisplayDetails();
-
-        expect(details.displayText).toBe('data String');
-        expect(details.cssStyle).toBe(abstractStaticCssStyle);
-      });
-
-      it('should handle complex method with abstract static combination', () => {
-        const str = '+processData(Map~String, List~Integer~~) Optional~Result~*$';
-        const classMember = new ClassMember(str, 'method');
-        const details = classMember.getDisplayDetails();
-
-        expect(details.displayText).toBe(
-          '+processData(Map~String, List<Integer~>) : Optional<Result>'
-        );
-        expect(details.cssStyle).toBe(abstractStaticCssStyle);
-      });
-
-      it('should handle attribute with visibility and abstract static combination', () => {
-        const str = '#config Settings$*';
-        const classMember = new ClassMember(str, 'attribute');
-        const details = classMember.getDisplayDetails();
-
-        expect(details.displayText).toBe('#config Settings');
-        expect(details.cssStyle).toBe(abstractStaticCssStyle);
-      });
-
-      // Verify existing classifier functionality still works
-      it('should still handle single static classifier correctly', () => {
-        const str = 'getName()$';
-        const classMember = new ClassMember(str, 'method');
-        const details = classMember.getDisplayDetails();
-
-        expect(details.displayText).toBe('getName()');
-        expect(details.cssStyle).toBe(staticCssStyle);
-      });
-
-      it('should still handle single abstract classifier correctly', () => {
-        const str = 'name String*';
-        const classMember = new ClassMember(str, 'attribute');
-        const details = classMember.getDisplayDetails();
-
-        expect(details.displayText).toBe('name String');
-        expect(details.cssStyle).toBe(abstractCssStyle);
-      });
-
-      it('should handle empty classifier correctly', () => {
-        const str = 'getValue()';
-        const classMember = new ClassMember(str, 'method');
-        const details = classMember.getDisplayDetails();
-
-        expect(details.displayText).toBe('getValue()');
-        expect(details.cssStyle).toBe('');
-      });
-    });
-    it('should return correct css for static classifier', function () {
-      const str = `getTime()$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime()');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = `getTime()*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime()');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = `getTime()*$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime()');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = `getTime()$*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime()');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-});

packages/mermaid/src/diagrams/class/classTypes.method.spec.ts

@@ -1,827 +0,0 @@
-import { ClassMember } from './classTypes.js';
-import { vi, describe, it, expect } from 'vitest';
-const spyOn = vi.spyOn;
-
-const staticCssStyle = 'text-decoration:underline;';
-const abstractCssStyle = 'font-style:italic;';
-const abstractStaticCssStyle = 'text-decoration:underline;font-style:italic;';
-
-describe('given text representing a method, ', function () {
-  describe('when method has no parameters', function () {
-    it('should parse correctly', function () {
-      const str = `getTime()`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(str);
-    });
-
-    it('should handle public visibility', function () {
-      const str = `+getTime()`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('+getTime()');
-    });
-
-    it('should handle private visibility', function () {
-      const str = `-getTime()`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('-getTime()');
-    });
-
-    it('should handle protected visibility', function () {
-      const str = `#getTime()`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('#getTime()');
-    });
-
-    it('should handle internal visibility', function () {
-      const str = `~getTime()`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('~getTime()');
-    });
-  });
-
-  describe('when method has single parameter value', function () {
-    it('should parse correctly', function () {
-      const str = `getTime(int)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(str);
-    });
-
-    it('should handle public visibility', function () {
-      const str = `+getTime(int)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('+getTime(int)');
-    });
-
-    it('should handle private visibility', function () {
-      const str = `-getTime(int)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('-getTime(int)');
-    });
-
-    it('should handle protected visibility', function () {
-      const str = `#getTime(int)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('#getTime(int)');
-    });
-
-    it('should handle internal visibility', function () {
-      const str = `~getTime(int)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('~getTime(int)');
-    });
-
-    it('should return correct css for static classifier', function () {
-      const str = `getTime(int)$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = `getTime(int)*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = `getTime(int)*$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = `getTime(int)$*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-
-  describe('when method has single parameter type and name (type first)', function () {
-    it('should parse correctly', function () {
-      const str = `getTime(int count)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(str);
-    });
-
-    it('should handle public visibility', function () {
-      const str = `+getTime(int count)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('+getTime(int count)');
-    });
-
-    it('should handle private visibility', function () {
-      const str = `-getTime(int count)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('-getTime(int count)');
-    });
-
-    it('should handle protected visibility', function () {
-      const str = `#getTime(int count)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('#getTime(int count)');
-    });
-
-    it('should handle internal visibility', function () {
-      const str = `~getTime(int count)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('~getTime(int count)');
-    });
-
-    it('should return correct css for static classifier', function () {
-      const str = `getTime(int count)$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int count)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = `getTime(int count)*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int count)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = `getTime(int count)*$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int count)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = `getTime(int count)$*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int count)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-
-  describe('when method has single parameter type and name (name first)', function () {
-    it('should parse correctly', function () {
-      const str = `getTime(count int)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(str);
-    });
-
-    it('should handle public visibility', function () {
-      const str = `+getTime(count int)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('+getTime(count int)');
-    });
-
-    it('should handle private visibility', function () {
-      const str = `-getTime(count int)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('-getTime(count int)');
-    });
-
-    it('should handle protected visibility', function () {
-      const str = `#getTime(count int)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('#getTime(count int)');
-    });
-
-    it('should handle internal visibility', function () {
-      const str = `~getTime(count int)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('~getTime(count int)');
-    });
-
-    it('should return correct css for static classifier', function () {
-      const str = `getTime(count int)$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(count int)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = `getTime(count int)*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(count int)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = `getTime(count int)*$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(count int)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = `getTime(count int)$*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(count int)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-
-  describe('when method has multiple parameters', function () {
-    it('should parse correctly', function () {
-      const str = `getTime(string text, int count)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(str);
-    });
-
-    it('should handle public visibility', function () {
-      const str = `+getTime(string text, int count)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(str);
-    });
-
-    it('should handle private visibility', function () {
-      const str = `-getTime(string text, int count)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(str);
-    });
-
-    it('should handle protected visibility', function () {
-      const str = `#getTime(string text, int count)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(str);
-    });
-
-    it('should handle internal visibility', function () {
-      const str = `~getTime(string text, int count)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(str);
-    });
-
-    it('should return correct css for static classifier', function () {
-      const str = `getTime(string text, int count)$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(string text, int count)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = `getTime(string text, int count)*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(string text, int count)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = `getTime(string text, int count)*$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(string text, int count)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = `getTime(string text, int count)$*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime(string text, int count)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-
-  describe('when method has return type', function () {
-    it('should parse correctly', function () {
-      const str = `getTime() DateTime`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime() : DateTime');
-    });
-
-    it('should handle public visibility', function () {
-      const str = `+getTime() DateTime`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('+getTime() : DateTime');
-    });
-
-    it('should handle private visibility', function () {
-      const str = `-getTime() DateTime`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('-getTime() : DateTime');
-    });
-
-    it('should handle protected visibility', function () {
-      const str = `#getTime() DateTime`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('#getTime() : DateTime');
-    });
-
-    it('should handle internal visibility', function () {
-      const str = `~getTime() DateTime`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('~getTime() : DateTime');
-    });
-
-    it('should return correct css for static classifier', function () {
-      const str = `getTime() DateTime$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime() : DateTime');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = `getTime()  DateTime*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime() : DateTime');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = `getTime()  DateTime*$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime() : DateTime');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = `getTime()  DateTime$*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTime() : DateTime');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-
-  describe('when method parameter is generic', function () {
-    it('should parse correctly', function () {
-      const str = `getTimes(List~T~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>)');
-    });
-
-    it('should handle public visibility', function () {
-      const str = `+getTimes(List~T~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('+getTimes(List<T>)');
-    });
-
-    it('should handle private visibility', function () {
-      const str = `-getTimes(List~T~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('-getTimes(List<T>)');
-    });
-
-    it('should handle protected visibility', function () {
-      const str = `#getTimes(List~T~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('#getTimes(List<T>)');
-    });
-
-    it('should handle internal visibility', function () {
-      const str = `~getTimes(List~T~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('~getTimes(List<T>)');
-    });
-
-    it('should return correct css for static classifier', function () {
-      const str = `getTimes(List~T~)$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = `getTimes(List~T~)*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = `getTimes(List~T~)*$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = `getTimes(List~T~)$*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-
-  describe('when method parameter contains two generic', function () {
-    it('should parse correctly', function () {
-      const str = `getTimes(List~T~, List~OT~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>, List<OT>)');
-    });
-
-    it('should handle public visibility', function () {
-      const str = `+getTimes(List~T~, List~OT~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('+getTimes(List<T>, List<OT>)');
-    });
-
-    it('should handle private visibility', function () {
-      const str = `-getTimes(List~T~, List~OT~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('-getTimes(List<T>, List<OT>)');
-    });
-
-    it('should handle protected visibility', function () {
-      const str = `#getTimes(List~T~, List~OT~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('#getTimes(List<T>, List<OT>)');
-    });
-
-    it('should handle internal visibility', function () {
-      const str = `~getTimes(List~T~, List~OT~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('~getTimes(List<T>, List<OT>)');
-    });
-
-    it('should return correct css for static classifier', function () {
-      const str = `getTimes(List~T~, List~OT~)$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>, List<OT>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = `getTimes(List~T~, List~OT~)*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>, List<OT>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = `getTimes(List~T~, List~OT~)*$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>, List<OT>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = `getTimes(List~T~, List~OT~)$*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>, List<OT>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-
-  describe('when method parameter is a nested generic', function () {
-    it('should parse correctly', function () {
-      const str = `getTimetableList(List~List~T~~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimetableList(List<List<T>>)');
-    });
-
-    it('should handle public visibility', function () {
-      const str = `+getTimetableList(List~List~T~~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('+getTimetableList(List<List<T>>)');
-    });
-
-    it('should handle private visibility', function () {
-      const str = `-getTimetableList(List~List~T~~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('-getTimetableList(List<List<T>>)');
-    });
-
-    it('should handle protected visibility', function () {
-      const str = `#getTimetableList(List~List~T~~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('#getTimetableList(List<List<T>>)');
-    });
-
-    it('should handle internal visibility', function () {
-      const str = `~getTimetableList(List~List~T~~)`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('~getTimetableList(List<List<T>>)');
-    });
-
-    it('should return correct css for static classifier', function () {
-      const str = `getTimetableList(List~List~T~~)$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimetableList(List<List<T>>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = `getTimetableList(List~List~T~~)*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimetableList(List<List<T>>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = `getTimetableList(List~List~T~~)*$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimetableList(List<List<T>>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = `getTimetableList(List~List~T~~)$*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimetableList(List<List<T>>)');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-
-  describe('when method parameter is a composite generic', function () {
-    const methodNameAndParameters = 'getTimes(List~K, V~)';
-    const expectedMethodNameAndParameters = 'getTimes(List<K, V>)';
-    it('should parse correctly', function () {
-      const str = methodNameAndParameters;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(expectedMethodNameAndParameters);
-    });
-
-    it('should handle public visibility', function () {
-      const str = '+' + methodNameAndParameters;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        '+' + expectedMethodNameAndParameters
-      );
-    });
-
-    it('should handle private visibility', function () {
-      const str = '-' + methodNameAndParameters;
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        '-' + expectedMethodNameAndParameters
-      );
-    });
-
-    it('should handle protected visibility', function () {
-      const str = '#' + methodNameAndParameters;
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        '#' + expectedMethodNameAndParameters
-      );
-    });
-
-    it('should handle internal visibility', function () {
-      const str = '~' + methodNameAndParameters;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        '~' + expectedMethodNameAndParameters
-      );
-    });
-
-    it('should return correct css for static classifier', function () {
-      const str = methodNameAndParameters + '$';
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(expectedMethodNameAndParameters);
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = methodNameAndParameters + '*';
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(expectedMethodNameAndParameters);
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = methodNameAndParameters + '*$';
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(expectedMethodNameAndParameters);
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = methodNameAndParameters + '$*';
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(expectedMethodNameAndParameters);
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-
-  describe('when method return type is generic', function () {
-    it('should parse correctly', function () {
-      const str = `getTimes() List~T~`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes() : List<T>');
-    });
-
-    it('should handle public visibility', function () {
-      const str = `+getTimes() List~T~`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('+getTimes() : List<T>');
-    });
-
-    it('should handle private visibility', function () {
-      const str = `-getTimes() List~T~`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('-getTimes() : List<T>');
-    });
-
-    it('should handle protected visibility', function () {
-      const str = `#getTimes() List~T~`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('#getTimes() : List<T>');
-    });
-
-    it('should handle internal visibility', function () {
-      const str = `~getTimes() List~T~`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('~getTimes() : List<T>');
-    });
-
-    it('should return correct css for static classifier', function () {
-      const str = `getTimes() List~T~$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes() : List<T>');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = `getTimes() List~T~*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes() : List<T>');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = `getTimes() List~T~*$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes() : List<T>');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = `getTimes() List~T~$*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getTimes() : List<T>');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-
-  describe('when method return type is a nested generic', function () {
-    it('should parse correctly', function () {
-      const str = `getTimetableList() List~List~T~~`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        'getTimetableList() : List<List<T>>'
-      );
-    });
-
-    it('should handle public visibility', function () {
-      const str = `+getTimetableList() List~List~T~~`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        '+getTimetableList() : List<List<T>>'
-      );
-    });
-
-    it('should handle private visibility', function () {
-      const str = `-getTimetableList() List~List~T~~`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        '-getTimetableList() : List<List<T>>'
-      );
-    });
-
-    it('should handle protected visibility', function () {
-      const str = `#getTimetableList() List~List~T~~`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        '#getTimetableList() : List<List<T>>'
-      );
-    });
-
-    it('should handle internal visibility', function () {
-      const str = `~getTimetableList() List~List~T~~`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        '~getTimetableList() : List<List<T>>'
-      );
-    });
-
-    it('should return correct css for static classifier', function () {
-      const str = `getTimetableList() List~List~T~~$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        'getTimetableList() : List<List<T>>'
-      );
-      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
-    });
-
-    it('should return correct css for abstract classifier', function () {
-      const str = `getTimetableList() List~List~T~~*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        'getTimetableList() : List<List<T>>'
-      );
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
-    });
-
-    it('should return correct css for abstract static classifier', function () {
-      const str = `getTimetableList() List~List~T~~*$`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        'getTimetableList() : List<List<T>>'
-      );
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-
-    it('should return correct css for static abstract classifier', function () {
-      const str = `getTimetableList() List~List~T~~$*`;
-
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe(
-        'getTimetableList() : List<List<T>>'
-      );
-      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractStaticCssStyle);
-    });
-  });
-});

packages/mermaid/src/diagrams/class/classTypes.spec.ts

@@ -4,9 +4,664 @@ const spyOn = vi.spyOn;
 
 const staticCssStyle = 'text-decoration:underline;';
 const abstractCssStyle = 'font-style:italic;';
-const abstractStaticCssStyle = 'text-decoration:underline;font-style:italic;';
 
 describe('given text representing a method, ', function () {
+  describe('when method has no parameters', function () {
+    it('should parse correctly', function () {
+      const str = `getTime()`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(str);
+    });
+
+    it('should handle public visibility', function () {
+      const str = `+getTime()`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('+getTime()');
+    });
+
+    it('should handle private visibility', function () {
+      const str = `-getTime()`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('-getTime()');
+    });
+
+    it('should handle protected visibility', function () {
+      const str = `#getTime()`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('#getTime()');
+    });
+
+    it('should handle internal visibility', function () {
+      const str = `~getTime()`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('~getTime()');
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = `getTime()$`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime()');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = `getTime()*`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime()');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
+  describe('when method has single parameter value', function () {
+    it('should parse correctly', function () {
+      const str = `getTime(int)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(str);
+    });
+
+    it('should handle public visibility', function () {
+      const str = `+getTime(int)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('+getTime(int)');
+    });
+
+    it('should handle private visibility', function () {
+      const str = `-getTime(int)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('-getTime(int)');
+    });
+
+    it('should handle protected visibility', function () {
+      const str = `#getTime(int)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('#getTime(int)');
+    });
+
+    it('should handle internal visibility', function () {
+      const str = `~getTime(int)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('~getTime(int)');
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = `getTime(int)$`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = `getTime(int)*`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
+  describe('when method has single parameter type and name (type first)', function () {
+    it('should parse correctly', function () {
+      const str = `getTime(int count)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(str);
+    });
+
+    it('should handle public visibility', function () {
+      const str = `+getTime(int count)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('+getTime(int count)');
+    });
+
+    it('should handle private visibility', function () {
+      const str = `-getTime(int count)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('-getTime(int count)');
+    });
+
+    it('should handle protected visibility', function () {
+      const str = `#getTime(int count)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('#getTime(int count)');
+    });
+
+    it('should handle internal visibility', function () {
+      const str = `~getTime(int count)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('~getTime(int count)');
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = `getTime(int count)$`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int count)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = `getTime(int count)*`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime(int count)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
+  describe('when method has single parameter type and name (name first)', function () {
+    it('should parse correctly', function () {
+      const str = `getTime(count int)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(str);
+    });
+
+    it('should handle public visibility', function () {
+      const str = `+getTime(count int)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('+getTime(count int)');
+    });
+
+    it('should handle private visibility', function () {
+      const str = `-getTime(count int)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('-getTime(count int)');
+    });
+
+    it('should handle protected visibility', function () {
+      const str = `#getTime(count int)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('#getTime(count int)');
+    });
+
+    it('should handle internal visibility', function () {
+      const str = `~getTime(count int)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('~getTime(count int)');
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = `getTime(count int)$`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime(count int)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = `getTime(count int)*`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime(count int)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
+  describe('when method has multiple parameters', function () {
+    it('should parse correctly', function () {
+      const str = `getTime(string text, int count)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(str);
+    });
+
+    it('should handle public visibility', function () {
+      const str = `+getTime(string text, int count)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(str);
+    });
+
+    it('should handle private visibility', function () {
+      const str = `-getTime(string text, int count)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(str);
+    });
+
+    it('should handle protected visibility', function () {
+      const str = `#getTime(string text, int count)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(str);
+    });
+
+    it('should handle internal visibility', function () {
+      const str = `~getTime(string text, int count)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(str);
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = `getTime(string text, int count)$`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime(string text, int count)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = `getTime(string text, int count)*`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime(string text, int count)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
+  describe('when method has return type', function () {
+    it('should parse correctly', function () {
+      const str = `getTime() DateTime`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime() : DateTime');
+    });
+
+    it('should handle public visibility', function () {
+      const str = `+getTime() DateTime`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('+getTime() : DateTime');
+    });
+
+    it('should handle private visibility', function () {
+      const str = `-getTime() DateTime`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('-getTime() : DateTime');
+    });
+
+    it('should handle protected visibility', function () {
+      const str = `#getTime() DateTime`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('#getTime() : DateTime');
+    });
+
+    it('should handle internal visibility', function () {
+      const str = `~getTime() DateTime`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('~getTime() : DateTime');
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = `getTime() DateTime$`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime() : DateTime');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = `getTime()  DateTime*`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTime() : DateTime');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
+  describe('when method parameter is generic', function () {
+    it('should parse correctly', function () {
+      const str = `getTimes(List~T~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>)');
+    });
+
+    it('should handle public visibility', function () {
+      const str = `+getTimes(List~T~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('+getTimes(List<T>)');
+    });
+
+    it('should handle private visibility', function () {
+      const str = `-getTimes(List~T~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('-getTimes(List<T>)');
+    });
+
+    it('should handle protected visibility', function () {
+      const str = `#getTimes(List~T~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('#getTimes(List<T>)');
+    });
+
+    it('should handle internal visibility', function () {
+      const str = `~getTimes(List~T~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('~getTimes(List<T>)');
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = `getTimes(List~T~)$`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = `getTimes(List~T~)*`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
+  describe('when method parameter contains two generic', function () {
+    it('should parse correctly', function () {
+      const str = `getTimes(List~T~, List~OT~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>, List<OT>)');
+    });
+
+    it('should handle public visibility', function () {
+      const str = `+getTimes(List~T~, List~OT~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('+getTimes(List<T>, List<OT>)');
+    });
+
+    it('should handle private visibility', function () {
+      const str = `-getTimes(List~T~, List~OT~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('-getTimes(List<T>, List<OT>)');
+    });
+
+    it('should handle protected visibility', function () {
+      const str = `#getTimes(List~T~, List~OT~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('#getTimes(List<T>, List<OT>)');
+    });
+
+    it('should handle internal visibility', function () {
+      const str = `~getTimes(List~T~, List~OT~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('~getTimes(List<T>, List<OT>)');
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = `getTimes(List~T~, List~OT~)$`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>, List<OT>)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = `getTimes(List~T~, List~OT~)*`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimes(List<T>, List<OT>)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
+  describe('when method parameter is a nested generic', function () {
+    it('should parse correctly', function () {
+      const str = `getTimetableList(List~List~T~~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimetableList(List<List<T>>)');
+    });
+
+    it('should handle public visibility', function () {
+      const str = `+getTimetableList(List~List~T~~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('+getTimetableList(List<List<T>>)');
+    });
+
+    it('should handle private visibility', function () {
+      const str = `-getTimetableList(List~List~T~~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('-getTimetableList(List<List<T>>)');
+    });
+
+    it('should handle protected visibility', function () {
+      const str = `#getTimetableList(List~List~T~~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('#getTimetableList(List<List<T>>)');
+    });
+
+    it('should handle internal visibility', function () {
+      const str = `~getTimetableList(List~List~T~~)`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('~getTimetableList(List<List<T>>)');
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = `getTimetableList(List~List~T~~)$`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimetableList(List<List<T>>)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = `getTimetableList(List~List~T~~)*`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimetableList(List<List<T>>)');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
+  describe('when method parameter is a composite generic', function () {
+    const methodNameAndParameters = 'getTimes(List~K, V~)';
+    const expectedMethodNameAndParameters = 'getTimes(List<K, V>)';
+    it('should parse correctly', function () {
+      const str = methodNameAndParameters;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(expectedMethodNameAndParameters);
+    });
+
+    it('should handle public visibility', function () {
+      const str = '+' + methodNameAndParameters;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(
+        '+' + expectedMethodNameAndParameters
+      );
+    });
+
+    it('should handle private visibility', function () {
+      const str = '-' + methodNameAndParameters;
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(
+        '-' + expectedMethodNameAndParameters
+      );
+    });
+
+    it('should handle protected visibility', function () {
+      const str = '#' + methodNameAndParameters;
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(
+        '#' + expectedMethodNameAndParameters
+      );
+    });
+
+    it('should handle internal visibility', function () {
+      const str = '~' + methodNameAndParameters;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(
+        '~' + expectedMethodNameAndParameters
+      );
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = methodNameAndParameters + '$';
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(expectedMethodNameAndParameters);
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = methodNameAndParameters + '*';
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(expectedMethodNameAndParameters);
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
+  describe('when method return type is generic', function () {
+    it('should parse correctly', function () {
+      const str = `getTimes() List~T~`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimes() : List<T>');
+    });
+
+    it('should handle public visibility', function () {
+      const str = `+getTimes() List~T~`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('+getTimes() : List<T>');
+    });
+
+    it('should handle private visibility', function () {
+      const str = `-getTimes() List~T~`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('-getTimes() : List<T>');
+    });
+
+    it('should handle protected visibility', function () {
+      const str = `#getTimes() List~T~`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('#getTimes() : List<T>');
+    });
+
+    it('should handle internal visibility', function () {
+      const str = `~getTimes() List~T~`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('~getTimes() : List<T>');
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = `getTimes() List~T~$`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimes() : List<T>');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = `getTimes() List~T~*`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe('getTimes() : List<T>');
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
+  describe('when method return type is a nested generic', function () {
+    it('should parse correctly', function () {
+      const str = `getTimetableList() List~List~T~~`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(
+        'getTimetableList() : List<List<T>>'
+      );
+    });
+
+    it('should handle public visibility', function () {
+      const str = `+getTimetableList() List~List~T~~`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(
+        '+getTimetableList() : List<List<T>>'
+      );
+    });
+
+    it('should handle private visibility', function () {
+      const str = `-getTimetableList() List~List~T~~`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(
+        '-getTimetableList() : List<List<T>>'
+      );
+    });
+
+    it('should handle protected visibility', function () {
+      const str = `#getTimetableList() List~List~T~~`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(
+        '#getTimetableList() : List<List<T>>'
+      );
+    });
+
+    it('should handle internal visibility', function () {
+      const str = `~getTimetableList() List~List~T~~`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(
+        '~getTimetableList() : List<List<T>>'
+      );
+    });
+
+    it('should return correct css for static classifier', function () {
+      const str = `getTimetableList() List~List~T~~$`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(
+        'getTimetableList() : List<List<T>>'
+      );
+      expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
+    });
+
+    it('should return correct css for abstract classifier', function () {
+      const str = `getTimetableList() List~List~T~~*`;
+
+      const classMember = new ClassMember(str, 'method');
+      expect(classMember.getDisplayDetails().displayText).toBe(
+        'getTimetableList() : List<List<T>>'
+      );
+      expect(classMember.getDisplayDetails().cssStyle).toBe(abstractCssStyle);
+    });
+  });
+
   describe('--uncategorized tests--', function () {
     it('member name should handle double colons', function () {
       const str = `std::map ~int,string~ pMap;`;
@@ -25,82 +680,83 @@ describe('given text representing a method, ', function () {
       expect(classMember.getDisplayDetails().cssStyle).toBe(staticCssStyle);
     });
   });
+});
 
-  describe('Edge Cases and Additional Scenarios', () => {
-    it('should handle method with special characters in name', function () {
-      const str = `operator++(int value)`;
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('operator++(int value)');
-      expect(classMember.id).toBe('operator++');
+describe('given text representing an attribute', () => {
+  describe('when the attribute has no modifiers', () => {
+    it('should parse the display text correctly', () => {
+      const str = 'name String';
+
+      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
+
+      expect(displayDetails.displayText).toBe('name String');
+      expect(displayDetails.cssStyle).toBe('');
     });
+  });
 
-    it('should handle method with numbers in name', function () {
-      const str = `method123(param)`;
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('method123(param)');
-      expect(classMember.id).toBe('method123');
+  describe('when the attribute has public "+" modifier', () => {
+    it('should parse the display text correctly', () => {
+      const str = '+name String';
+
+      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
+
+      expect(displayDetails.displayText).toBe('+name String');
+      expect(displayDetails.cssStyle).toBe('');
     });
+  });
 
-    it('should handle method with underscores and hyphens', function () {
-      const str = `get_user_data(user_id int)`;
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('get_user_data(user_id int)');
-      expect(classMember.id).toBe('get_user_data');
+  describe('when the attribute has protected "#" modifier', () => {
+    it('should parse the display text correctly', () => {
+      const str = '#name String';
+
+      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
+
+      expect(displayDetails.displayText).toBe('#name String');
+      expect(displayDetails.cssStyle).toBe('');
     });
+  });
 
-    it('should handle method with no spaces around parentheses', function () {
-      const str = `method(param)`;
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('method(param)');
+  describe('when the attribute has private "-" modifier', () => {
+    it('should parse the display text correctly', () => {
+      const str = '-name String';
+
+      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
+
+      expect(displayDetails.displayText).toBe('-name String');
+      expect(displayDetails.cssStyle).toBe('');
     });
+  });
 
-    it('should handle method with array parameters', function () {
-      const str = `processArray(int[] numbers)`;
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('processArray(int[] numbers)');
+  describe('when the attribute has internal "~" modifier', () => {
+    it('should parse the display text correctly', () => {
+      const str = '~name String';
+
+      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
+
+      expect(displayDetails.displayText).toBe('~name String');
+      expect(displayDetails.cssStyle).toBe('');
     });
+  });
 
-    it('should handle method with function pointer parameter', function () {
-      const str = `callback(void (*fn)(int))`;
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('callback(void (*fn)(int))');
+  describe('when the attribute has static "$" modifier', () => {
+    it('should parse the display text correctly and apply static css style', () => {
+      const str = 'name String$';
+
+      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
+
+      expect(displayDetails.displayText).toBe('name String');
+      expect(displayDetails.cssStyle).toBe(staticCssStyle);
     });
+  });
 
-    it('should handle method with complex nested generics (HTML encoded)', function () {
-      const str = `process(Map<String, List<Map<Integer, String>>> data)`;
-      const classMember = new ClassMember(str, 'method');
-      // Current behavior: parseGenericTypes converts < > to HTML entities
-      expect(classMember.getDisplayDetails().displayText).toBe('process(Map&gt;&gt; data)');
-    });
+  describe('when the attribute has abstract "*" modifier', () => {
+    it('should parse the display text correctly and apply abstract css style', () => {
+      const str = 'name String*';
 
-    it('should handle method with colon in return type', function () {
-      const str = `getNamespace() std::string`;
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('getNamespace() : std::string');
-    });
+      const displayDetails = new ClassMember(str, 'attribute').getDisplayDetails();
 
-    it('should handle malformed input gracefully - no parentheses', function () {
-      const str = `not_a_method_missing_parentheses`;
-      const classMember = new ClassMember(str, 'method');
-      // This will not match the method regex, so should handle gracefully
-      // But currently throws when parseGenericTypes gets undefined
-      expect(() => classMember.getDisplayDetails()).toThrow();
-    });
-
-    it('should handle empty parameter list with classifier', function () {
-      const str = `emptyMethod()$*`;
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('emptyMethod()');
-      expect(classMember.getDisplayDetails().cssStyle).toBe(
-        'text-decoration:underline;font-style:italic;'
-      );
-    });
-
-    it('should handle method with constructor-like name', function () {
-      const str = `Class()`;
-      const classMember = new ClassMember(str, 'method');
-      expect(classMember.getDisplayDetails().displayText).toBe('Class()');
-      expect(classMember.id).toBe('Class');
+      expect(displayDetails.displayText).toBe('name String');
+      expect(displayDetails.cssStyle).toBe(abstractCssStyle);
     });
   });
 });

packages/mermaid/src/diagrams/class/classTypes.ts

@@ -81,42 +81,64 @@ export class ClassMember {
     let potentialClassifier = '';
 
     if (this.memberType === 'method') {
-      const methodRegEx = /([#+~-])?(.+)\((.*)\)([$*]{0,2})(.*?)([$*]{0,2})$/;
+      const methodRegEx = /([#+~-])?(.+)\((.*)\)([\s$*])?(.*)([$*])?/;
       const match = methodRegEx.exec(input);
       if (match) {
-        this.visibility = (match[1] ? match[1].trim() : '') as Visibility;
-        this.id = match[2].trim();
+        const detectedVisibility = match[1] ? match[1].trim() : '';
+
+        if (visibilityValues.includes(detectedVisibility)) {
+          this.visibility = detectedVisibility as Visibility;
+        }
+
+        this.id = match[2];
         this.parameters = match[3] ? match[3].trim() : '';
         potentialClassifier = match[4] ? match[4].trim() : '';
         this.returnType = match[5] ? match[5].trim() : '';
 
         if (potentialClassifier === '') {
-          potentialClassifier = match[6] ? match[6].trim() : '';
+          const lastChar = this.returnType.substring(this.returnType.length - 1);
+          if (/[$*]/.exec(lastChar)) {
+            potentialClassifier = lastChar;
+            this.returnType = this.returnType.substring(0, this.returnType.length - 1);
+          }
         }
       }
     } else {
-      const fieldRegEx = /([#+~-])?(.*?)([$*]{0,2})$/;
-      const match = fieldRegEx.exec(input);
+      const length = input.length;
+      const firstChar = input.substring(0, 1);
+      const lastChar = input.substring(length - 1);
 
-      if (match) {
-        this.visibility = (match[1] ? match[1].trim() : '') as Visibility;
-        this.id = match[2] ? match[2].trim() : '';
-        potentialClassifier = match[3] ? match[3].trim() : '';
+      if (visibilityValues.includes(firstChar)) {
+        this.visibility = firstChar as Visibility;
       }
+
+      if (/[$*]/.exec(lastChar)) {
+        potentialClassifier = lastChar;
+      }
+
+      this.id = input.substring(
+        this.visibility === '' ? 0 : 1,
+        potentialClassifier === '' ? length : length - 1
+      );
     }
 
     this.classifier = potentialClassifier;
+    // Preserve one space only
+    this.id = this.id.startsWith(' ') ? ' ' + this.id.trim() : this.id.trim();
+
+    const combinedText = `${this.visibility ? '\\' + this.visibility : ''}${parseGenericTypes(this.id)}${this.memberType === 'method' ? `(${parseGenericTypes(this.parameters)})${this.returnType ? ' : ' + parseGenericTypes(this.returnType) : ''}` : ''}`;
+    this.text = combinedText.replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+    if (this.text.startsWith('\\&lt;')) {
+      this.text = this.text.replace('\\&lt;', '~');
+    }
   }
 
   parseClassifier() {
     switch (this.classifier) {
-      case '$':
-        return 'text-decoration:underline;';
       case '*':
         return 'font-style:italic;';
-      case '$*':
-      case '*$':
-        return 'text-decoration:underline;font-style:italic;';
+      case '$':
+        return 'text-decoration:underline;';
       default:
         return '';
     }

packages/mermaid/src/diagrams/flowchart/flowDb.ts

@@ -85,6 +85,17 @@ export class FlowDB implements DiagramDB {
     return common.sanitizeText(txt, this.config);
   }
 
+  private sanitizeNodeLabelType(labelType?: string) {
+    switch (labelType) {
+      case 'markdown':
+      case 'string':
+      case 'text':
+        return labelType;
+      default:
+        return 'markdown';
+    }
+  }
+
   /**
    * Function to lookup domId from id in the graph definition.
    *
@@ -208,6 +219,7 @@ export class FlowDB implements DiagramDB {
 
       if (doc?.label) {
         vertex.text = doc?.label;
+        vertex.labelType = this.sanitizeNodeLabelType(doc?.labelType);
       }
       if (doc?.icon) {
         vertex.icon = doc?.icon;
@@ -267,7 +279,7 @@ export class FlowDB implements DiagramDB {
       if (edge.text.startsWith('"') && edge.text.endsWith('"')) {
         edge.text = edge.text.substring(1, edge.text.length - 1);
       }
-      edge.labelType = linkTextObj.type;
+      edge.labelType = this.sanitizeNodeLabelType(linkTextObj.type);
     }
 
     if (type !== undefined) {
@@ -702,7 +714,7 @@ You have to call mermaid.initialize.`
       title: title.trim(),
       classes: [],
       dir,
-      labelType: _title.type,
+      labelType: this.sanitizeNodeLabelType(_title?.type),
     };
 
     log.info('Adding', subGraph.id, subGraph.nodes, subGraph.dir);
@@ -1012,6 +1024,7 @@ You have to call mermaid.initialize.`
       const baseNode = {
         id: vertex.id,
         label: vertex.text,
+        labelType: vertex.labelType,
         labelStyle: '',
         parentId,
         padding: config.flowchart?.padding || 8,
@@ -1088,6 +1101,7 @@ You have to call mermaid.initialize.`
         id: subGraph.id,
         label: subGraph.title,
         labelStyle: '',
+        labelType: subGraph.labelType,
         parentId: parentDB.get(subGraph.id),
         padding: 8,
         cssCompiledStyles: this.getCompiledStyles(subGraph.classes),
@@ -1119,6 +1133,7 @@ You have to call mermaid.initialize.`
         end: rawEdge.end,
         type: rawEdge.type ?? 'normal',
         label: rawEdge.text,
+        labelType: rawEdge.labelType,
         labelpos: 'c',
         thickness: rawEdge.stroke,
         minlen: rawEdge.length,

packages/mermaid/src/diagrams/flowchart/types.ts

@@ -29,7 +29,7 @@ export interface FlowVertex {
   domId: string;
   haveCallback?: boolean;
   id: string;
-  labelType: 'text';
+  labelType: 'markdown' | 'string' | 'text';
   link?: string;
   linkTarget?: string;
   props?: any;
@@ -62,7 +62,7 @@ export interface FlowEdge {
   style?: string[];
   length?: number;
   text: string;
-  labelType: 'text';
+  labelType: 'markdown' | 'string' | 'text';
   classes: string[];
   id?: string;
   animation?: 'fast' | 'slow';

packages/mermaid/src/diagrams/kanban/kanbanDb.ts

@@ -62,6 +62,7 @@ const getData = function () {
     const node = {
       id: section.id,
       label: sanitizeText(section.label ?? '', conf),
+      labelType: 'markdown',
       isGroup: true,
       ticket: section.ticket,
       shape: 'kanbanSection',
@@ -76,6 +77,7 @@ const getData = function () {
         id: item.id,
         parentId: section.id,
         label: sanitizeText(item.label ?? '', conf),
+        labelType: 'markdown',
         isGroup: false,
         ticket: item?.ticket,
         priority: item?.priority,

packages/mermaid/src/diagrams/mindmap/mindmapDb.ts

@@ -260,6 +260,7 @@ export class MindmapDB {
       id: node.id.toString(),
       domId: 'node_' + node.id.toString(),
       label: node.descr,
+      labelType: 'markdown',
       isGroup: false,
       shape: getShapeFromType(node.type),
       width: node.width,

packages/mermaid/src/diagrams/mindmap/mindmapTypes.ts

@@ -16,6 +16,7 @@ export interface MindmapNode {
   x?: number;
   y?: number;
   isRoot?: boolean;
+  labelType?: string;
 }
 
 export type FilledMindMapNode = RequiredDeep<MindmapNode>;

packages/mermaid/src/diagrams/packet/renderer.ts

@@ -16,7 +16,7 @@ const draw: DrawDefinition = (_text, id, _version, diagram: Diagram) => {
   const svgWidth = bitWidth * bitsPerRow + 2;
   const svg: SVG = selectSvgElement(id);
 
-  svg.attr('viewBox', `0 0 ${svgWidth} ${svgHeight}`);
+  svg.attr('viewbox', `0 0 ${svgWidth} ${svgHeight}`);
   configureSvgSize(svg, svgHeight, svgWidth, config.useMaxWidth);
 
   for (const [word, packet] of words.entries()) {

packages/mermaid/src/diagrams/radar/renderer.ts

@@ -2,7 +2,6 @@ import type { Diagram } from '../../Diagram.js';
 import type { RadarDiagramConfig } from '../../config.type.js';
 import type { DiagramRenderer, DrawDefinition, SVG, SVGGroup } from '../../diagram-api/types.js';
 import { selectSvgElement } from '../../rendering-util/selectSvgElement.js';
-import { configureSvgSize } from '../../setupGraphViewbox.js';
 import type { RadarDB, RadarAxis, RadarCurve } from './types.js';
 
 const draw: DrawDefinition = (_text, id, _version, diagram: Diagram) => {
@@ -54,9 +53,11 @@ const drawFrame = (svg: SVG, config: Required<RadarDiagramConfig>): SVGGroup =>
     x: config.marginLeft + config.width / 2,
     y: config.marginTop + config.height / 2,
   };
-  configureSvgSize(svg, totalHeight, totalWidth, config.useMaxWidth ?? true);
-
-  svg.attr('viewBox', `0 0 ${totalWidth} ${totalHeight}`);
+  // Initialize the SVG
+  svg
+    .attr('viewbox', `0 0 ${totalWidth} ${totalHeight}`)
+    .attr('width', totalWidth)
+    .attr('height', totalHeight);
   // g element to center the radar chart
   return svg.append('g').attr('transform', `translate(${center.x}, ${center.y})`);
 };

packages/mermaid/src/docs/syntax/classDiagram.md

@@ -15,7 +15,7 @@ title: Animal example
 classDiagram
     note "From Duck till Zebra"
     Animal <|-- Duck
-    note for Duck "can fly<br>can swim<br>can dive<br>can help in debugging"
+    note for Duck "can fly\ncan swim\ncan dive\ncan help in debugging"
     Animal <|-- Fish
     Animal <|-- Zebra
     Animal : +int age
@@ -175,7 +175,6 @@ To describe the visibility (or encapsulation) of an attribute or method/function
 >
 > - `*` Abstract e.g.: `someAbstractMethod()*` or `someAbstractMethod() int*`
 > - `$` Static e.g.: `someStaticMethod()$` or `someStaticMethod() String$`
-> - `$*` OR `*$` Both e.g: `someAbstractStaticMethod()$*` or `someAbstractStaticMethod() int$*`
 
 > _note_ you can also include additional _classifiers_ to a field definition by adding the following notation to the very end:
 >

packages/mermaid/src/rendering-util/rendering-elements/clusters.js

@@ -30,11 +30,17 @@ const rect = async (parent, node) => {
   // Create the label and insert it after the rect
   const labelEl = shapeSvg.insert('g').attr('class', 'cluster-label ');
 
-  const text = await createText(labelEl, node.label, {
-    style: node.labelStyle,
-    useHtmlLabels,
-    isNode: true,
-  });
+  let text;
+  if (node.labelType === 'markdown') {
+    text = await createText(labelEl, node.label, {
+      style: node.labelStyle,
+      useHtmlLabels,
+      isNode: true,
+    });
+  } else {
+    const labelElement = await createLabel(node.label, node.labelStyle, false, true);
+    text = labelEl.node()?.appendChild(labelElement);
+  }
 
   // Get the size of the label
   let bbox = text.getBBox();

packages/mermaid/src/rendering-util/rendering-elements/edges.js

@@ -29,7 +29,7 @@ import {
 import rough from 'roughjs';
 import createLabel from './createLabel.js';
 import { addEdgeMarkers } from './edgeMarker.ts';
-import { isLabelStyle, styles2String } from './shapes/handDrawnShapeStyles.js';
+import { isLabelStyle } from './shapes/handDrawnShapeStyles.js';
 
 export const edgeLabels = new Map();
 export const terminalLabels = new Map();
@@ -47,14 +47,16 @@ export const getLabelStyles = (styleArray) => {
 export const insertEdgeLabel = async (elem, edge) => {
   let useHtmlLabels = evaluate(getConfig().flowchart.htmlLabels);
 
-  const { labelStyles } = styles2String(edge);
-  edge.labelStyle = labelStyles;
-  const labelElement = await createText(elem, edge.label, {
-    style: edge.labelStyle,
-    useHtmlLabels,
-    addSvgBackground: true,
-    isNode: false,
-  });
+  const labelElement =
+    edge.labelType === 'markdown'
+      ? await createText(elem, edge.label, {
+          style: getLabelStyles(edge.labelStyle),
+          useHtmlLabels,
+          addSvgBackground: true,
+          isNode: false,
+        })
+      : await createLabel(edge.label, getLabelStyles(edge.labelStyle), undefined, false);
+
   log.info('abc82', edge, edge.labelType);
 
   // Create outer g, edgeLabel, this will be positioned after graph layout

packages/mermaid/src/rendering-util/rendering-elements/shapes/util.ts

@@ -1,3 +1,4 @@
+import createLabel from '../createLabel.js';
 import { createText } from '../../createText.js';
 import type { Node } from '../../types.js';
 import { getConfig } from '../../../diagram-api/diagramAPI.js';
@@ -13,7 +14,7 @@ export const labelHelper = async <T extends SVGGraphicsElement>(
   _classes?: string
 ) => {
   let cssClasses;
-  const useHtmlLabels = node.useHtmlLabels || evaluate(getConfig()?.htmlLabels);
+  const useHtmlLabels = node.useHtmlLabels || evaluate(getConfig()?.flowchart?.htmlLabels);
   if (!_classes) {
     cssClasses = 'node default';
   } else {
@@ -40,14 +41,26 @@ export const labelHelper = async <T extends SVGGraphicsElement>(
     label = typeof node.label === 'string' ? node.label : node.label[0];
   }
 
-  const text = await createText(labelEl, sanitizeText(decodeEntities(label), getConfig()), {
-    useHtmlLabels,
-    width: node.width || getConfig().flowchart?.wrappingWidth,
-    // @ts-expect-error -- This is currently not used. Should this be `classes` instead?
-    cssClasses: 'markdown-node-label',
-    style: node.labelStyle,
-    addSvgBackground: !!node.icon || !!node.img,
-  });
+  let text;
+  if (node.labelType === 'markdown') {
+    text = await createText(labelEl, sanitizeText(decodeEntities(label), getConfig()), {
+      useHtmlLabels,
+      width: node.width || getConfig().flowchart?.wrappingWidth,
+      // @ts-expect-error -- This is currently not used. Should this be `classes` instead?
+      cssClasses: 'markdown-node-label',
+      style: node.labelStyle,
+      addSvgBackground: !!node.icon || !!node.img,
+    });
+  } else {
+    const labelElement = await createLabel(
+      sanitizeText(decodeEntities(label), getConfig()),
+      node.labelStyle,
+      false,
+      true
+    );
+    text = labelEl.node()?.appendChild(labelElement);
+  }
+
   // Get the size of the label
   let bbox = text.getBBox();
   const halfPadding = (node?.padding ?? 0) / 2;

packages/mermaid/src/types.ts

@@ -1,6 +1,7 @@
 export interface NodeMetaData {
   shape?: string;
   label?: string;
+  labelType?: string;
   icon?: string;
   form?: string;
   pos?: 't' | 'b';