fix(deps): update dependency dompurify to ^3.2.7

feat: Optimize bundling to remove shipping package.json inside mermaid's JS bundle.

.changeset/deep-pumas-run.md

@@ -1,5 +0,0 @@
----
-'mermaid': patch
----
-
-chore: Fix mindmap rendering in docs and apply tidytree layout

.changeset/four-eyes-wish.md

@@ -1,5 +0,0 @@
----
-'mermaid': patch
----
-
-fix: Ensure edge label color is applied when using classDef with edge IDs

.changeset/moody-fans-try.md

@@ -1,5 +0,0 @@
----
-'mermaid': patch
----
-
-fix: Resolve gantt chart crash due to invalid array length

.changeset/proud-colts-smell.md

@@ -1,5 +0,0 @@
----
-'mermaid': minor
----
-
-feat: Add IDs in architecture diagrams

.changeset/revert-marked-dependency.md

@@ -1,9 +0,0 @@
----
-'mermaid': patch
----
-
-chore: revert marked dependency from ^15.0.7 to ^16.0.0
-
-- Reverted marked package version to ^16.0.0 for better compatibility
-- This is a dependency update that maintains API compatibility
-- All tests pass with the updated version

.changeset/short-seals-sort.md

@@ -0,0 +1,5 @@
+---
+'mermaid': minor
+---
+
+feat: allow to put notes in namespaces on classDiagram

.cspell/code-terms.txt

@@ -1,3 +1,5 @@
+!viewbox
+# It should be viewBox
 # This file contains coding related terms
 ALPHANUM
 antiscript

.cspell/libraries.txt

@@ -64,6 +64,7 @@ rscratch
 shiki
 Slidev
 sparkline
+speccharts
 sphinxcontrib
 ssim
 stylis

.esbuild/util.ts

@@ -71,6 +71,9 @@ export const getBuildConfig = (options: MermaidBuildOptions): BuildOptions => {
 
   const external: string[] = ['require', 'fs', 'path'];
   const outFileName = getFileName(name, options);
+  const { dependencies, version } = JSON.parse(
+    readFileSync(resolve(__dirname, `../packages/${packageName}/package.json`), 'utf-8')
+  );
   const output: BuildOptions = buildOptions({
     ...rest,
     absWorkingDir: resolve(__dirname, `../packages/${packageName}`),
@@ -82,15 +85,13 @@ export const getBuildConfig = (options: MermaidBuildOptions): BuildOptions => {
     chunkNames: `chunks/${outFileName}/[name]-[hash]`,
     define: {
       // This needs to be stringified for esbuild
-      includeLargeFeatures: `${includeLargeFeatures}`,
+      'injected.includeLargeFeatures': `${includeLargeFeatures}`,
+      'injected.version': `'${version}'`,
       'import.meta.vitest': 'undefined',
     },
   });
 
   if (core) {
-    const { dependencies } = JSON.parse(
-      readFileSync(resolve(__dirname, `../packages/${packageName}/package.json`), 'utf-8')
-    );
     // Core build is used to generate file without bundled dependencies.
     // This is used by downstream projects to bundle dependencies themselves.
     // Ignore dependencies and any dependencies of dependencies

.github/workflows/release.yml

@@ -42,5 +42,4 @@ jobs:
           publish: pnpm changeset:publish
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
           NPM_CONFIG_PROVENANCE: true

.github/workflows/validate-lockfile.yml

@@ -1,7 +1,7 @@
 name: Validate pnpm-lock.yaml
 
 on:
-  pull_request:
+  pull_request_target:
     paths:
       - 'pnpm-lock.yaml'
       - '**/package.json'
@@ -15,13 +15,8 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - uses: pnpm/action-setup@a7487c7e89a18df4991f7f222e4898a00d66ddda # v4.1.0
+          ref: ${{ github.event.pull_request.head.sha }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
 
       - name: Validate pnpm-lock.yaml entries
         id: validate # give this step an ID so we can reference its outputs
@@ -55,16 +50,41 @@ jobs:
             exit 1
           fi
 
+      - name: Find existing lockfile validation comment
+        if: always()
+        uses: peter-evans/find-comment@v3
+        id: find-comment
+        with:
+          issue-number: ${{ github.event.pull_request.number }}
+          comment-author: 'github-actions[bot]'
+          body-includes: 'Lockfile Validation Failed'
+
       - name: Comment on PR if validation failed
         if: failure()
-        uses: peter-evans/create-or-update-comment@v4
+        uses: peter-evans/create-or-update-comment@v5
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           issue-number: ${{ github.event.pull_request.number }}
+          comment-id: ${{ steps.find-comment.outputs.comment-id }}
+          edit-mode: replace
           body: |
+            ❌ **Lockfile Validation Failed**
+
             The following issue(s) were detected:
             ${{ steps.validate.outputs.errors }}
 
             Please address these and push an update.
 
             _Posted automatically by GitHub Actions_
+
+      - name: Delete comment if validation passed
+        if: success() && steps.find-comment.outputs.comment-id != ''
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            await github.rest.issues.deleteComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              comment_id: ${{ steps.find-comment.outputs.comment-id }},
+            });

.vite/build.ts

@@ -78,6 +78,8 @@ export const getBuildConfig = ({ minify, core, watch, entryName }: BuildOptions)
     },
     define: {
       'import.meta.vitest': 'undefined',
+      'injected.includeLargeFeatures': 'true',
+      'injected.version': `'0.0.0'`,
     },
     resolve: {
       extensions: [],
@@ -94,10 +96,6 @@ export const getBuildConfig = ({ minify, core, watch, entryName }: BuildOptions)
       }),
       ...visualizerOptions(packageName, core),
     ],
-    define: {
-      // Needs to be string
-      includeLargeFeatures: 'true',
-    },
   };
 
   if (watch && config.build) {

Dockerfile

@@ -5,7 +5,7 @@ USER 0:0
 RUN corepack enable \
     && corepack enable pnpm
 
-RUN apk add --no-cache git~=2.43.4 \
+RUN apk add --no-cache git~=2.43 \
     && git config --add --system safe.directory /mermaid
 
 ENV NODE_OPTIONS="--max_old_space_size=8192"

cypress/helpers/util.ts

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

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

@@ -562,6 +562,20 @@ class C13["With Città foreign language"]
       `
     );
   });
+  it('should add notes in namespaces', function () {
+    imgSnapshotTest(
+      `
+      classDiagram
+      note "This is a outer note"
+      note for C1 "This is a outer note for C1"
+      namespace Namespace1 {
+        note "This is a inner note"
+        note for C1 "This is a inner note for C1"
+        class C1
+      }
+      `
+    );
+  });
   it('should render a simple class diagram with no members', () => {
     imgSnapshotTest(
       `

cypress/integration/rendering/classDiagram-v3.spec.js

@@ -709,6 +709,20 @@ class C13["With Città foreign language"]
       `
     );
   });
+  it('should add notes in namespaces', function () {
+    imgSnapshotTest(
+      `
+      classDiagram
+      note "This is a outer note"
+      note for C1 "This is a outer note for C1"
+      namespace Namespace1 {
+        note "This is a inner note"
+        note for C1 "This is a inner note for C1"
+        class C1
+      }
+      `
+    );
+  });
   it('should render a simple class diagram with no members', () => {
     imgSnapshotTest(
       `

demos/classchart.html

@@ -184,6 +184,7 @@
       }
       Admin --> Report : generates
     </pre>
+    <hr />
     <pre class="mermaid">
     classDiagram
       namespace Company.Project.Module {
@@ -240,6 +241,20 @@
       Bike --> Square : "Logo Shape"
 
     </pre>
+    <hr />
+    <pre class="mermaid">
+      classDiagram
+        note "This is a outer note"
+        note for Class1 "This is a outer note for Class1"
+        namespace ns {
+          note "This is a inner note"
+          note for Class1 "This is a inner note for Class1"
+          class Class1
+          class Class2
+        }
+    </pre>
+    <hr />
+
     <script type="module">
       import mermaid from './mermaid.esm.mjs';
       mermaid.initialize({

docs/ecosystem/integrations-community.md

@@ -57,6 +57,8 @@ To add an integration to this list, see the [Integrations - create page](./integ
   - [GitHub Writer](https://github.com/ckeditor/github-writer)
   - [SVG diagram generator](https://github.com/SimonKenyonShepard/mermaidjs-github-svg-generator)
 - [GitLab](https://docs.gitlab.com/ee/user/markdown.html#diagrams-and-flowcharts) ✅
+- [GNU Octave](https://octave.org/) ✅
+  - [octave_mermaid_js](https://github.com/CNOCTAVE/octave_mermaid_js) ✅
 - [Mermaid Plugin for JetBrains IDEs](https://plugins.jetbrains.com/plugin/20146-mermaid)
 - [MonsterWriter](https://www.monsterwriter.com/) ✅
 - [Joplin](https://joplinapp.org) ✅
@@ -272,6 +274,7 @@ Communication tools and platforms
   - [reveal.js-mermaid-plugin](https://github.com/ludwick/reveal.js-mermaid-plugin)
 - [Reveal CK](https://github.com/jedcn/reveal-ck)
   - [reveal-ck-mermaid-plugin](https://github.com/tmtm/reveal-ck-mermaid-plugin)
+- [speccharts: Turn your test suites into specification diagrams](https://github.com/arnaudrenaud/speccharts)
 - [Vitepress Plugin](https://github.com/sametcn99/vitepress-mermaid-renderer)
 
 <!--- cspell:ignore Blazorade HueHive --->

docs/ecosystem/mermaid-chart.md

@@ -47,7 +47,7 @@ Try the Ultimate AI, Mermaid, and Visual Diagramming Suite by creating an accoun
 
 ## Plans
 
-- **Free** - A free plan that includes three diagrams.
+- **Free** - A free plan that includes six diagrams.
 
 - **Pro** - A paid plan that includes unlimited diagrams, access to the collaboration feature, and more.
 

docs/syntax/classDiagram.md

@@ -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-layout-elk/package.json

@@ -18,7 +18,9 @@
     "elk",
     "mermaid"
   ],
-  "scripts": {},
+  "scripts": {
+    "clean": "rimraf dist"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/mermaid-js/mermaid"

packages/mermaid-layout-tidy-tree/package.json

@@ -19,7 +19,9 @@
     "mermaid",
     "layout"
   ],
-  "scripts": {},
+  "scripts": {
+    "clean": "rimraf dist"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/mermaid-js/mermaid"

packages/mermaid/CHANGELOG.md

@@ -1,5 +1,30 @@
 # mermaid
 
+## 11.12.1
+
+### Patch Changes
+
+- [#7107](https://github.com/mermaid-js/mermaid/pull/7107) [`cbf8946`](https://github.com/mermaid-js/mermaid/commit/cbf89462acecac7a06f19843e8d48cb137df0753) Thanks [@shubhamparikh2704](https://github.com/shubhamparikh2704)! - fix: Updated the dependency dagre-d3-es to 7.0.13 to fix GHSA-cc8p-78qf-8p7q
+
+## 11.12.0
+
+### Minor Changes
+
+- [#6921](https://github.com/mermaid-js/mermaid/pull/6921) [`764b315`](https://github.com/mermaid-js/mermaid/commit/764b315dc16d0359add7c6b8e3ef7592e9bdc09c) Thanks [@quilicicf](https://github.com/quilicicf)! - feat: Add IDs in architecture diagrams
+
+### Patch Changes
+
+- [#6950](https://github.com/mermaid-js/mermaid/pull/6950) [`a957908`](https://github.com/mermaid-js/mermaid/commit/a9579083bfba367a4f4678547ec37ed7b61b9f5b) Thanks [@shubhamparikh2704](https://github.com/shubhamparikh2704)! - chore: Fix mindmap rendering in docs and apply tidytree layout
+
+- [#6826](https://github.com/mermaid-js/mermaid/pull/6826) [`1d36810`](https://github.com/mermaid-js/mermaid/commit/1d3681053b9168354e48e5763023b6305cd1ca72) Thanks [@darshanr0107](https://github.com/darshanr0107)! - fix: Ensure edge label color is applied when using classDef with edge IDs
+
+- [#6945](https://github.com/mermaid-js/mermaid/pull/6945) [`d318f1a`](https://github.com/mermaid-js/mermaid/commit/d318f1a13cd7429334a29c70e449074ec1cb9f68) Thanks [@darshanr0107](https://github.com/darshanr0107)! - fix: Resolve gantt chart crash due to invalid array length
+
+- [#6918](https://github.com/mermaid-js/mermaid/pull/6918) [`cfe9238`](https://github.com/mermaid-js/mermaid/commit/cfe9238882cbe95416db1feea3112456a71b6aaf) Thanks [@shubhamparikh2704](https://github.com/shubhamparikh2704)! - chore: revert marked dependency from ^15.0.7 to ^16.0.0
+  - Reverted marked package version to ^16.0.0 for better compatibility
+  - This is a dependency update that maintains API compatibility
+  - All tests pass with the updated version
+
 ## 11.11.0
 
 ### Minor Changes

packages/mermaid/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mermaid",
-  "version": "11.11.0",
+  "version": "11.12.1",
   "description": "Markdown-ish syntax for generating flowcharts, mindmaps, sequence diagrams, class diagrams, gantt charts, git graphs and more.",
   "type": "module",
   "module": "./dist/mermaid.core.mjs",
@@ -76,9 +76,9 @@
     "cytoscape-fcose": "^2.2.0",
     "d3": "^7.9.0",
     "d3-sankey": "^0.12.3",
-    "dagre-d3-es": "7.0.11",
+    "dagre-d3-es": "7.0.13",
     "dayjs": "^1.11.18",
-    "dompurify": "^3.2.5",
+    "dompurify": "^3.2.7",
     "katex": "^0.16.22",
     "khroma": "^2.1.0",
     "lodash-es": "^4.17.21",

packages/mermaid/src/diagram-api/diagram-orchestration.ts

@@ -72,7 +72,7 @@ export const addDiagrams = () => {
     }
   );
 
-  if (includeLargeFeatures) {
+  if (injected.includeLargeFeatures) {
     registerLazyLoadedDiagrams(flowchartElk, mindmap, architecture);
   }
 

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

@@ -17,6 +17,7 @@ import type {
   ClassRelation,
   ClassNode,
   ClassNote,
+  ClassNoteMap,
   ClassMap,
   NamespaceMap,
   NamespaceNode,
@@ -33,15 +34,16 @@ const sanitizeText = (txt: string) => common.sanitizeText(txt, getConfig());
 
 export class ClassDB implements DiagramDB {
   private relations: ClassRelation[] = [];
-  private classes = new Map<string, ClassNode>();
+  private classes: ClassMap = new Map<string, ClassNode>();
   private readonly styleClasses = new Map<string, StyleClass>();
-  private notes: ClassNote[] = [];
+  private notes: ClassNoteMap = new Map<string, ClassNote>();
   private interfaces: Interface[] = [];
   // private static classCounter = 0;
   private namespaces = new Map<string, NamespaceNode>();
   private namespaceCounter = 0;
 
-  private functions: any[] = [];
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  private functions: Function[] = [];
 
   constructor() {
     this.functions.push(this.setupToolTips.bind(this));
@@ -124,7 +126,7 @@ export class ClassDB implements DiagramDB {
       annotations: [],
       styles: [],
       domId: MERMAID_DOM_ID_PREFIX + name + '-' + classCounter,
-    } as ClassNode);
+    });
 
     classCounter++;
   }
@@ -155,12 +157,12 @@ export class ClassDB implements DiagramDB {
 
   public clear() {
     this.relations = [];
-    this.classes = new Map();
-    this.notes = [];
+    this.classes = new Map<string, ClassNode>();
+    this.notes = new Map<string, ClassNote>();
     this.interfaces = [];
     this.functions = [];
     this.functions.push(this.setupToolTips.bind(this));
-    this.namespaces = new Map();
+    this.namespaces = new Map<string, NamespaceNode>();
     this.namespaceCounter = 0;
     this.direction = 'TB';
     commonClear();
@@ -178,7 +180,12 @@ export class ClassDB implements DiagramDB {
     return this.relations;
   }
 
-  public getNotes() {
+  public getNote(id: string | number): ClassNote {
+    const key = typeof id === 'number' ? `note${id}` : id;
+    return this.notes.get(key)!;
+  }
+
+  public getNotes(): ClassNoteMap {
     return this.notes;
   }
 
@@ -265,10 +272,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'));
@@ -283,16 +286,19 @@ export class ClassDB implements DiagramDB {
     }
   }
 
-  public addNote(text: string, className: string) {
+  public addNote(text: string, className: string): string {
+    const index = this.notes.size;
     const note = {
-      id: `note${this.notes.length}`,
+      id: `note${index}`,
       class: className,
       text: text,
+      index: index,
     };
-    this.notes.push(note);
+    this.notes.set(note.id, note);
+    return note.id;
   }
 
-  public cleanupLabel(label: string) {
+  public cleanupLabel(label: string): string {
     if (label.startsWith(':')) {
       label = label.substring(1);
     }
@@ -358,7 +364,7 @@ export class ClassDB implements DiagramDB {
     });
   }
 
-  public getTooltip(id: string, namespace?: string) {
+  public getTooltip(id: string, namespace?: string): string | undefined {
     if (namespace && this.namespaces.has(namespace)) {
       return this.namespaces.get(namespace)!.classes.get(id)!.tooltip;
     }
@@ -538,10 +544,11 @@ export class ClassDB implements DiagramDB {
 
     this.namespaces.set(id, {
       id: id,
-      classes: new Map(),
-      children: {},
+      classes: new Map<string, ClassNode>(),
+      notes: new Map<string, ClassNote>(),
+      children: new Map<string, NamespaceNode>(),
       domId: MERMAID_DOM_ID_PREFIX + id + '-' + this.namespaceCounter,
-    } as NamespaceNode);
+    });
 
     this.namespaceCounter++;
   }
@@ -559,16 +566,23 @@ export class ClassDB implements DiagramDB {
    *
    * @param id - ID of the namespace to add
    * @param classNames - IDs of the class to add
+   * @param noteNames - IDs of the notes to add
    * @public
    */
-  public addClassesToNamespace(id: string, classNames: string[]) {
+  public addClassesToNamespace(id: string, classNames: string[], noteNames: string[]) {
     if (!this.namespaces.has(id)) {
       return;
     }
     for (const name of classNames) {
       const { className } = this.splitClassNameAndType(name);
-      this.classes.get(className)!.parent = id;
-      this.namespaces.get(id)!.classes.set(className, this.classes.get(className)!);
+      const classNode = this.getClass(className);
+      classNode.parent = id;
+      this.namespaces.get(id)!.classes.set(className, classNode);
+    }
+    for (const noteName of noteNames) {
+      const noteNode = this.getNote(noteName);
+      noteNode.parent = id;
+      this.namespaces.get(id)!.notes.set(noteName, noteNode);
     }
   }
 
@@ -621,36 +635,32 @@ export class ClassDB implements DiagramDB {
     const edges: Edge[] = [];
     const config = getConfig();
 
-    for (const namespaceKey of this.namespaces.keys()) {
-      const namespace = this.namespaces.get(namespaceKey);
-      if (namespace) {
-        const node: Node = {
-          id: namespace.id,
-          label: namespace.id,
-          isGroup: true,
-          padding: config.class!.padding ?? 16,
-          // parent node must be one of [rect, roundedWithTitle, noteGroup, divider]
-          shape: 'rect',
-          cssStyles: [],
-          look: config.look,
-        };
-        nodes.push(node);
-      }
+    for (const namespace of this.namespaces.values()) {
+      const node: Node = {
+        id: namespace.id,
+        label: namespace.id,
+        isGroup: true,
+        padding: config.class!.padding ?? 16,
+        // parent node must be one of [rect, roundedWithTitle, noteGroup, divider]
+        shape: 'rect',
+        cssStyles: [],
+        look: config.look,
+      };
+      nodes.push(node);
     }
 
-    for (const classKey of this.classes.keys()) {
-      const classNode = this.classes.get(classKey);
-      if (classNode) {
-        const node = classNode as unknown as Node;
-        node.parentId = classNode.parent;
-        node.look = config.look;
-        nodes.push(node);
-      }
+    for (const classNode of this.classes.values()) {
+      const node: Node = {
+        ...classNode,
+        type: undefined,
+        isGroup: false,
+        parentId: classNode.parent,
+        look: config.look,
+      };
+      nodes.push(node);
     }
 
-    let cnt = 0;
-    for (const note of this.notes) {
-      cnt++;
+    for (const note of this.notes.values()) {
       const noteNode: Node = {
         id: note.id,
         label: note.text,
@@ -664,14 +674,15 @@ export class ClassDB implements DiagramDB {
           `stroke: ${config.themeVariables.noteBorderColor}`,
         ],
         look: config.look,
+        parentId: note.parent,
       };
       nodes.push(noteNode);
 
-      const noteClassId = this.classes.get(note.class)?.id ?? '';
+      const noteClassId = this.classes.get(note.class)?.id;
 
       if (noteClassId) {
         const edge: Edge = {
-          id: `edgeNote${cnt}`,
+          id: `edgeNote${note.index}`,
           start: note.id,
           end: noteClassId,
           type: 'normal',
@@ -701,7 +712,7 @@ export class ClassDB implements DiagramDB {
       nodes.push(interfaceNode);
     }
 
-    cnt = 0;
+    let cnt = 0;
     for (const classRelation of this.relations) {
       cnt++;
       const edge: Edge = {

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

@@ -417,7 +417,7 @@ class C13["With Città foreign language"]
                      note "This is a keyword: ${keyword}. It truly is."
                   `;
       parser.parse(str);
-      expect(classDb.getNotes()[0].text).toEqual(`This is a keyword: ${keyword}. It truly is.`);
+      expect(classDb.getNote(0).text).toEqual(`This is a keyword: ${keyword}. It truly is.`);
     });
 
     it.each(keywords)(
@@ -427,7 +427,7 @@ class C13["With Città foreign language"]
                       note "${keyword}"`;
 
         parser.parse(str);
-        expect(classDb.getNotes()[0].text).toEqual(`${keyword}`);
+        expect(classDb.getNote(0).text).toEqual(`${keyword}`);
       }
     );
 
@@ -441,7 +441,7 @@ class C13["With Città foreign language"]
                    `;
 
       parser.parse(str);
-      expect(classDb.getNotes()[0].text).toEqual(`This is a keyword: ${keyword}. It truly is.`);
+      expect(classDb.getNote(0).text).toEqual(`This is a keyword: ${keyword}. It truly is.`);
     });
 
     it.each(keywords)(
@@ -456,7 +456,7 @@ class C13["With Città foreign language"]
                     `;
 
         parser.parse(str);
-        expect(classDb.getNotes()[0].text).toEqual(`${keyword}`);
+        expect(classDb.getNote(0).text).toEqual(`${keyword}`);
       }
     );
 

packages/mermaid/src/diagrams/class/classRenderer-v2.ts

@@ -8,7 +8,7 @@ import utils, { getEdgeId } from '../../utils.js';
 import { interpolateToCurve, getStylesFromArray } from '../../utils.js';
 import { setupGraphViewbox } from '../../setupGraphViewbox.js';
 import common from '../common/common.js';
-import type { ClassRelation, ClassNote, ClassMap, NamespaceMap } from './classTypes.js';
+import type { ClassRelation, ClassMap, ClassNoteMap, NamespaceMap } from './classTypes.js';
 import type { EdgeData } from '../../types.js';
 
 const sanitizeText = (txt: string) => common.sanitizeText(txt, getConfig());
@@ -65,6 +65,9 @@ export const addNamespaces = function (
 
     g.setNode(vertex.id, node);
     addClasses(vertex.classes, g, _id, diagObj, vertex.id);
+    const classes: ClassMap = diagObj.db.getClasses();
+    const relations: ClassRelation[] = diagObj.db.getRelations();
+    addNotes(vertex.notes, g, relations.length + 1, classes, vertex.id);
 
     log.info('setNode', node);
   });
@@ -144,69 +147,74 @@ export const addClasses = function (
  * @param classes - Classes
  */
 export const addNotes = function (
-  notes: ClassNote[],
+  notes: ClassNoteMap,
   g: graphlib.Graph,
   startEdgeId: number,
-  classes: ClassMap
+  classes: ClassMap,
+  parent?: string
 ) {
   log.info(notes);
 
-  notes.forEach(function (note, i) {
-    const vertex = note;
+  [...notes.values()]
+    .filter((note) => note.parent === parent)
+    .forEach(function (vertex) {
+      const cssNoteStr = '';
 
-    const cssNoteStr = '';
+      const styles = { labelStyle: '', style: '' };
 
-    const styles = { labelStyle: '', style: '' };
+      const vertexText = vertex.text;
 
-    const vertexText = vertex.text;
+      const radius = 0;
+      const shape = 'note';
+      const node = {
+        labelStyle: styles.labelStyle,
+        shape: shape,
+        labelText: sanitizeText(vertexText),
+        noteData: vertex,
+        rx: radius,
+        ry: radius,
+        class: cssNoteStr,
+        style: styles.style,
+        id: vertex.id,
+        domId: vertex.id,
+        tooltip: '',
+        type: 'note',
+        // TODO V10: Flowchart ? Keeping flowchart for backwards compatibility. Remove in next major release
+        padding: getConfig().flowchart?.padding ?? getConfig().class?.padding,
+      };
+      g.setNode(vertex.id, node);
+      log.info('setNode', node);
 
-    const radius = 0;
-    const shape = 'note';
-    const node = {
-      labelStyle: styles.labelStyle,
-      shape: shape,
-      labelText: sanitizeText(vertexText),
-      noteData: vertex,
-      rx: radius,
-      ry: radius,
-      class: cssNoteStr,
-      style: styles.style,
-      id: vertex.id,
-      domId: vertex.id,
-      tooltip: '',
-      type: 'note',
-      // TODO V10: Flowchart ? Keeping flowchart for backwards compatibility. Remove in next major release
-      padding: getConfig().flowchart?.padding ?? getConfig().class?.padding,
-    };
-    g.setNode(vertex.id, node);
-    log.info('setNode', node);
+      if (parent) {
+        g.setParent(vertex.id, parent);
+      }
 
-    if (!vertex.class || !classes.has(vertex.class)) {
-      return;
-    }
-    const edgeId = startEdgeId + i;
+      if (!vertex.class || !classes.has(vertex.class)) {
+        return;
+      }
+      const edgeId = startEdgeId + vertex.index;
 
-    const edgeData: EdgeData = {
-      id: `edgeNote${edgeId}`,
-      //Set relationship style and line type
-      classes: 'relation',
-      pattern: 'dotted',
-      // Set link type for rendering
-      arrowhead: 'none',
-      //Set edge extra labels
-      startLabelRight: '',
-      endLabelLeft: '',
-      //Set relation arrow types
-      arrowTypeStart: 'none',
-      arrowTypeEnd: 'none',
-      style: 'fill:none',
-      labelStyle: '',
-      curve: interpolateToCurve(conf.curve, curveLinear),
-    };
+      const edgeData: EdgeData = {
+        id: `edgeNote${edgeId}`,
+        //Set relationship style and line type
+        classes: 'relation',
+        pattern: 'dotted',
+        // Set link type for rendering
+        arrowhead: 'none',
+        //Set edge extra labels
+        startLabelRight: '',
+        endLabelLeft: '',
+        //Set relation arrow types
+        arrowTypeStart: 'none',
+        arrowTypeEnd: 'none',
+        style: 'fill:none',
+        labelStyle: '',
+        curve: interpolateToCurve(conf.curve, curveLinear),
+      };
 
-    // Add the edge to the graph
-    g.setEdge(vertex.id, vertex.class, edgeData, edgeId);
-  });
+      // Add the edge to the graph
+      g.setEdge(vertex.id, vertex.class, edgeData, edgeId);
+    });
 };
 
 /**
@@ -329,7 +337,7 @@ export const draw = async function (text: string, id: string, _version: string,
   const namespaces: NamespaceMap = diagObj.db.getNamespaces();
   const classes: ClassMap = diagObj.db.getClasses();
   const relations: ClassRelation[] = diagObj.db.getRelations();
-  const notes: ClassNote[] = diagObj.db.getNotes();
+  const notes: ClassNoteMap = diagObj.db.getNotes();
   log.info(relations);
   addNamespaces(namespaces, g, id, diagObj);
   addClasses(classes, g, id, diagObj);

packages/mermaid/src/diagrams/class/classRenderer.js

@@ -206,7 +206,7 @@ export const draw = function (text, id, _version, diagObj) {
     );
   });
 
-  const notes = diagObj.db.getNotes();
+  const notes = diagObj.db.getNotes().values();
   notes.forEach(function (note) {
     log.debug(`Adding note: ${JSON.stringify(note)}`);
     const node = svgDraw.drawNote(diagram, note, conf, diagObj);

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

@@ -5,7 +5,7 @@ export interface ClassNode {
   id: string;
   type: string;
   label: string;
-  shape: string;
+  shape: 'classBox';
   text: string;
   cssClasses: string;
   methods: ClassMember[];
@@ -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 '';
     }
@@ -127,6 +149,8 @@ export interface ClassNote {
   id: string;
   class: string;
   text: string;
+  index: number;
+  parent?: string;
 }
 
 export interface ClassRelation {
@@ -155,6 +179,7 @@ export interface NamespaceNode {
   id: string;
   domId: string;
   classes: ClassMap;
+  notes: ClassNoteMap;
   children: NamespaceMap;
 }
 
@@ -165,4 +190,5 @@ export interface StyleClass {
 }
 
 export type ClassMap = Map<string, ClassNode>;
+export type ClassNoteMap = Map<string, ClassNote>;
 export type NamespaceMap = Map<string, NamespaceNode>;

packages/mermaid/src/diagrams/class/parser/classDiagram.jison

@@ -275,8 +275,8 @@ statement
     ;
 
 namespaceStatement
-    : namespaceIdentifier STRUCT_START classStatements STRUCT_STOP          { yy.addClassesToNamespace($1, $3); }
-    | namespaceIdentifier STRUCT_START NEWLINE classStatements STRUCT_STOP  { yy.addClassesToNamespace($1, $4); }
+    : namespaceIdentifier STRUCT_START classStatements STRUCT_STOP          { yy.addClassesToNamespace($1, $3[0], $3[1]); }
+    | namespaceIdentifier STRUCT_START NEWLINE classStatements STRUCT_STOP  { yy.addClassesToNamespace($1, $4[0], $4[1]); }
     ;
 
 namespaceIdentifier
@@ -284,9 +284,12 @@ namespaceIdentifier
     ;
 
 classStatements
-    : classStatement                            {$$=[$1]}
-    | classStatement NEWLINE                    {$$=[$1]}
-    | classStatement NEWLINE classStatements    {$3.unshift($1); $$=$3}
+    : classStatement                            {$$=[[$1], []]}
+    | classStatement NEWLINE                    {$$=[[$1], []]}
+    | classStatement NEWLINE classStatements    {$3[0].unshift($1); $$=$3}
+    | noteStatement                             {$$=[[], [$1]]}
+    | noteStatement NEWLINE                     {$$=[[], [$1]]}
+    | noteStatement NEWLINE classStatements     {$3[1].unshift($1); $$=$3}
     ;
 
 classStatement
@@ -333,8 +336,8 @@ relationStatement
     ;
 
 noteStatement
-    : NOTE_FOR className noteText  { yy.addNote($3, $2); }
-    | NOTE noteText                { yy.addNote($2); }
+    : NOTE_FOR className noteText  { $$ = yy.addNote($3, $2); }
+    | NOTE noteText                { $$ = yy.addNote($2); }
     ;
 
 classDefStatement

packages/mermaid/src/diagrams/common/common.ts

@@ -333,7 +333,7 @@ const renderKatexUnsanitized = async (text: string, config: MermaidConfig): Prom
     return text.replace(katexRegex, 'MathML is unsupported in this environment.');
   }
 
-  if (includeLargeFeatures) {
+  if (injected.includeLargeFeatures) {
     const { default: katex } = await import('katex');
     const outputMode =
       config.forceLegacyMathML || (!isMathMLSupported() && config.legacyMathML)

packages/mermaid/src/diagrams/info/infoDb.ts

@@ -1,8 +1,7 @@
 import type { InfoFields, InfoDB } from './infoTypes.js';
-import packageJson from '../../../package.json' assert { type: 'json' };
 
 export const DEFAULT_INFO_DB: InfoFields = {
-  version: packageJson.version + (includeLargeFeatures ? '' : '-tiny'),
+  version: injected.version + (injected.includeLargeFeatures ? '' : '-tiny'),
 } as const;
 
 export const getVersion = (): string => DEFAULT_INFO_DB.version;

packages/mermaid/src/docs/.vitepress/config.ts

@@ -1,6 +1,6 @@
 import type { MarkdownOptions } from 'vitepress';
 import { defineConfig } from 'vitepress';
-import packageJson from '../../../package.json' assert { type: 'json' };
+import packageJson from '../../../package.json' with { type: 'json' };
 import { addCanonicalUrls } from './canonical-urls.js';
 import MermaidExample from './mermaid-markdown-all.js';
 

packages/mermaid/src/docs/ecosystem/integrations-community.md

@@ -52,6 +52,8 @@ To add an integration to this list, see the [Integrations - create page](./integ
   - [GitHub Writer](https://github.com/ckeditor/github-writer)
   - [SVG diagram generator](https://github.com/SimonKenyonShepard/mermaidjs-github-svg-generator)
 - [GitLab](https://docs.gitlab.com/ee/user/markdown.html#diagrams-and-flowcharts) ✅
+- [GNU Octave](https://octave.org/) ✅
+  - [octave_mermaid_js](https://github.com/CNOCTAVE/octave_mermaid_js) ✅
 - [Mermaid Plugin for JetBrains IDEs](https://plugins.jetbrains.com/plugin/20146-mermaid)
 - [MonsterWriter](https://www.monsterwriter.com/) ✅
 - [Joplin](https://joplinapp.org) ✅
@@ -267,6 +269,7 @@ Communication tools and platforms
   - [reveal.js-mermaid-plugin](https://github.com/ludwick/reveal.js-mermaid-plugin)
 - [Reveal CK](https://github.com/jedcn/reveal-ck)
   - [reveal-ck-mermaid-plugin](https://github.com/tmtm/reveal-ck-mermaid-plugin)
+- [speccharts: Turn your test suites into specification diagrams](https://github.com/arnaudrenaud/speccharts)
 - [Vitepress Plugin](https://github.com/sametcn99/vitepress-mermaid-renderer)
 
 <!--- cspell:ignore Blazorade HueHive --->

packages/mermaid/src/docs/ecosystem/mermaid-chart.md

@@ -41,7 +41,7 @@ Try the Ultimate AI, Mermaid, and Visual Diagramming Suite by creating an accoun
 
 ## Plans
 
-- **Free** - A free plan that includes three diagrams.
+- **Free** - A free plan that includes six diagrams.
 
 - **Pro** - A paid plan that includes unlimited diagrams, access to the collaboration feature, and more.
 

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

@@ -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/mermaidAPI.ts

@@ -7,7 +7,6 @@ import { select } from 'd3';
 import { compile, serialize, stringify } from 'stylis';
 import DOMPurify from 'dompurify';
 import isEmpty from 'lodash-es/isEmpty.js';
-import packageJson from '../package.json' assert { type: 'json' };
 import { addSVGa11yTitleDescription, setA11yDiagramInfo } from './accessibility.js';
 import assignWithDepth from './assignWithDepth.js';
 import * as configApi from './config.js';
@@ -421,12 +420,12 @@ const render = async function (
   // -------------------------------------------------------------------------------
   // Draw the diagram with the renderer
   try {
-    await diag.renderer.draw(text, id, packageJson.version, diag);
+    await diag.renderer.draw(text, id, injected.version, diag);
   } catch (e) {
     if (config.suppressErrorRendering) {
       removeTempElements();
     } else {
-      errorRenderer.draw(text, id, packageJson.version);
+      errorRenderer.draw(text, id, injected.version);
     }
     throw e;
   }

packages/mermaid/src/rendering-util/render.ts

@@ -42,7 +42,7 @@ const registerDefaultLayoutLoaders = () => {
       name: 'dagre',
       loader: async () => await import('./layout-algorithms/dagre/index.js'),
     },
-    ...(includeLargeFeatures
+    ...(injected.includeLargeFeatures
       ? [
           {
             name: 'cose-bilkent',

packages/mermaid/src/type.d.ts

@@ -1,2 +1,5 @@
 // eslint-disable-next-line no-var
-declare var includeLargeFeatures: boolean;
+declare var injected: {
+  version: string;
+  includeLargeFeatures: boolean;
+};

packages/parser/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @mermaid-js/parser
 
+## 0.6.3
+
+### Patch Changes
+
+- [#7051](https://github.com/mermaid-js/mermaid/pull/7051) [`63df702`](https://github.com/mermaid-js/mermaid/commit/63df7021462e8dc1f2aaecb9c5febbbbde4c38e3) Thanks [@shubhamparikh2704](https://github.com/shubhamparikh2704)! - Add validation for negative values in pie charts:
+
+  Prevents crashes during parsing by validating values post-parsing.
+
+  Provides clearer, user-friendly error messages for invalid negative inputs.
+
 ## 0.6.2
 
 ### Patch Changes

packages/parser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mermaid-js/parser",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "MermaidJS parser",
   "author": "Yokozuna59",
   "contributors": [

packages/tiny/CHANGELOG.md

@@ -1,5 +1,30 @@
 # mermaid
 
+## 11.12.1
+
+### Patch Changes
+
+- [#7107](https://github.com/mermaid-js/mermaid/pull/7107) [`cbf8946`](https://github.com/mermaid-js/mermaid/commit/cbf89462acecac7a06f19843e8d48cb137df0753) Thanks [@shubhamparikh2704](https://github.com/shubhamparikh2704)! - fix: Updated the dependency dagre-d3-es to 7.0.13 to fix GHSA-cc8p-78qf-8p7q
+
+## 11.12.0
+
+### Minor Changes
+
+- [#6921](https://github.com/mermaid-js/mermaid/pull/6921) [`764b315`](https://github.com/mermaid-js/mermaid/commit/764b315dc16d0359add7c6b8e3ef7592e9bdc09c) Thanks [@quilicicf](https://github.com/quilicicf)! - feat: Add IDs in architecture diagrams
+
+### Patch Changes
+
+- [#6950](https://github.com/mermaid-js/mermaid/pull/6950) [`a957908`](https://github.com/mermaid-js/mermaid/commit/a9579083bfba367a4f4678547ec37ed7b61b9f5b) Thanks [@shubhamparikh2704](https://github.com/shubhamparikh2704)! - chore: Fix mindmap rendering in docs and apply tidytree layout
+
+- [#6826](https://github.com/mermaid-js/mermaid/pull/6826) [`1d36810`](https://github.com/mermaid-js/mermaid/commit/1d3681053b9168354e48e5763023b6305cd1ca72) Thanks [@darshanr0107](https://github.com/darshanr0107)! - fix: Ensure edge label color is applied when using classDef with edge IDs
+
+- [#6945](https://github.com/mermaid-js/mermaid/pull/6945) [`d318f1a`](https://github.com/mermaid-js/mermaid/commit/d318f1a13cd7429334a29c70e449074ec1cb9f68) Thanks [@darshanr0107](https://github.com/darshanr0107)! - fix: Resolve gantt chart crash due to invalid array length
+
+- [#6918](https://github.com/mermaid-js/mermaid/pull/6918) [`cfe9238`](https://github.com/mermaid-js/mermaid/commit/cfe9238882cbe95416db1feea3112456a71b6aaf) Thanks [@shubhamparikh2704](https://github.com/shubhamparikh2704)! - chore: revert marked dependency from ^15.0.7 to ^16.0.0
+  - Reverted marked package version to ^16.0.0 for better compatibility
+  - This is a dependency update that maintains API compatibility
+  - All tests pass with the updated version
+
 ## 11.11.0
 
 ### Minor Changes

packages/tiny/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mermaid-js/tiny",
-  "version": "11.11.0",
+  "version": "11.12.1",
   "description": "Tiny version of mermaid",
   "type": "commonjs",
   "main": "./dist/mermaid.tiny.js",

pnpm-lock.yaml

@@ -251,14 +251,14 @@ importers:
         specifier: ^0.12.3
         version: 0.12.3
       dagre-d3-es:
-        specifier: 7.0.11
-        version: 7.0.11
+        specifier: 7.0.13
+        version: 7.0.13
       dayjs:
         specifier: ^1.11.18
         version: 1.11.18
       dompurify:
-        specifier: ^3.2.5
-        version: 3.2.6
+        specifier: ^3.2.7
+        version: 3.3.0
       katex:
         specifier: ^0.16.22
         version: 0.16.22
@@ -4900,8 +4900,8 @@ packages:
     resolution: {integrity: sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA==}
     engines: {node: '>=12'}
 
-  dagre-d3-es@7.0.11:
-    resolution: {integrity: sha512-tvlJLyQf834SylNKax8Wkzco/1ias1OPw8DcUMDE7oUIoSEW25riQVuiu/0OWEFqT0cxHT3Pa9/D82Jr47IONw==}
+  dagre-d3-es@7.0.13:
+    resolution: {integrity: sha512-efEhnxpSuwpYOKRm/L5KbqoZmNNukHa/Flty4Wp62JRvgH2ojwVgPgdYyr4twpieZnyRDdIH7PY2mopX26+j2Q==}
 
   dashdash@1.14.1:
     resolution: {integrity: sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==}
@@ -5166,8 +5166,8 @@ packages:
     resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==}
     engines: {node: '>= 4'}
 
-  dompurify@3.2.6:
-    resolution: {integrity: sha512-/2GogDQlohXPZe6D6NOgQvXLPSYBqIWMnZ8zzOhn09REE4eyAzb+Hed3jhoM9OkuaJ8P6ZGTTVWQKAi8ieIzfQ==}
+  dompurify@3.3.0:
+    resolution: {integrity: sha512-r+f6MYR1gGN1eJv0TVQbhA7if/U7P87cdPl3HN5rikqaBSBxLiCb/b9O+2eG0cxz0ghyU+mU1QkbsOwERMYlWQ==}
 
   domutils@3.2.2:
     resolution: {integrity: sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==}
@@ -13803,7 +13803,7 @@ snapshots:
       class-variance-authority: 0.7.1
       clsx: 2.1.1
       color-string: 2.1.2
-      dompurify: 3.2.6
+      dompurify: 3.3.0
       highlight.js: 10.7.3
       html-to-image: 1.11.13
       immer: 10.1.3
@@ -15161,7 +15161,7 @@ snapshots:
       d3-transition: 3.0.1(d3-selection@3.0.0)
       d3-zoom: 3.0.0
 
-  dagre-d3-es@7.0.11:
+  dagre-d3-es@7.0.13:
     dependencies:
       d3: 7.9.0
       lodash-es: 4.17.21
@@ -15416,7 +15416,7 @@ snapshots:
     dependencies:
       domelementtype: 2.3.0
 
-  dompurify@3.2.6:
+  dompurify@3.3.0:
     optionalDependencies:
       '@types/trusted-types': 2.0.7
 

vite.config.ts

@@ -35,7 +35,8 @@ export default defineConfig({
   },
   define: {
     // Needs to be string
-    includeLargeFeatures: 'true',
+    'injected.includeLargeFeatures': 'true',
     'import.meta.vitest': 'undefined',
+    packageVersion: "'0.0.0'",
   },
 });