feature: vor und nachteile

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/architecture-7EHR7CIX-OP562TCL.mjs

@@ -0,0 +1,10 @@
+import {
+  ArchitectureModule,
+  createArchitectureServices
+} from "./chunk-D6UAH5RW.mjs";
+import "./chunk-NW2N4LI3.mjs";
+import "./chunk-PTVI3W5X.mjs";
+export {
+  ArchitectureModule,
+  createArchitectureServices
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/architecture-7EHR7CIX-OP562TCL.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-2ENXBMWA.mjs

@@ -0,0 +1,104 @@
+import {
+  __name as __name2
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../parser/dist/mermaid-parser.core.mjs
+var parsers = {};
+var initializers = {
+  info: /* @__PURE__ */ __name2(async () => {
+    const { createInfoServices: createInfoServices2 } = await import("./info-J43DQDTF-ZY6QRYG4.mjs");
+    const parser = createInfoServices2().Info.parser.LangiumParser;
+    parsers.info = parser;
+  }, "info"),
+  packet: /* @__PURE__ */ __name2(async () => {
+    const { createPacketServices: createPacketServices2 } = await import("./packet-YPE3B663-JK7CTFV3.mjs");
+    const parser = createPacketServices2().Packet.parser.LangiumParser;
+    parsers.packet = parser;
+  }, "packet"),
+  pie: /* @__PURE__ */ __name2(async () => {
+    const { createPieServices: createPieServices2 } = await import("./pie-LRSECV5Y-YQIUPWZK.mjs");
+    const parser = createPieServices2().Pie.parser.LangiumParser;
+    parsers.pie = parser;
+  }, "pie"),
+  treeView: /* @__PURE__ */ __name2(async () => {
+    const { createTreeViewServices: createTreeViewServices2 } = await import("./treeView-BLDUP644-Z5PZNN5R.mjs");
+    const parser = createTreeViewServices2().TreeView.parser.LangiumParser;
+    parsers.treeView = parser;
+  }, "treeView"),
+  architecture: /* @__PURE__ */ __name2(async () => {
+    const { createArchitectureServices: createArchitectureServices2 } = await import("./architecture-7EHR7CIX-OP562TCL.mjs");
+    const parser = createArchitectureServices2().Architecture.parser.LangiumParser;
+    parsers.architecture = parser;
+  }, "architecture"),
+  gitGraph: /* @__PURE__ */ __name2(async () => {
+    const { createGitGraphServices: createGitGraphServices2 } = await import("./gitGraph-WXDBUCRP-EUW4T63J.mjs");
+    const parser = createGitGraphServices2().GitGraph.parser.LangiumParser;
+    parsers.gitGraph = parser;
+  }, "gitGraph"),
+  eventmodeling: /* @__PURE__ */ __name2(async () => {
+    const { createEventModelingServices: createEventModelingServices2 } = await import("./eventmodeling-FCH6USID-KPOGAU7Q.mjs");
+    const parser = createEventModelingServices2().EventModel.parser.LangiumParser;
+    parsers.eventmodeling = parser;
+  }, "eventmodeling"),
+  radar: /* @__PURE__ */ __name2(async () => {
+    const { createRadarServices: createRadarServices2 } = await import("./radar-GUYGQ44K-S4BGN5FN.mjs");
+    const parser = createRadarServices2().Radar.parser.LangiumParser;
+    parsers.radar = parser;
+  }, "radar"),
+  treemap: /* @__PURE__ */ __name2(async () => {
+    const { createTreemapServices: createTreemapServices2 } = await import("./treemap-LRROVOQU-URWGPAEI.mjs");
+    const parser = createTreemapServices2().Treemap.parser.LangiumParser;
+    parsers.treemap = parser;
+  }, "treemap"),
+  wardley: /* @__PURE__ */ __name2(async () => {
+    const { createWardleyServices: createWardleyServices2 } = await import("./wardley-L42UT6IY-YAZPMKU5.mjs");
+    const parser = createWardleyServices2().Wardley.parser.LangiumParser;
+    parsers.wardley = parser;
+  }, "wardley")
+};
+async function parse(diagramType, text) {
+  const initializer = initializers[diagramType];
+  if (!initializer) {
+    throw new Error(`Unknown diagram type: ${diagramType}`);
+  }
+  if (!parsers[diagramType]) {
+    await initializer();
+  }
+  const parser = parsers[diagramType];
+  const result = parser.parse(text);
+  if (result.lexerErrors.length > 0 || result.parserErrors.length > 0) {
+    throw new MermaidParseError(result);
+  }
+  return result.value;
+}
+__name(parse, "parse");
+__name2(parse, "parse");
+var MermaidParseError = class extends Error {
+  static {
+    __name(this, "MermaidParseError");
+  }
+  constructor(result) {
+    const lexerErrors = result.lexerErrors.map((err) => {
+      const line = err.line !== void 0 && !isNaN(err.line) ? err.line : "?";
+      const column = err.column !== void 0 && !isNaN(err.column) ? err.column : "?";
+      return `Lexer error on line ${line}, column ${column}: ${err.message}`;
+    }).join("\n");
+    const parserErrors = result.parserErrors.map((err) => {
+      const line = err.token.startLine !== void 0 && !isNaN(err.token.startLine) ? err.token.startLine : "?";
+      const column = err.token.startColumn !== void 0 && !isNaN(err.token.startColumn) ? err.token.startColumn : "?";
+      return `Parse error on line ${line}, column ${column}: ${err.message}`;
+    }).join("\n");
+    super(`Parsing failed: ${lexerErrors} ${parserErrors}`);
+    this.result = result;
+  }
+  static {
+    __name2(this, "MermaidParseError");
+  }
+};
+
+export {
+  parse
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-3O5MS6M4.mjs

@@ -0,0 +1,69 @@
+import {
+  AbstractMermaidTokenBuilder,
+  AbstractMermaidValueConverter,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  TreeViewGrammarGeneratedModule,
+  __name as __name2,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../parser/dist/chunks/mermaid-parser.core/chunk-WCWK7LTN.mjs
+var TreeViewValueConverter = class extends AbstractMermaidValueConverter {
+  static {
+    __name(this, "TreeViewValueConverter");
+  }
+  static {
+    __name2(this, "TreeViewValueConverter");
+  }
+  runCustomConverter(rule, input, _cstNode) {
+    if (rule.name === "INDENTATION") {
+      return input?.length || 0;
+    } else if (rule.name === "STRING2") {
+      return input.substring(1, input.length - 1);
+    }
+    return void 0;
+  }
+};
+var TreeViewTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "TreeViewTokenBuilder");
+  }
+  static {
+    __name2(this, "TreeViewTokenBuilder");
+  }
+  constructor() {
+    super(["treeView-beta"]);
+  }
+};
+var TreeViewModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name2(() => new TreeViewTokenBuilder(), "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name2(() => new TreeViewValueConverter(), "ValueConverter")
+  }
+};
+function createTreeViewServices(context = EmptyFileSystem) {
+  const shared = inject(
+    createDefaultSharedCoreModule(context),
+    MermaidGeneratedSharedModule
+  );
+  const TreeView = inject(
+    createDefaultCoreModule({ shared }),
+    TreeViewGrammarGeneratedModule,
+    TreeViewModule
+  );
+  shared.ServiceRegistry.register(TreeView);
+  return { shared, TreeView };
+}
+__name(createTreeViewServices, "createTreeViewServices");
+__name2(createTreeViewServices, "createTreeViewServices");
+
+export {
+  TreeViewModule,
+  createTreeViewServices
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-3O5MS6M4.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-WCWK7LTN.mjs"],
+  "sourcesContent": ["import {\n  AbstractMermaidTokenBuilder,\n  AbstractMermaidValueConverter,\n  EmptyFileSystem,\n  MermaidGeneratedSharedModule,\n  TreeViewGrammarGeneratedModule,\n  __name,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject,\n  lib_exports\n} from \"./chunk-NNHCCRGN.mjs\";\n\n// src/language/treeView/valueConverter.ts\nvar TreeViewValueConverter = class extends AbstractMermaidValueConverter {\n  static {\n    __name(this, \"TreeViewValueConverter\");\n  }\n  runCustomConverter(rule, input, _cstNode) {\n    if (rule.name === \"INDENTATION\") {\n      return input?.length || 0;\n    } else if (rule.name === \"STRING2\") {\n      return input.substring(1, input.length - 1);\n    }\n    return void 0;\n  }\n};\n\n// src/language/treeView/tokenBuilder.ts\nvar TreeViewTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"TreeViewTokenBuilder\");\n  }\n  constructor() {\n    super([\"treeView-beta\"]);\n  }\n};\n\n// src/language/treeView/module.ts\nvar TreeViewModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new TreeViewTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new TreeViewValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createTreeViewServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const TreeView = inject(\n    createDefaultCoreModule({ shared }),\n    TreeViewGrammarGeneratedModule,\n    TreeViewModule\n  );\n  shared.ServiceRegistry.register(TreeView);\n  return { shared, TreeView };\n}\n__name(createTreeViewServices, \"createTreeViewServices\");\n\nexport {\n  TreeViewModule,\n  createTreeViewServices\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAcA,IAAI,yBAAyB,cAAc,8BAA8B;AAAA,EAdzE,OAcyE;AAAA;AAAA;AAAA,EACvE,OAAO;AACL,IAAAA,QAAO,MAAM,wBAAwB;AAAA,EACvC;AAAA,EACA,mBAAmB,MAAM,OAAO,UAAU;AACxC,QAAI,KAAK,SAAS,eAAe;AAC/B,aAAO,OAAO,UAAU;AAAA,IAC1B,WAAW,KAAK,SAAS,WAAW;AAClC,aAAO,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC;AAAA,IAC5C;AACA,WAAO;AAAA,EACT;AACF;AAGA,IAAI,uBAAuB,cAAc,4BAA4B;AAAA,EA7BrE,OA6BqE;AAAA;AAAA;AAAA,EACnE,OAAO;AACL,IAAAA,QAAO,MAAM,sBAAsB;AAAA,EACrC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,eAAe,CAAC;AAAA,EACzB;AACF;AAGA,IAAI,iBAAiB;AAAA,EACnB,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,cAAc;AAAA,IACrF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,uBAAuB,GAAG,gBAAgB;AAAA,EAC7F;AACF;AACA,SAAS,uBAAuB,UAAU,iBAAiB;AACzD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,WAAW;AAAA,IACf,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,QAAQ;AACxC,SAAO,EAAE,QAAQ,SAAS;AAC5B;AAZS;AAaTA,QAAO,wBAAwB,wBAAwB;",
+  "names": ["__name"]
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-6ZKBGPIT.mjs

@@ -0,0 +1,21 @@
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/diagrams/common/populateCommonDb.ts
+function populateCommonDb(ast, db) {
+  if (ast.accDescr) {
+    db.setAccDescription?.(ast.accDescr);
+  }
+  if (ast.accTitle) {
+    db.setAccTitle?.(ast.accTitle);
+  }
+  if (ast.title) {
+    db.setDiagramTitle?.(ast.title);
+  }
+}
+__name(populateCommonDb, "populateCommonDb");
+
+export {
+  populateCommonDb
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-6ZKBGPIT.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/diagrams/common/populateCommonDb.ts"],
+  "sourcesContent": ["import type { DiagramAST } from '@mermaid-js/parser';\nimport type { DiagramDB } from '../../diagram-api/types.js';\n\nexport function populateCommonDb(ast: DiagramAST, db: DiagramDB) {\n  if (ast.accDescr) {\n    db.setAccDescription?.(ast.accDescr);\n  }\n  if (ast.accTitle) {\n    db.setAccTitle?.(ast.accTitle);\n  }\n  if (ast.title) {\n    db.setDiagramTitle?.(ast.title);\n  }\n}\n"],
+  "mappings": ";;;;;AAGO,SAAS,iBAAiB,KAAiB,IAAe;AAC/D,MAAI,IAAI,UAAU;AAChB,OAAG,oBAAoB,IAAI,QAAQ;AAAA,EACrC;AACA,MAAI,IAAI,UAAU;AAChB,OAAG,cAAc,IAAI,QAAQ;AAAA,EAC/B;AACA,MAAI,IAAI,OAAO;AACb,OAAG,kBAAkB,IAAI,KAAK;AAAA,EAChC;AACF;AAVgB;",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-7723GVCQ.mjs

@@ -0,0 +1,21 @@
+import {
+  select_default
+} from "./chunk-V7P66DNM.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/rendering-util/insertElementsForSize.js
+var getDiagramElement = /* @__PURE__ */ __name((id, securityLevel) => {
+  let sandboxElement;
+  if (securityLevel === "sandbox") {
+    sandboxElement = select_default("#i" + id);
+  }
+  const root = securityLevel === "sandbox" ? select_default(sandboxElement.nodes()[0].contentDocument.body) : select_default("body");
+  const svg = root.select(`[id="${id}"]`);
+  return svg;
+}, "getDiagramElement");
+
+export {
+  getDiagramElement
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-7723GVCQ.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/rendering-util/insertElementsForSize.js"],
+  "sourcesContent": ["import { select } from 'd3';\n\nexport const getDiagramElement = (id, securityLevel) => {\n  let sandboxElement;\n  if (securityLevel === 'sandbox') {\n    sandboxElement = select('#i' + id);\n  }\n  const root =\n    securityLevel === 'sandbox'\n      ? select(sandboxElement.nodes()[0].contentDocument.body)\n      : select('body');\n\n  const svg = root.select(`[id=\"${id}\"]`);\n\n  // Run the renderer. This is what draws the final graph.\n\n  return svg;\n};\n"],
+  "mappings": ";;;;;;;;AAEO,IAAM,oBAAoB,wBAAC,IAAI,kBAAkB;AACtD,MAAI;AACJ,MAAI,kBAAkB,WAAW;AAC/B,qBAAiB,eAAO,OAAO,EAAE;AAAA,EACnC;AACA,QAAM,OACJ,kBAAkB,YACd,eAAO,eAAe,MAAM,EAAE,CAAC,EAAE,gBAAgB,IAAI,IACrD,eAAO,MAAM;AAEnB,QAAM,MAAM,KAAK,OAAO,QAAQ,EAAE,IAAI;AAItC,SAAO;AACT,GAfiC;",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-7TFACZ55.mjs

@@ -0,0 +1,102 @@
+import {
+  __commonJS,
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/constants.js
+var require_constants = __commonJS({
+  "../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/constants.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BLANK_URL = exports.relativeFirstCharacters = exports.whitespaceEscapeCharsRegex = exports.urlSchemeRegex = exports.ctrlCharactersRegex = exports.htmlCtrlEntityRegex = exports.htmlEntitiesRegex = exports.invalidProtocolRegex = void 0;
+    exports.invalidProtocolRegex = /^([^\w]*)(javascript|data|vbscript)/im;
+    exports.htmlEntitiesRegex = /&#(\w+)(^\w|;)?/g;
+    exports.htmlCtrlEntityRegex = /&(newline|tab);/gi;
+    exports.ctrlCharactersRegex = /[\u0000-\u001F\u007F-\u009F\u2000-\u200D\uFEFF]/gim;
+    exports.urlSchemeRegex = /^.+(:|:)/gim;
+    exports.whitespaceEscapeCharsRegex = /(\\|%5[cC])((%(6[eE]|72|74))|[nrt])/g;
+    exports.relativeFirstCharacters = [".", "/"];
+    exports.BLANK_URL = "about:blank";
+  }
+});
+
+// ../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.sanitizeUrl = void 0;
+    var constants_1 = require_constants();
+    function isRelativeUrlWithoutProtocol(url) {
+      return constants_1.relativeFirstCharacters.indexOf(url[0]) > -1;
+    }
+    __name(isRelativeUrlWithoutProtocol, "isRelativeUrlWithoutProtocol");
+    function decodeHtmlCharacters(str) {
+      var removedNullByte = str.replace(constants_1.ctrlCharactersRegex, "");
+      return removedNullByte.replace(constants_1.htmlEntitiesRegex, function(match, dec) {
+        return String.fromCharCode(dec);
+      });
+    }
+    __name(decodeHtmlCharacters, "decodeHtmlCharacters");
+    function isValidUrl(url) {
+      return URL.canParse(url);
+    }
+    __name(isValidUrl, "isValidUrl");
+    function decodeURI(uri) {
+      try {
+        return decodeURIComponent(uri);
+      } catch (e) {
+        return uri;
+      }
+    }
+    __name(decodeURI, "decodeURI");
+    function sanitizeUrl(url) {
+      if (!url) {
+        return constants_1.BLANK_URL;
+      }
+      var charsToDecode;
+      var decodedUrl = decodeURI(url.trim());
+      do {
+        decodedUrl = decodeHtmlCharacters(decodedUrl).replace(constants_1.htmlCtrlEntityRegex, "").replace(constants_1.ctrlCharactersRegex, "").replace(constants_1.whitespaceEscapeCharsRegex, "").trim();
+        decodedUrl = decodeURI(decodedUrl);
+        charsToDecode = decodedUrl.match(constants_1.ctrlCharactersRegex) || decodedUrl.match(constants_1.htmlEntitiesRegex) || decodedUrl.match(constants_1.htmlCtrlEntityRegex) || decodedUrl.match(constants_1.whitespaceEscapeCharsRegex);
+      } while (charsToDecode && charsToDecode.length > 0);
+      var sanitizedUrl = decodedUrl;
+      if (!sanitizedUrl) {
+        return constants_1.BLANK_URL;
+      }
+      if (isRelativeUrlWithoutProtocol(sanitizedUrl)) {
+        return sanitizedUrl;
+      }
+      var trimmedUrl = sanitizedUrl.trimStart();
+      var urlSchemeParseResults = trimmedUrl.match(constants_1.urlSchemeRegex);
+      if (!urlSchemeParseResults) {
+        return sanitizedUrl;
+      }
+      var urlScheme = urlSchemeParseResults[0].toLowerCase().trim();
+      if (constants_1.invalidProtocolRegex.test(urlScheme)) {
+        return constants_1.BLANK_URL;
+      }
+      var backSanitized = trimmedUrl.replace(/\\/g, "/");
+      if (urlScheme === "mailto:" || urlScheme.includes("://")) {
+        return backSanitized;
+      }
+      if (urlScheme === "http:" || urlScheme === "https:") {
+        if (!isValidUrl(backSanitized)) {
+          return constants_1.BLANK_URL;
+        }
+        var url_1 = new URL(backSanitized);
+        url_1.protocol = url_1.protocol.toLowerCase();
+        url_1.hostname = url_1.hostname.toLowerCase();
+        return url_1.toString();
+      }
+      return backSanitized;
+    }
+    __name(sanitizeUrl, "sanitizeUrl");
+    exports.sanitizeUrl = sanitizeUrl;
+  }
+});
+
+export {
+  require_dist
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-7TFACZ55.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/constants.js", "../../../../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/index.js"],
+  "sourcesContent": ["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.BLANK_URL = exports.relativeFirstCharacters = exports.whitespaceEscapeCharsRegex = exports.urlSchemeRegex = exports.ctrlCharactersRegex = exports.htmlCtrlEntityRegex = exports.htmlEntitiesRegex = exports.invalidProtocolRegex = void 0;\nexports.invalidProtocolRegex = /^([^\\w]*)(javascript|data|vbscript)/im;\nexports.htmlEntitiesRegex = /&#(\\w+)(^\\w|;)?/g;\nexports.htmlCtrlEntityRegex = /&(newline|tab);/gi;\nexports.ctrlCharactersRegex = /[\\u0000-\\u001F\\u007F-\\u009F\\u2000-\\u200D\\uFEFF]/gim;\nexports.urlSchemeRegex = /^.+(:|:)/gim;\nexports.whitespaceEscapeCharsRegex = /(\\\\|%5[cC])((%(6[eE]|72|74))|[nrt])/g;\nexports.relativeFirstCharacters = [\".\", \"/\"];\nexports.BLANK_URL = \"about:blank\";\n", "\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.sanitizeUrl = void 0;\nvar constants_1 = require(\"./constants\");\nfunction isRelativeUrlWithoutProtocol(url) {\n    return constants_1.relativeFirstCharacters.indexOf(url[0]) > -1;\n}\nfunction decodeHtmlCharacters(str) {\n    var removedNullByte = str.replace(constants_1.ctrlCharactersRegex, \"\");\n    return removedNullByte.replace(constants_1.htmlEntitiesRegex, function (match, dec) {\n        return String.fromCharCode(dec);\n    });\n}\nfunction isValidUrl(url) {\n    return URL.canParse(url);\n}\nfunction decodeURI(uri) {\n    try {\n        return decodeURIComponent(uri);\n    }\n    catch (e) {\n        // Ignoring error\n        // It is possible that the URI contains a `%` not associated\n        // with URI/URL-encoding.\n        return uri;\n    }\n}\nfunction sanitizeUrl(url) {\n    if (!url) {\n        return constants_1.BLANK_URL;\n    }\n    var charsToDecode;\n    var decodedUrl = decodeURI(url.trim());\n    do {\n        decodedUrl = decodeHtmlCharacters(decodedUrl)\n            .replace(constants_1.htmlCtrlEntityRegex, \"\")\n            .replace(constants_1.ctrlCharactersRegex, \"\")\n            .replace(constants_1.whitespaceEscapeCharsRegex, \"\")\n            .trim();\n        decodedUrl = decodeURI(decodedUrl);\n        charsToDecode =\n            decodedUrl.match(constants_1.ctrlCharactersRegex) ||\n                decodedUrl.match(constants_1.htmlEntitiesRegex) ||\n                decodedUrl.match(constants_1.htmlCtrlEntityRegex) ||\n                decodedUrl.match(constants_1.whitespaceEscapeCharsRegex);\n    } while (charsToDecode && charsToDecode.length > 0);\n    var sanitizedUrl = decodedUrl;\n    if (!sanitizedUrl) {\n        return constants_1.BLANK_URL;\n    }\n    if (isRelativeUrlWithoutProtocol(sanitizedUrl)) {\n        return sanitizedUrl;\n    }\n    // Remove any leading whitespace before checking the URL scheme\n    var trimmedUrl = sanitizedUrl.trimStart();\n    var urlSchemeParseResults = trimmedUrl.match(constants_1.urlSchemeRegex);\n    if (!urlSchemeParseResults) {\n        return sanitizedUrl;\n    }\n    var urlScheme = urlSchemeParseResults[0].toLowerCase().trim();\n    if (constants_1.invalidProtocolRegex.test(urlScheme)) {\n        return constants_1.BLANK_URL;\n    }\n    var backSanitized = trimmedUrl.replace(/\\\\/g, \"/\");\n    // Handle special cases for mailto: and custom deep-link protocols\n    if (urlScheme === \"mailto:\" || urlScheme.includes(\"://\")) {\n        return backSanitized;\n    }\n    // For http and https URLs, perform additional validation\n    if (urlScheme === \"http:\" || urlScheme === \"https:\") {\n        if (!isValidUrl(backSanitized)) {\n            return constants_1.BLANK_URL;\n        }\n        var url_1 = new URL(backSanitized);\n        url_1.protocol = url_1.protocol.toLowerCase();\n        url_1.hostname = url_1.hostname.toLowerCase();\n        return url_1.toString();\n    }\n    return backSanitized;\n}\nexports.sanitizeUrl = sanitizeUrl;\n"],
+  "mappings": ";;;;;;AAAA;AAAA;AAAA;AACA,WAAO,eAAe,SAAS,cAAc,EAAE,OAAO,KAAK,CAAC;AAC5D,YAAQ,YAAY,QAAQ,0BAA0B,QAAQ,6BAA6B,QAAQ,iBAAiB,QAAQ,sBAAsB,QAAQ,sBAAsB,QAAQ,oBAAoB,QAAQ,uBAAuB;AAC3O,YAAQ,uBAAuB;AAC/B,YAAQ,oBAAoB;AAC5B,YAAQ,sBAAsB;AAC9B,YAAQ,sBAAsB;AAC9B,YAAQ,iBAAiB;AACzB,YAAQ,6BAA6B;AACrC,YAAQ,0BAA0B,CAAC,KAAK,GAAG;AAC3C,YAAQ,YAAY;AAAA;AAAA;;;ACVpB;AAAA;AAAA;AACA,WAAO,eAAe,SAAS,cAAc,EAAE,OAAO,KAAK,CAAC;AAC5D,YAAQ,cAAc;AACtB,QAAI,cAAc;AAClB,aAAS,6BAA6B,KAAK;AACvC,aAAO,YAAY,wBAAwB,QAAQ,IAAI,CAAC,CAAC,IAAI;AAAA,IACjE;AAFS;AAGT,aAAS,qBAAqB,KAAK;AAC/B,UAAI,kBAAkB,IAAI,QAAQ,YAAY,qBAAqB,EAAE;AACrE,aAAO,gBAAgB,QAAQ,YAAY,mBAAmB,SAAU,OAAO,KAAK;AAChF,eAAO,OAAO,aAAa,GAAG;AAAA,MAClC,CAAC;AAAA,IACL;AALS;AAMT,aAAS,WAAW,KAAK;AACrB,aAAO,IAAI,SAAS,GAAG;AAAA,IAC3B;AAFS;AAGT,aAAS,UAAU,KAAK;AACpB,UAAI;AACA,eAAO,mBAAmB,GAAG;AAAA,MACjC,SACO,GAAG;AAIN,eAAO;AAAA,MACX;AAAA,IACJ;AAVS;AAWT,aAAS,YAAY,KAAK;AACtB,UAAI,CAAC,KAAK;AACN,eAAO,YAAY;AAAA,MACvB;AACA,UAAI;AACJ,UAAI,aAAa,UAAU,IAAI,KAAK,CAAC;AACrC,SAAG;AACC,qBAAa,qBAAqB,UAAU,EACvC,QAAQ,YAAY,qBAAqB,EAAE,EAC3C,QAAQ,YAAY,qBAAqB,EAAE,EAC3C,QAAQ,YAAY,4BAA4B,EAAE,EAClD,KAAK;AACV,qBAAa,UAAU,UAAU;AACjC,wBACI,WAAW,MAAM,YAAY,mBAAmB,KAC5C,WAAW,MAAM,YAAY,iBAAiB,KAC9C,WAAW,MAAM,YAAY,mBAAmB,KAChD,WAAW,MAAM,YAAY,0BAA0B;AAAA,MACnE,SAAS,iBAAiB,cAAc,SAAS;AACjD,UAAI,eAAe;AACnB,UAAI,CAAC,cAAc;AACf,eAAO,YAAY;AAAA,MACvB;AACA,UAAI,6BAA6B,YAAY,GAAG;AAC5C,eAAO;AAAA,MACX;AAEA,UAAI,aAAa,aAAa,UAAU;AACxC,UAAI,wBAAwB,WAAW,MAAM,YAAY,cAAc;AACvE,UAAI,CAAC,uBAAuB;AACxB,eAAO;AAAA,MACX;AACA,UAAI,YAAY,sBAAsB,CAAC,EAAE,YAAY,EAAE,KAAK;AAC5D,UAAI,YAAY,qBAAqB,KAAK,SAAS,GAAG;AAClD,eAAO,YAAY;AAAA,MACvB;AACA,UAAI,gBAAgB,WAAW,QAAQ,OAAO,GAAG;AAEjD,UAAI,cAAc,aAAa,UAAU,SAAS,KAAK,GAAG;AACtD,eAAO;AAAA,MACX;AAEA,UAAI,cAAc,WAAW,cAAc,UAAU;AACjD,YAAI,CAAC,WAAW,aAAa,GAAG;AAC5B,iBAAO,YAAY;AAAA,QACvB;AACA,YAAI,QAAQ,IAAI,IAAI,aAAa;AACjC,cAAM,WAAW,MAAM,SAAS,YAAY;AAC5C,cAAM,WAAW,MAAM,SAAS,YAAY;AAC5C,eAAO,MAAM,SAAS;AAAA,MAC1B;AACA,aAAO;AAAA,IACX;AApDS;AAqDT,YAAQ,cAAc;AAAA;AAAA;",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-BBDM4ZFP.mjs

@@ -0,0 +1,53 @@
+import {
+  AbstractMermaidTokenBuilder,
+  CommonValueConverter,
+  EmptyFileSystem,
+  InfoGrammarGeneratedModule,
+  MermaidGeneratedSharedModule,
+  __name as __name2,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../parser/dist/chunks/mermaid-parser.core/chunk-5DO6E6H7.mjs
+var InfoTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "InfoTokenBuilder");
+  }
+  static {
+    __name2(this, "InfoTokenBuilder");
+  }
+  constructor() {
+    super(["info", "showInfo"]);
+  }
+};
+var InfoModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name2(() => new InfoTokenBuilder(), "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name2(() => new CommonValueConverter(), "ValueConverter")
+  }
+};
+function createInfoServices(context = EmptyFileSystem) {
+  const shared = inject(
+    createDefaultSharedCoreModule(context),
+    MermaidGeneratedSharedModule
+  );
+  const Info = inject(
+    createDefaultCoreModule({ shared }),
+    InfoGrammarGeneratedModule,
+    InfoModule
+  );
+  shared.ServiceRegistry.register(Info);
+  return { shared, Info };
+}
+__name(createInfoServices, "createInfoServices");
+__name2(createInfoServices, "createInfoServices");
+
+export {
+  InfoModule,
+  createInfoServices
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-BBDM4ZFP.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-5DO6E6H7.mjs"],
+  "sourcesContent": ["import {\n  AbstractMermaidTokenBuilder,\n  CommonValueConverter,\n  EmptyFileSystem,\n  InfoGrammarGeneratedModule,\n  MermaidGeneratedSharedModule,\n  __name,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject,\n  lib_exports\n} from \"./chunk-NNHCCRGN.mjs\";\n\n// src/language/info/tokenBuilder.ts\nvar InfoTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"InfoTokenBuilder\");\n  }\n  constructor() {\n    super([\"info\", \"showInfo\"]);\n  }\n};\n\n// src/language/info/module.ts\nvar InfoModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new InfoTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createInfoServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const Info = inject(\n    createDefaultCoreModule({ shared }),\n    InfoGrammarGeneratedModule,\n    InfoModule\n  );\n  shared.ServiceRegistry.register(Info);\n  return { shared, Info };\n}\n__name(createInfoServices, \"createInfoServices\");\n\nexport {\n  InfoModule,\n  createInfoServices\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAcA,IAAI,mBAAmB,cAAc,4BAA4B;AAAA,EAdjE,OAciE;AAAA;AAAA;AAAA,EAC/D,OAAO;AACL,IAAAA,QAAO,MAAM,kBAAkB;AAAA,EACjC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,QAAQ,UAAU,CAAC;AAAA,EAC5B;AACF;AAGA,IAAI,aAAa;AAAA,EACf,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,iBAAiB,GAAG,cAAc;AAAA,IACjF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,gBAAgB;AAAA,EAC3F;AACF;AACA,SAAS,mBAAmB,UAAU,iBAAiB;AACrD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,OAAO;AAAA,IACX,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,IAAI;AACpC,SAAO,EAAE,QAAQ,KAAK;AACxB;AAZS;AAaTA,QAAO,oBAAoB,oBAAoB;",
+  "names": ["__name"]
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-CT5Q72BK.mjs

@@ -0,0 +1,67 @@
+import {
+  AbstractMermaidTokenBuilder,
+  AbstractMermaidValueConverter,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  PieGrammarGeneratedModule,
+  __name as __name2,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../parser/dist/chunks/mermaid-parser.core/chunk-MZUSXYTE.mjs
+var PieTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "PieTokenBuilder");
+  }
+  static {
+    __name2(this, "PieTokenBuilder");
+  }
+  constructor() {
+    super(["pie", "showData"]);
+  }
+};
+var PieValueConverter = class extends AbstractMermaidValueConverter {
+  static {
+    __name(this, "PieValueConverter");
+  }
+  static {
+    __name2(this, "PieValueConverter");
+  }
+  runCustomConverter(rule, input, _cstNode) {
+    if (rule.name !== "PIE_SECTION_LABEL") {
+      return void 0;
+    }
+    return input.replace(/"/g, "").trim();
+  }
+};
+var PieModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name2(() => new PieTokenBuilder(), "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name2(() => new PieValueConverter(), "ValueConverter")
+  }
+};
+function createPieServices(context = EmptyFileSystem) {
+  const shared = inject(
+    createDefaultSharedCoreModule(context),
+    MermaidGeneratedSharedModule
+  );
+  const Pie = inject(
+    createDefaultCoreModule({ shared }),
+    PieGrammarGeneratedModule,
+    PieModule
+  );
+  shared.ServiceRegistry.register(Pie);
+  return { shared, Pie };
+}
+__name(createPieServices, "createPieServices");
+__name2(createPieServices, "createPieServices");
+
+export {
+  PieModule,
+  createPieServices
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-CT5Q72BK.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-MZUSXYTE.mjs"],
+  "sourcesContent": ["import {\n  AbstractMermaidTokenBuilder,\n  AbstractMermaidValueConverter,\n  EmptyFileSystem,\n  MermaidGeneratedSharedModule,\n  PieGrammarGeneratedModule,\n  __name,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject,\n  lib_exports\n} from \"./chunk-NNHCCRGN.mjs\";\n\n// src/language/pie/tokenBuilder.ts\nvar PieTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"PieTokenBuilder\");\n  }\n  constructor() {\n    super([\"pie\", \"showData\"]);\n  }\n};\n\n// src/language/pie/valueConverter.ts\nvar PieValueConverter = class extends AbstractMermaidValueConverter {\n  static {\n    __name(this, \"PieValueConverter\");\n  }\n  runCustomConverter(rule, input, _cstNode) {\n    if (rule.name !== \"PIE_SECTION_LABEL\") {\n      return void 0;\n    }\n    return input.replace(/\"/g, \"\").trim();\n  }\n};\n\n// src/language/pie/module.ts\nvar PieModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new PieTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new PieValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createPieServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const Pie = inject(\n    createDefaultCoreModule({ shared }),\n    PieGrammarGeneratedModule,\n    PieModule\n  );\n  shared.ServiceRegistry.register(Pie);\n  return { shared, Pie };\n}\n__name(createPieServices, \"createPieServices\");\n\nexport {\n  PieModule,\n  createPieServices\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAcA,IAAI,kBAAkB,cAAc,4BAA4B;AAAA,EAdhE,OAcgE;AAAA;AAAA;AAAA,EAC9D,OAAO;AACL,IAAAA,QAAO,MAAM,iBAAiB;AAAA,EAChC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,OAAO,UAAU,CAAC;AAAA,EAC3B;AACF;AAGA,IAAI,oBAAoB,cAAc,8BAA8B;AAAA,EAxBpE,OAwBoE;AAAA;AAAA;AAAA,EAClE,OAAO;AACL,IAAAA,QAAO,MAAM,mBAAmB;AAAA,EAClC;AAAA,EACA,mBAAmB,MAAM,OAAO,UAAU;AACxC,QAAI,KAAK,SAAS,qBAAqB;AACrC,aAAO;AAAA,IACT;AACA,WAAO,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;AAAA,EACtC;AACF;AAGA,IAAI,YAAY;AAAA,EACd,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,gBAAgB,GAAG,cAAc;AAAA,IAChF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,kBAAkB,GAAG,gBAAgB;AAAA,EACxF;AACF;AACA,SAAS,kBAAkB,UAAU,iBAAiB;AACpD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,MAAM;AAAA,IACV,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,GAAG;AACnC,SAAO,EAAE,QAAQ,IAAI;AACvB;AAZS;AAaTA,QAAO,mBAAmB,mBAAmB;",
+  "names": ["__name"]
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-CYW2HGLJ.mjs

@@ -0,0 +1,53 @@
+import {
+  AbstractMermaidTokenBuilder,
+  CommonValueConverter,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  PacketGrammarGeneratedModule,
+  __name as __name2,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../parser/dist/chunks/mermaid-parser.core/chunk-MPE355IW.mjs
+var PacketTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "PacketTokenBuilder");
+  }
+  static {
+    __name2(this, "PacketTokenBuilder");
+  }
+  constructor() {
+    super(["packet"]);
+  }
+};
+var PacketModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name2(() => new PacketTokenBuilder(), "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name2(() => new CommonValueConverter(), "ValueConverter")
+  }
+};
+function createPacketServices(context = EmptyFileSystem) {
+  const shared = inject(
+    createDefaultSharedCoreModule(context),
+    MermaidGeneratedSharedModule
+  );
+  const Packet = inject(
+    createDefaultCoreModule({ shared }),
+    PacketGrammarGeneratedModule,
+    PacketModule
+  );
+  shared.ServiceRegistry.register(Packet);
+  return { shared, Packet };
+}
+__name(createPacketServices, "createPacketServices");
+__name2(createPacketServices, "createPacketServices");
+
+export {
+  PacketModule,
+  createPacketServices
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-CYW2HGLJ.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-MPE355IW.mjs"],
+  "sourcesContent": ["import {\n  AbstractMermaidTokenBuilder,\n  CommonValueConverter,\n  EmptyFileSystem,\n  MermaidGeneratedSharedModule,\n  PacketGrammarGeneratedModule,\n  __name,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject,\n  lib_exports\n} from \"./chunk-NNHCCRGN.mjs\";\n\n// src/language/packet/tokenBuilder.ts\nvar PacketTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"PacketTokenBuilder\");\n  }\n  constructor() {\n    super([\"packet\"]);\n  }\n};\n\n// src/language/packet/module.ts\nvar PacketModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new PacketTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createPacketServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const Packet = inject(\n    createDefaultCoreModule({ shared }),\n    PacketGrammarGeneratedModule,\n    PacketModule\n  );\n  shared.ServiceRegistry.register(Packet);\n  return { shared, Packet };\n}\n__name(createPacketServices, \"createPacketServices\");\n\nexport {\n  PacketModule,\n  createPacketServices\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAcA,IAAI,qBAAqB,cAAc,4BAA4B;AAAA,EAdnE,OAcmE;AAAA;AAAA;AAAA,EACjE,OAAO;AACL,IAAAA,QAAO,MAAM,oBAAoB;AAAA,EACnC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,QAAQ,CAAC;AAAA,EAClB;AACF;AAGA,IAAI,eAAe;AAAA,EACjB,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,mBAAmB,GAAG,cAAc;AAAA,IACnF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,gBAAgB;AAAA,EAC3F;AACF;AACA,SAAS,qBAAqB,UAAU,iBAAiB;AACvD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,SAAS;AAAA,IACb,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,MAAM;AACtC,SAAO,EAAE,QAAQ,OAAO;AAC1B;AAZS;AAaTA,QAAO,sBAAsB,sBAAsB;",
+  "names": ["__name"]
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-D6MTONMS.mjs

@@ -0,0 +1,137 @@
+import {
+  AbstractMermaidTokenBuilder,
+  AbstractMermaidValueConverter,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  TreemapGrammarGeneratedModule,
+  __name as __name2,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../parser/dist/chunks/mermaid-parser.core/chunk-BR22UD5L.mjs
+var TreemapTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "TreemapTokenBuilder");
+  }
+  static {
+    __name2(this, "TreemapTokenBuilder");
+  }
+  constructor() {
+    super(["treemap"]);
+  }
+};
+var classDefRegex = /classDef\s+([A-Z_a-z]\w+)(?:\s+([^\n\r;]*))?;?/;
+var TreemapValueConverter = class extends AbstractMermaidValueConverter {
+  static {
+    __name(this, "TreemapValueConverter");
+  }
+  static {
+    __name2(this, "TreemapValueConverter");
+  }
+  runCustomConverter(rule, input, _cstNode) {
+    if (rule.name === "NUMBER2") {
+      return parseFloat(input.replace(/,/g, ""));
+    } else if (rule.name === "SEPARATOR") {
+      return input.substring(1, input.length - 1);
+    } else if (rule.name === "STRING2") {
+      return input.substring(1, input.length - 1);
+    } else if (rule.name === "INDENTATION") {
+      return input.length;
+    } else if (rule.name === "ClassDef") {
+      if (typeof input !== "string") {
+        return input;
+      }
+      const match = classDefRegex.exec(input);
+      if (match) {
+        return {
+          $type: "ClassDefStatement",
+          className: match[1],
+          styleText: match[2] || void 0
+        };
+      }
+    }
+    return void 0;
+  }
+};
+function registerValidationChecks(services) {
+  const validator = services.validation.TreemapValidator;
+  const registry = services.validation.ValidationRegistry;
+  if (registry) {
+    const checks = {
+      Treemap: validator.checkSingleRoot.bind(validator)
+      // Remove unused validation for TreemapRow
+    };
+    registry.register(checks, validator);
+  }
+}
+__name(registerValidationChecks, "registerValidationChecks");
+__name2(registerValidationChecks, "registerValidationChecks");
+var TreemapValidator = class {
+  static {
+    __name(this, "TreemapValidator");
+  }
+  static {
+    __name2(this, "TreemapValidator");
+  }
+  /**
+   * Validates that a treemap has only one root node.
+   * A root node is defined as a node that has no indentation.
+   */
+  checkSingleRoot(doc, accept) {
+    let rootNodeIndentation;
+    for (const row of doc.TreemapRows) {
+      if (!row.item) {
+        continue;
+      }
+      if (rootNodeIndentation === void 0 && // Check if this is a root node (no indentation)
+      row.indent === void 0) {
+        rootNodeIndentation = 0;
+      } else if (row.indent === void 0) {
+        accept("error", "Multiple root nodes are not allowed in a treemap.", {
+          node: row,
+          property: "item"
+        });
+      } else if (rootNodeIndentation !== void 0 && rootNodeIndentation >= parseInt(row.indent, 10)) {
+        accept("error", "Multiple root nodes are not allowed in a treemap.", {
+          node: row,
+          property: "item"
+        });
+      }
+    }
+  }
+};
+var TreemapModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name2(() => new TreemapTokenBuilder(), "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name2(() => new TreemapValueConverter(), "ValueConverter")
+  },
+  validation: {
+    TreemapValidator: /* @__PURE__ */ __name2(() => new TreemapValidator(), "TreemapValidator")
+  }
+};
+function createTreemapServices(context = EmptyFileSystem) {
+  const shared = inject(
+    createDefaultSharedCoreModule(context),
+    MermaidGeneratedSharedModule
+  );
+  const Treemap = inject(
+    createDefaultCoreModule({ shared }),
+    TreemapGrammarGeneratedModule,
+    TreemapModule
+  );
+  shared.ServiceRegistry.register(Treemap);
+  registerValidationChecks(Treemap);
+  return { shared, Treemap };
+}
+__name(createTreemapServices, "createTreemapServices");
+__name2(createTreemapServices, "createTreemapServices");
+
+export {
+  TreemapModule,
+  createTreemapServices
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-D6MTONMS.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-BR22UD5L.mjs"],
+  "sourcesContent": ["import {\n  AbstractMermaidTokenBuilder,\n  AbstractMermaidValueConverter,\n  EmptyFileSystem,\n  MermaidGeneratedSharedModule,\n  TreemapGrammarGeneratedModule,\n  __name,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject,\n  lib_exports\n} from \"./chunk-NNHCCRGN.mjs\";\n\n// src/language/treemap/tokenBuilder.ts\nvar TreemapTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"TreemapTokenBuilder\");\n  }\n  constructor() {\n    super([\"treemap\"]);\n  }\n};\n\n// src/language/treemap/valueConverter.ts\nvar classDefRegex = /classDef\\s+([A-Z_a-z]\\w+)(?:\\s+([^\\n\\r;]*))?;?/;\nvar TreemapValueConverter = class extends AbstractMermaidValueConverter {\n  static {\n    __name(this, \"TreemapValueConverter\");\n  }\n  runCustomConverter(rule, input, _cstNode) {\n    if (rule.name === \"NUMBER2\") {\n      return parseFloat(input.replace(/,/g, \"\"));\n    } else if (rule.name === \"SEPARATOR\") {\n      return input.substring(1, input.length - 1);\n    } else if (rule.name === \"STRING2\") {\n      return input.substring(1, input.length - 1);\n    } else if (rule.name === \"INDENTATION\") {\n      return input.length;\n    } else if (rule.name === \"ClassDef\") {\n      if (typeof input !== \"string\") {\n        return input;\n      }\n      const match = classDefRegex.exec(input);\n      if (match) {\n        return {\n          $type: \"ClassDefStatement\",\n          className: match[1],\n          styleText: match[2] || void 0\n        };\n      }\n    }\n    return void 0;\n  }\n};\n\n// src/language/treemap/treemap-validator.ts\nfunction registerValidationChecks(services) {\n  const validator = services.validation.TreemapValidator;\n  const registry = services.validation.ValidationRegistry;\n  if (registry) {\n    const checks = {\n      Treemap: validator.checkSingleRoot.bind(validator)\n      // Remove unused validation for TreemapRow\n    };\n    registry.register(checks, validator);\n  }\n}\n__name(registerValidationChecks, \"registerValidationChecks\");\nvar TreemapValidator = class {\n  static {\n    __name(this, \"TreemapValidator\");\n  }\n  /**\n   * Validates that a treemap has only one root node.\n   * A root node is defined as a node that has no indentation.\n   */\n  checkSingleRoot(doc, accept) {\n    let rootNodeIndentation;\n    for (const row of doc.TreemapRows) {\n      if (!row.item) {\n        continue;\n      }\n      if (rootNodeIndentation === void 0 && // Check if this is a root node (no indentation)\n      row.indent === void 0) {\n        rootNodeIndentation = 0;\n      } else if (row.indent === void 0) {\n        accept(\"error\", \"Multiple root nodes are not allowed in a treemap.\", {\n          node: row,\n          property: \"item\"\n        });\n      } else if (rootNodeIndentation !== void 0 && rootNodeIndentation >= parseInt(row.indent, 10)) {\n        accept(\"error\", \"Multiple root nodes are not allowed in a treemap.\", {\n          node: row,\n          property: \"item\"\n        });\n      }\n    }\n  }\n};\n\n// src/language/treemap/module.ts\nvar TreemapModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new TreemapTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new TreemapValueConverter(), \"ValueConverter\")\n  },\n  validation: {\n    TreemapValidator: /* @__PURE__ */ __name(() => new TreemapValidator(), \"TreemapValidator\")\n  }\n};\nfunction createTreemapServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const Treemap = inject(\n    createDefaultCoreModule({ shared }),\n    TreemapGrammarGeneratedModule,\n    TreemapModule\n  );\n  shared.ServiceRegistry.register(Treemap);\n  registerValidationChecks(Treemap);\n  return { shared, Treemap };\n}\n__name(createTreemapServices, \"createTreemapServices\");\n\nexport {\n  TreemapModule,\n  createTreemapServices\n};\n"],
+  "mappings": "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",
+  "names": ["__name"]
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-D6UAH5RW.mjs

@@ -0,0 +1,76 @@
+import {
+  AbstractMermaidTokenBuilder,
+  AbstractMermaidValueConverter,
+  ArchitectureGrammarGeneratedModule,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  __name as __name2,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../parser/dist/chunks/mermaid-parser.core/chunk-4EGX6M5U.mjs
+var ArchitectureTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "ArchitectureTokenBuilder");
+  }
+  static {
+    __name2(this, "ArchitectureTokenBuilder");
+  }
+  constructor() {
+    super(["architecture"]);
+  }
+};
+var ArchitectureValueConverter = class extends AbstractMermaidValueConverter {
+  static {
+    __name(this, "ArchitectureValueConverter");
+  }
+  static {
+    __name2(this, "ArchitectureValueConverter");
+  }
+  runCustomConverter(rule, input, _cstNode) {
+    if (rule.name === "ARCH_ICON") {
+      return input.replace(/[()]/g, "").trim();
+    } else if (rule.name === "ARCH_TEXT_ICON") {
+      return input.replace(/["()]/g, "");
+    } else if (rule.name === "ARCH_TITLE") {
+      let result = input.replace(/^\[|]$/g, "").trim();
+      if (result.startsWith('"') && result.endsWith('"') || result.startsWith("'") && result.endsWith("'")) {
+        result = result.slice(1, -1);
+        result = result.replace(/\\"/g, '"').replace(/\\'/g, "'");
+      }
+      return result.trim();
+    }
+    return void 0;
+  }
+};
+var ArchitectureModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name2(() => new ArchitectureTokenBuilder(), "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name2(() => new ArchitectureValueConverter(), "ValueConverter")
+  }
+};
+function createArchitectureServices(context = EmptyFileSystem) {
+  const shared = inject(
+    createDefaultSharedCoreModule(context),
+    MermaidGeneratedSharedModule
+  );
+  const Architecture = inject(
+    createDefaultCoreModule({ shared }),
+    ArchitectureGrammarGeneratedModule,
+    ArchitectureModule
+  );
+  shared.ServiceRegistry.register(Architecture);
+  return { shared, Architecture };
+}
+__name(createArchitectureServices, "createArchitectureServices");
+__name2(createArchitectureServices, "createArchitectureServices");
+
+export {
+  ArchitectureModule,
+  createArchitectureServices
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-D6UAH5RW.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-4EGX6M5U.mjs"],
+  "sourcesContent": ["import {\n  AbstractMermaidTokenBuilder,\n  AbstractMermaidValueConverter,\n  ArchitectureGrammarGeneratedModule,\n  EmptyFileSystem,\n  MermaidGeneratedSharedModule,\n  __name,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject,\n  lib_exports\n} from \"./chunk-NNHCCRGN.mjs\";\n\n// src/language/architecture/tokenBuilder.ts\nvar ArchitectureTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"ArchitectureTokenBuilder\");\n  }\n  constructor() {\n    super([\"architecture\"]);\n  }\n};\n\n// src/language/architecture/valueConverter.ts\nvar ArchitectureValueConverter = class extends AbstractMermaidValueConverter {\n  static {\n    __name(this, \"ArchitectureValueConverter\");\n  }\n  runCustomConverter(rule, input, _cstNode) {\n    if (rule.name === \"ARCH_ICON\") {\n      return input.replace(/[()]/g, \"\").trim();\n    } else if (rule.name === \"ARCH_TEXT_ICON\") {\n      return input.replace(/[\"()]/g, \"\");\n    } else if (rule.name === \"ARCH_TITLE\") {\n      let result = input.replace(/^\\[|]$/g, \"\").trim();\n      if (result.startsWith('\"') && result.endsWith('\"') || result.startsWith(\"'\") && result.endsWith(\"'\")) {\n        result = result.slice(1, -1);\n        result = result.replace(/\\\\\"/g, '\"').replace(/\\\\'/g, \"'\");\n      }\n      return result.trim();\n    }\n    return void 0;\n  }\n};\n\n// src/language/architecture/module.ts\nvar ArchitectureModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new ArchitectureTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new ArchitectureValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createArchitectureServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const Architecture = inject(\n    createDefaultCoreModule({ shared }),\n    ArchitectureGrammarGeneratedModule,\n    ArchitectureModule\n  );\n  shared.ServiceRegistry.register(Architecture);\n  return { shared, Architecture };\n}\n__name(createArchitectureServices, \"createArchitectureServices\");\n\nexport {\n  ArchitectureModule,\n  createArchitectureServices\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAcA,IAAI,2BAA2B,cAAc,4BAA4B;AAAA,EAdzE,OAcyE;AAAA;AAAA;AAAA,EACvE,OAAO;AACL,IAAAA,QAAO,MAAM,0BAA0B;AAAA,EACzC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,cAAc,CAAC;AAAA,EACxB;AACF;AAGA,IAAI,6BAA6B,cAAc,8BAA8B;AAAA,EAxB7E,OAwB6E;AAAA;AAAA;AAAA,EAC3E,OAAO;AACL,IAAAA,QAAO,MAAM,4BAA4B;AAAA,EAC3C;AAAA,EACA,mBAAmB,MAAM,OAAO,UAAU;AACxC,QAAI,KAAK,SAAS,aAAa;AAC7B,aAAO,MAAM,QAAQ,SAAS,EAAE,EAAE,KAAK;AAAA,IACzC,WAAW,KAAK,SAAS,kBAAkB;AACzC,aAAO,MAAM,QAAQ,UAAU,EAAE;AAAA,IACnC,WAAW,KAAK,SAAS,cAAc;AACrC,UAAI,SAAS,MAAM,QAAQ,WAAW,EAAE,EAAE,KAAK;AAC/C,UAAI,OAAO,WAAW,GAAG,KAAK,OAAO,SAAS,GAAG,KAAK,OAAO,WAAW,GAAG,KAAK,OAAO,SAAS,GAAG,GAAG;AACpG,iBAAS,OAAO,MAAM,GAAG,EAAE;AAC3B,iBAAS,OAAO,QAAQ,QAAQ,GAAG,EAAE,QAAQ,QAAQ,GAAG;AAAA,MAC1D;AACA,aAAO,OAAO,KAAK;AAAA,IACrB;AACA,WAAO;AAAA,EACT;AACF;AAGA,IAAI,qBAAqB;AAAA,EACvB,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,yBAAyB,GAAG,cAAc;AAAA,IACzF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,2BAA2B,GAAG,gBAAgB;AAAA,EACjG;AACF;AACA,SAAS,2BAA2B,UAAU,iBAAiB;AAC7D,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,eAAe;AAAA,IACnB,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,YAAY;AAC5C,SAAO,EAAE,QAAQ,aAAa;AAChC;AAZS;AAaTA,QAAO,4BAA4B,4BAA4B;",
+  "names": ["__name"]
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-GTILCTU2.mjs

@@ -0,0 +1,111 @@
+import {
+  getConfig2 as getConfig
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/rendering-util/rendering-elements/shapes/handDrawnShapeStyles.ts
+var solidStateFill = /* @__PURE__ */ __name((color) => {
+  const { handDrawnSeed } = getConfig();
+  return {
+    fill: color,
+    hachureAngle: 120,
+    // angle of hachure,
+    hachureGap: 4,
+    fillWeight: 2,
+    roughness: 0.7,
+    stroke: color,
+    seed: handDrawnSeed
+  };
+}, "solidStateFill");
+var compileStyles = /* @__PURE__ */ __name((node) => {
+  const stylesMap = styles2Map([
+    ...node.cssCompiledStyles || [],
+    ...node.cssStyles || [],
+    ...node.labelStyle || []
+  ]);
+  return { stylesMap, stylesArray: [...stylesMap] };
+}, "compileStyles");
+var styles2Map = /* @__PURE__ */ __name((styles) => {
+  const styleMap = /* @__PURE__ */ new Map();
+  styles.forEach((style) => {
+    const [key, value] = style.split(":");
+    styleMap.set(key.trim(), value?.trim());
+  });
+  return styleMap;
+}, "styles2Map");
+var isLabelStyle = /* @__PURE__ */ __name((key) => {
+  return key === "color" || key === "font-size" || key === "font-family" || key === "font-weight" || key === "font-style" || key === "text-decoration" || key === "text-align" || key === "text-transform" || key === "line-height" || key === "letter-spacing" || key === "word-spacing" || key === "text-shadow" || key === "text-overflow" || key === "white-space" || key === "word-wrap" || key === "word-break" || key === "overflow-wrap" || key === "hyphens";
+}, "isLabelStyle");
+var styles2String = /* @__PURE__ */ __name((node) => {
+  const { stylesArray } = compileStyles(node);
+  const labelStyles = [];
+  const nodeStyles = [];
+  const borderStyles = [];
+  const backgroundStyles = [];
+  stylesArray.forEach((style) => {
+    const key = style[0];
+    if (isLabelStyle(key)) {
+      labelStyles.push(style.join(":") + " !important");
+    } else {
+      nodeStyles.push(style.join(":") + " !important");
+      if (key.includes("stroke")) {
+        borderStyles.push(style.join(":") + " !important");
+      }
+      if (key === "fill") {
+        backgroundStyles.push(style.join(":") + " !important");
+      }
+    }
+  });
+  return {
+    labelStyles: labelStyles.join(";"),
+    nodeStyles: nodeStyles.join(";"),
+    stylesArray,
+    borderStyles,
+    backgroundStyles
+  };
+}, "styles2String");
+var userNodeOverrides = /* @__PURE__ */ __name((node, options) => {
+  const { themeVariables, handDrawnSeed } = getConfig();
+  const { nodeBorder, mainBkg } = themeVariables;
+  const { stylesMap } = compileStyles(node);
+  const result = Object.assign(
+    {
+      roughness: 0.7,
+      fill: stylesMap.get("fill") || mainBkg,
+      fillStyle: "hachure",
+      // solid fill
+      fillWeight: 4,
+      hachureGap: 5.2,
+      stroke: stylesMap.get("stroke") || nodeBorder,
+      seed: handDrawnSeed,
+      strokeWidth: stylesMap.get("stroke-width")?.replace("px", "") || 1.3,
+      fillLineDash: [0, 0],
+      strokeLineDash: getStrokeDashArray(stylesMap.get("stroke-dasharray"))
+    },
+    options
+  );
+  return result;
+}, "userNodeOverrides");
+var getStrokeDashArray = /* @__PURE__ */ __name((strokeDasharrayStyle) => {
+  if (!strokeDasharrayStyle) {
+    return [0, 0];
+  }
+  const dashArray = strokeDasharrayStyle.trim().split(/\s+/).map(Number);
+  if (dashArray.length === 1) {
+    const val = isNaN(dashArray[0]) ? 0 : dashArray[0];
+    return [val, val];
+  }
+  const first = isNaN(dashArray[0]) ? 0 : dashArray[0];
+  const second = isNaN(dashArray[1]) ? 0 : dashArray[1];
+  return [first, second];
+}, "getStrokeDashArray");
+
+export {
+  solidStateFill,
+  compileStyles,
+  isLabelStyle,
+  styles2String,
+  userNodeOverrides
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-GTILCTU2.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/rendering-util/rendering-elements/shapes/handDrawnShapeStyles.ts"],
+  "sourcesContent": ["import { getConfig } from '../../../diagram-api/diagramAPI.js';\nimport type { Node } from '../../types.js';\n\n// Striped fill like start or fork nodes in state diagrams\nexport const solidStateFill = (color: string) => {\n  const { handDrawnSeed } = getConfig();\n  return {\n    fill: color,\n    hachureAngle: 120, // angle of hachure,\n    hachureGap: 4,\n    fillWeight: 2,\n    roughness: 0.7,\n    stroke: color,\n    seed: handDrawnSeed,\n  };\n};\n\nexport const compileStyles = (node: Node) => {\n  // node.cssCompiledStyles is an array of strings in the form of 'key: value' where key is the css property and value is the value\n  // the array is the styles of node from the classes it is using\n  // node.cssStyles is an array of styles directly set on the node\n  // concat the arrays and remove duplicates such that the values from node.cssStyles are used if there are duplicates\n  const stylesMap = styles2Map([\n    ...(node.cssCompiledStyles || []),\n    ...(node.cssStyles || []),\n    ...(node.labelStyle || []),\n  ]);\n  return { stylesMap, stylesArray: [...stylesMap] };\n};\n\nexport const styles2Map = (styles: string[]) => {\n  const styleMap = new Map<string, string>();\n  styles.forEach((style) => {\n    const [key, value] = style.split(':');\n    styleMap.set(key.trim(), value?.trim());\n  });\n  return styleMap;\n};\nexport const isLabelStyle = (key: string) => {\n  return (\n    key === 'color' ||\n    key === 'font-size' ||\n    key === 'font-family' ||\n    key === 'font-weight' ||\n    key === 'font-style' ||\n    key === 'text-decoration' ||\n    key === 'text-align' ||\n    key === 'text-transform' ||\n    key === 'line-height' ||\n    key === 'letter-spacing' ||\n    key === 'word-spacing' ||\n    key === 'text-shadow' ||\n    key === 'text-overflow' ||\n    key === 'white-space' ||\n    key === 'word-wrap' ||\n    key === 'word-break' ||\n    key === 'overflow-wrap' ||\n    key === 'hyphens'\n  );\n};\nexport const styles2String = (node: Node) => {\n  const { stylesArray } = compileStyles(node);\n  const labelStyles: string[] = [];\n  const nodeStyles: string[] = [];\n  const borderStyles: string[] = [];\n  const backgroundStyles: string[] = [];\n\n  stylesArray.forEach((style) => {\n    const key = style[0];\n    if (isLabelStyle(key)) {\n      labelStyles.push(style.join(':') + ' !important');\n    } else {\n      nodeStyles.push(style.join(':') + ' !important');\n      if (key.includes('stroke')) {\n        borderStyles.push(style.join(':') + ' !important');\n      }\n      if (key === 'fill') {\n        backgroundStyles.push(style.join(':') + ' !important');\n      }\n    }\n  });\n\n  return {\n    labelStyles: labelStyles.join(';'),\n    nodeStyles: nodeStyles.join(';'),\n    stylesArray,\n    borderStyles,\n    backgroundStyles,\n  };\n};\n\n// Striped fill like start or fork nodes in state diagrams\n// TODO remove any\nexport const userNodeOverrides = (node: Node, options: any) => {\n  const { themeVariables, handDrawnSeed } = getConfig();\n  const { nodeBorder, mainBkg } = themeVariables;\n  const { stylesMap } = compileStyles(node);\n\n  // index the style array to a map object\n  const result = Object.assign(\n    {\n      roughness: 0.7,\n      fill: stylesMap.get('fill') || mainBkg,\n      fillStyle: 'hachure', // solid fill\n      fillWeight: 4,\n      hachureGap: 5.2,\n      stroke: stylesMap.get('stroke') || nodeBorder,\n      seed: handDrawnSeed,\n      strokeWidth: stylesMap.get('stroke-width')?.replace('px', '') || 1.3,\n      fillLineDash: [0, 0],\n      strokeLineDash: getStrokeDashArray(stylesMap.get('stroke-dasharray')),\n    },\n    options\n  );\n  return result;\n};\n\nconst getStrokeDashArray = (strokeDasharrayStyle?: string) => {\n  if (!strokeDasharrayStyle) {\n    return [0, 0];\n  }\n  const dashArray = strokeDasharrayStyle.trim().split(/\\s+/).map(Number);\n  if (dashArray.length === 1) {\n    const val = isNaN(dashArray[0]) ? 0 : dashArray[0];\n    return [val, val];\n  }\n  const first = isNaN(dashArray[0]) ? 0 : dashArray[0];\n  const second = isNaN(dashArray[1]) ? 0 : dashArray[1];\n  return [first, second];\n};\n"],
+  "mappings": "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",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-HQDACWF7.mjs

@@ -0,0 +1,56 @@
+import {
+  AbstractMermaidValueConverter,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  WardleyGrammarGeneratedModule,
+  __name as __name2,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../parser/dist/chunks/mermaid-parser.core/chunk-PUPMXCY4.mjs
+var WardleyValueConverter = class extends AbstractMermaidValueConverter {
+  static {
+    __name(this, "WardleyValueConverter");
+  }
+  static {
+    __name2(this, "WardleyValueConverter");
+  }
+  runCustomConverter(rule, input, _cstNode) {
+    switch (rule.name.toUpperCase()) {
+      case "LINK_LABEL":
+        return input.substring(1).trim();
+      default:
+        return void 0;
+    }
+  }
+};
+var WardleyModule = {
+  parser: {
+    ValueConverter: /* @__PURE__ */ __name2(() => new WardleyValueConverter(), "ValueConverter")
+  }
+};
+function createWardleyServices(context = EmptyFileSystem) {
+  const shared = inject(
+    createDefaultSharedCoreModule(context),
+    MermaidGeneratedSharedModule
+  );
+  const Wardley = inject(
+    createDefaultCoreModule({ shared }),
+    WardleyGrammarGeneratedModule,
+    WardleyModule
+  );
+  shared.ServiceRegistry.register(Wardley);
+  return { shared, Wardley };
+}
+__name(createWardleyServices, "createWardleyServices");
+__name2(createWardleyServices, "createWardleyServices");
+
+export {
+  WardleyModule,
+  createWardleyServices
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-HQDACWF7.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-PUPMXCY4.mjs"],
+  "sourcesContent": ["import {\n  AbstractMermaidValueConverter,\n  EmptyFileSystem,\n  MermaidGeneratedSharedModule,\n  WardleyGrammarGeneratedModule,\n  __name,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject,\n  lib_exports\n} from \"./chunk-NNHCCRGN.mjs\";\n\n// src/language/wardley/valueConverter.ts\nvar WardleyValueConverter = class extends AbstractMermaidValueConverter {\n  static {\n    __name(this, \"WardleyValueConverter\");\n  }\n  runCustomConverter(rule, input, _cstNode) {\n    switch (rule.name.toUpperCase()) {\n      case \"LINK_LABEL\":\n        return input.substring(1).trim();\n      default:\n        return void 0;\n    }\n  }\n};\n\n// src/language/wardley/module.ts\nvar WardleyModule = {\n  parser: {\n    ValueConverter: /* @__PURE__ */ __name(() => new WardleyValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createWardleyServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const Wardley = inject(\n    createDefaultCoreModule({ shared }),\n    WardleyGrammarGeneratedModule,\n    WardleyModule\n  );\n  shared.ServiceRegistry.register(Wardley);\n  return { shared, Wardley };\n}\n__name(createWardleyServices, \"createWardleyServices\");\n\nexport {\n  WardleyModule,\n  createWardleyServices\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;AAaA,IAAI,wBAAwB,cAAc,8BAA8B;AAAA,EAbxE,OAawE;AAAA;AAAA;AAAA,EACtE,OAAO;AACL,IAAAA,QAAO,MAAM,uBAAuB;AAAA,EACtC;AAAA,EACA,mBAAmB,MAAM,OAAO,UAAU;AACxC,YAAQ,KAAK,KAAK,YAAY,GAAG;AAAA,MAC/B,KAAK;AACH,eAAO,MAAM,UAAU,CAAC,EAAE,KAAK;AAAA,MACjC;AACE,eAAO;AAAA,IACX;AAAA,EACF;AACF;AAGA,IAAI,gBAAgB;AAAA,EAClB,QAAQ;AAAA,IACN,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,sBAAsB,GAAG,gBAAgB;AAAA,EAC5F;AACF;AACA,SAAS,sBAAsB,UAAU,iBAAiB;AACxD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,UAAU;AAAA,IACd,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,OAAO;AACvC,SAAO,EAAE,QAAQ,QAAQ;AAC3B;AAZS;AAaTA,QAAO,uBAAuB,uBAAuB;",
+  "names": ["__name"]
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-IALYP65X.mjs

@@ -0,0 +1,24 @@
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/utils/imperativeState.ts
+var ImperativeState = class {
+  /**
+   * @param init - Function that creates the default state.
+   */
+  constructor(init) {
+    this.init = init;
+    this.records = this.init();
+  }
+  static {
+    __name(this, "ImperativeState");
+  }
+  reset() {
+    this.records = this.init();
+  }
+};
+
+export {
+  ImperativeState
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-IALYP65X.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/imperativeState.ts"],
+  "sourcesContent": ["/**\n * Resettable state storage.\n * @example\n * ```\n * const state = new ImperativeState(() => ({\n *   foo: undefined as string | undefined,\n *   bar: [] as number[],\n *   baz: 1 as number | undefined,\n * }));\n *\n * state.records.foo = \"hi\";\n * console.log(state.records.foo); // prints \"hi\";\n * state.reset();\n * console.log(state.records.foo); // prints \"default\";\n *\n * // typeof state.records:\n * // {\n * //   foo: string | undefined, // actual: undefined\n * //   bar: number[],           // actual: []\n * //   baz: number | undefined, // actual: 1\n * // }\n * ```\n */\nexport class ImperativeState<S> {\n  public records: S;\n\n  /**\n   * @param init - Function that creates the default state.\n   */\n  constructor(private init: () => S) {\n    this.records = this.init();\n  }\n\n  reset() {\n    this.records = this.init();\n  }\n}\n"],
+  "mappings": ";;;;;AAuBO,IAAM,kBAAN,MAAyB;AAAA;AAAA;AAAA;AAAA,EAM9B,YAAoB,MAAe;AAAf;AAClB,SAAK,UAAU,KAAK,KAAK;AAAA,EAC3B;AAAA,EA/BF,OAuBgC;AAAA;AAAA;AAAA,EAU9B,QAAQ;AACN,SAAK,UAAU,KAAK,KAAK;AAAA,EAC3B;AACF;",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-KEUPHFFI.mjs

@@ -0,0 +1,35 @@
+import {
+  configureSvgSize
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  log
+} from "./chunk-V7P66DNM.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/rendering-util/setupViewPortForSVG.ts
+var setupViewPortForSVG = /* @__PURE__ */ __name((svg, padding, cssDiagram, useMaxWidth) => {
+  svg.attr("class", cssDiagram);
+  const { width, height, x, y } = calculateDimensionsWithPadding(svg, padding);
+  configureSvgSize(svg, height, width, useMaxWidth);
+  const viewBox = createViewBox(x, y, width, height, padding);
+  svg.attr("viewBox", viewBox);
+  log.debug(`viewBox configured: ${viewBox} with padding: ${padding}`);
+}, "setupViewPortForSVG");
+var calculateDimensionsWithPadding = /* @__PURE__ */ __name((svg, padding) => {
+  const bounds = svg.node()?.getBBox() || { width: 0, height: 0, x: 0, y: 0 };
+  return {
+    width: bounds.width + padding * 2,
+    height: bounds.height + padding * 2,
+    x: bounds.x,
+    y: bounds.y
+  };
+}, "calculateDimensionsWithPadding");
+var createViewBox = /* @__PURE__ */ __name((x, y, width, height, padding) => {
+  return `${x - padding} ${y - padding} ${width} ${height}`;
+}, "createViewBox");
+
+export {
+  setupViewPortForSVG
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-KEUPHFFI.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/rendering-util/setupViewPortForSVG.ts"],
+  "sourcesContent": ["import { configureSvgSize } from '../setupGraphViewbox.js';\nimport type { SVG } from '../diagram-api/types.js';\nimport { log } from '../logger.js';\n\nexport const setupViewPortForSVG = (\n  svg: SVG,\n  padding: number,\n  cssDiagram: string,\n  useMaxWidth: boolean\n) => {\n  // Initialize the SVG element and set the diagram class\n  svg.attr('class', cssDiagram);\n\n  // Calculate the dimensions and position with padding\n  const { width, height, x, y } = calculateDimensionsWithPadding(svg, padding);\n\n  // Configure the size and aspect ratio of the SVG\n  configureSvgSize(svg, height, width, useMaxWidth);\n\n  // Update the viewBox to ensure all content is visible with padding\n  const viewBox = createViewBox(x, y, width, height, padding);\n  svg.attr('viewBox', viewBox);\n\n  // Log the viewBox configuration for debugging\n  log.debug(`viewBox configured: ${viewBox} with padding: ${padding}`);\n};\n\nconst calculateDimensionsWithPadding = (svg: SVG, padding: number) => {\n  const bounds = svg.node()?.getBBox() || { width: 0, height: 0, x: 0, y: 0 };\n  return {\n    width: bounds.width + padding * 2,\n    height: bounds.height + padding * 2,\n    x: bounds.x,\n    y: bounds.y,\n  };\n};\n\nconst createViewBox = (x: number, y: number, width: number, height: number, padding: number) => {\n  return `${x - padding} ${y - padding} ${width} ${height}`;\n};\n"],
+  "mappings": ";;;;;;;;;;;AAIO,IAAM,sBAAsB,wBACjC,KACA,SACA,YACA,gBACG;AAEH,MAAI,KAAK,SAAS,UAAU;AAG5B,QAAM,EAAE,OAAO,QAAQ,GAAG,EAAE,IAAI,+BAA+B,KAAK,OAAO;AAG3E,mBAAiB,KAAK,QAAQ,OAAO,WAAW;AAGhD,QAAM,UAAU,cAAc,GAAG,GAAG,OAAO,QAAQ,OAAO;AAC1D,MAAI,KAAK,WAAW,OAAO;AAG3B,MAAI,MAAM,uBAAuB,OAAO,kBAAkB,OAAO,EAAE;AACrE,GArBmC;AAuBnC,IAAM,iCAAiC,wBAAC,KAAU,YAAoB;AACpE,QAAM,SAAS,IAAI,KAAK,GAAG,QAAQ,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,GAAG,GAAG,GAAG,EAAE;AAC1E,SAAO;AAAA,IACL,OAAO,OAAO,QAAQ,UAAU;AAAA,IAChC,QAAQ,OAAO,SAAS,UAAU;AAAA,IAClC,GAAG,OAAO;AAAA,IACV,GAAG,OAAO;AAAA,EACZ;AACF,GARuC;AAUvC,IAAM,gBAAgB,wBAAC,GAAW,GAAW,OAAe,QAAgB,YAAoB;AAC9F,SAAO,GAAG,IAAI,OAAO,IAAI,IAAI,OAAO,IAAI,KAAK,IAAI,MAAM;AACzD,GAFsB;",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-LJRZYMMA.mjs

@@ -0,0 +1,53 @@
+import {
+  AbstractMermaidTokenBuilder,
+  CommonValueConverter,
+  EmptyFileSystem,
+  GitGraphGrammarGeneratedModule,
+  MermaidGeneratedSharedModule,
+  __name as __name2,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../parser/dist/chunks/mermaid-parser.core/chunk-UIBZB4QT.mjs
+var GitGraphTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "GitGraphTokenBuilder");
+  }
+  static {
+    __name2(this, "GitGraphTokenBuilder");
+  }
+  constructor() {
+    super(["gitGraph"]);
+  }
+};
+var GitGraphModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name2(() => new GitGraphTokenBuilder(), "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name2(() => new CommonValueConverter(), "ValueConverter")
+  }
+};
+function createGitGraphServices(context = EmptyFileSystem) {
+  const shared = inject(
+    createDefaultSharedCoreModule(context),
+    MermaidGeneratedSharedModule
+  );
+  const GitGraph = inject(
+    createDefaultCoreModule({ shared }),
+    GitGraphGrammarGeneratedModule,
+    GitGraphModule
+  );
+  shared.ServiceRegistry.register(GitGraph);
+  return { shared, GitGraph };
+}
+__name(createGitGraphServices, "createGitGraphServices");
+__name2(createGitGraphServices, "createGitGraphServices");
+
+export {
+  GitGraphModule,
+  createGitGraphServices
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-LJRZYMMA.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-UIBZB4QT.mjs"],
+  "sourcesContent": ["import {\n  AbstractMermaidTokenBuilder,\n  CommonValueConverter,\n  EmptyFileSystem,\n  GitGraphGrammarGeneratedModule,\n  MermaidGeneratedSharedModule,\n  __name,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject,\n  lib_exports\n} from \"./chunk-NNHCCRGN.mjs\";\n\n// src/language/gitGraph/tokenBuilder.ts\nvar GitGraphTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"GitGraphTokenBuilder\");\n  }\n  constructor() {\n    super([\"gitGraph\"]);\n  }\n};\n\n// src/language/gitGraph/module.ts\nvar GitGraphModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new GitGraphTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createGitGraphServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const GitGraph = inject(\n    createDefaultCoreModule({ shared }),\n    GitGraphGrammarGeneratedModule,\n    GitGraphModule\n  );\n  shared.ServiceRegistry.register(GitGraph);\n  return { shared, GitGraph };\n}\n__name(createGitGraphServices, \"createGitGraphServices\");\n\nexport {\n  GitGraphModule,\n  createGitGraphServices\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAcA,IAAI,uBAAuB,cAAc,4BAA4B;AAAA,EAdrE,OAcqE;AAAA;AAAA;AAAA,EACnE,OAAO;AACL,IAAAA,QAAO,MAAM,sBAAsB;AAAA,EACrC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,UAAU,CAAC;AAAA,EACpB;AACF;AAGA,IAAI,iBAAiB;AAAA,EACnB,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,cAAc;AAAA,IACrF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,gBAAgB;AAAA,EAC3F;AACF;AACA,SAAS,uBAAuB,UAAU,iBAAiB;AACzD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,WAAW;AAAA,IACf,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,QAAQ;AACxC,SAAO,EAAE,QAAQ,SAAS;AAC5B;AAZS;AAaTA,QAAO,wBAAwB,wBAAwB;",
+  "names": ["__name"]
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-NZTEHIZO.mjs

@@ -0,0 +1,117 @@
+import {
+  AbstractMermaidTokenBuilder,
+  CommonValueConverter,
+  EmptyFileSystem,
+  EventModelingGeneratedModule,
+  MermaidGeneratedSharedModule,
+  __name as __name2,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../parser/dist/chunks/mermaid-parser.core/chunk-N66VUXT2.mjs
+var EventModelingTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "EventModelingTokenBuilder");
+  }
+  static {
+    __name2(this, "EventModelingTokenBuilder");
+  }
+  constructor() {
+    super(["eventmodeling"]);
+  }
+};
+var COMMAND_TYPES = /* @__PURE__ */ new Set(["cmd", "command"]);
+var EVENT_TYPES = /* @__PURE__ */ new Set(["evt", "event"]);
+var READMODEL_TYPES = /* @__PURE__ */ new Set(["rmo", "readmodel"]);
+var PROCESSOR_TYPES = /* @__PURE__ */ new Set(["pcr", "processor"]);
+var UI_TYPES = /* @__PURE__ */ new Set(["ui"]);
+function registerValidationChecks(services) {
+  const validator = services.validation.EventModelingValidator;
+  const registry = services.validation.ValidationRegistry;
+  if (registry) {
+    const checks = {
+      EmTimeFrame: validator.checkSourceFrameTypes.bind(validator),
+      EmResetFrame: validator.checkSourceFrameTypes.bind(validator)
+    };
+    registry.register(checks, validator);
+  }
+}
+__name(registerValidationChecks, "registerValidationChecks");
+__name2(registerValidationChecks, "registerValidationChecks");
+var EventModelingValidator = class {
+  static {
+    __name(this, "EventModelingValidator");
+  }
+  static {
+    __name2(this, "EventModelingValidator");
+  }
+  checkSourceFrameTypes(frame, accept) {
+    if (frame.sourceFrames.length === 0) {
+      return;
+    }
+    if (COMMAND_TYPES.has(frame.modelEntityType)) {
+      this.validateSources(
+        frame,
+        /* @__PURE__ */ new Set([...UI_TYPES, ...PROCESSOR_TYPES]),
+        "command",
+        "ui or processor",
+        accept
+      );
+    } else if (EVENT_TYPES.has(frame.modelEntityType)) {
+      this.validateSources(frame, COMMAND_TYPES, "event", "command", accept);
+    } else if (READMODEL_TYPES.has(frame.modelEntityType)) {
+      this.validateSources(frame, EVENT_TYPES, "read model", "event", accept);
+    } else if (PROCESSOR_TYPES.has(frame.modelEntityType)) {
+      this.validateSources(frame, READMODEL_TYPES, "processor", "read model", accept);
+    } else if (UI_TYPES.has(frame.modelEntityType)) {
+      this.validateSources(frame, READMODEL_TYPES, "ui", "read model", accept);
+    }
+  }
+  validateSources(frame, allowedSourceTypes, targetLabel, expectedSourceLabel, accept) {
+    for (const sourceRef of frame.sourceFrames) {
+      const source = sourceRef.ref;
+      if (source !== void 0 && !allowedSourceTypes.has(source.modelEntityType)) {
+        accept(
+          "error",
+          `A ${targetLabel} can only receive input from a ${expectedSourceLabel}, not from '${source.modelEntityType}'.`,
+          { node: frame, property: "sourceFrames" }
+        );
+      }
+    }
+  }
+};
+var EventModelingModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name2(() => new EventModelingTokenBuilder(), "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name2(() => new CommonValueConverter(), "ValueConverter")
+  },
+  validation: {
+    EventModelingValidator: /* @__PURE__ */ __name2(() => new EventModelingValidator(), "EventModelingValidator")
+  }
+};
+function createEventModelingServices(context = EmptyFileSystem) {
+  const shared = inject(
+    createDefaultSharedCoreModule(context),
+    MermaidGeneratedSharedModule
+  );
+  const EventModel = inject(
+    createDefaultCoreModule({ shared }),
+    EventModelingGeneratedModule,
+    EventModelingModule
+  );
+  shared.ServiceRegistry.register(EventModel);
+  registerValidationChecks(EventModel);
+  return { shared, EventModel };
+}
+__name(createEventModelingServices, "createEventModelingServices");
+__name2(createEventModelingServices, "createEventModelingServices");
+
+export {
+  EventModelingModule,
+  createEventModelingServices
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-NZTEHIZO.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-N66VUXT2.mjs"],
+  "sourcesContent": ["import {\n  AbstractMermaidTokenBuilder,\n  CommonValueConverter,\n  EmptyFileSystem,\n  EventModelingGeneratedModule,\n  MermaidGeneratedSharedModule,\n  __name,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject,\n  lib_exports\n} from \"./chunk-NNHCCRGN.mjs\";\n\n// src/language/eventmodeling/tokenBuilder.ts\nvar EventModelingTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"EventModelingTokenBuilder\");\n  }\n  constructor() {\n    super([\"eventmodeling\"]);\n  }\n};\n\n// src/language/eventmodeling/event-modeling-validator.ts\nvar COMMAND_TYPES = /* @__PURE__ */ new Set([\"cmd\", \"command\"]);\nvar EVENT_TYPES = /* @__PURE__ */ new Set([\"evt\", \"event\"]);\nvar READMODEL_TYPES = /* @__PURE__ */ new Set([\"rmo\", \"readmodel\"]);\nvar PROCESSOR_TYPES = /* @__PURE__ */ new Set([\"pcr\", \"processor\"]);\nvar UI_TYPES = /* @__PURE__ */ new Set([\"ui\"]);\nfunction registerValidationChecks(services) {\n  const validator = services.validation.EventModelingValidator;\n  const registry = services.validation.ValidationRegistry;\n  if (registry) {\n    const checks = {\n      EmTimeFrame: validator.checkSourceFrameTypes.bind(validator),\n      EmResetFrame: validator.checkSourceFrameTypes.bind(validator)\n    };\n    registry.register(checks, validator);\n  }\n}\n__name(registerValidationChecks, \"registerValidationChecks\");\nvar EventModelingValidator = class {\n  static {\n    __name(this, \"EventModelingValidator\");\n  }\n  checkSourceFrameTypes(frame, accept) {\n    if (frame.sourceFrames.length === 0) {\n      return;\n    }\n    if (COMMAND_TYPES.has(frame.modelEntityType)) {\n      this.validateSources(\n        frame,\n        /* @__PURE__ */ new Set([...UI_TYPES, ...PROCESSOR_TYPES]),\n        \"command\",\n        \"ui or processor\",\n        accept\n      );\n    } else if (EVENT_TYPES.has(frame.modelEntityType)) {\n      this.validateSources(frame, COMMAND_TYPES, \"event\", \"command\", accept);\n    } else if (READMODEL_TYPES.has(frame.modelEntityType)) {\n      this.validateSources(frame, EVENT_TYPES, \"read model\", \"event\", accept);\n    } else if (PROCESSOR_TYPES.has(frame.modelEntityType)) {\n      this.validateSources(frame, READMODEL_TYPES, \"processor\", \"read model\", accept);\n    } else if (UI_TYPES.has(frame.modelEntityType)) {\n      this.validateSources(frame, READMODEL_TYPES, \"ui\", \"read model\", accept);\n    }\n  }\n  validateSources(frame, allowedSourceTypes, targetLabel, expectedSourceLabel, accept) {\n    for (const sourceRef of frame.sourceFrames) {\n      const source = sourceRef.ref;\n      if (source !== void 0 && !allowedSourceTypes.has(source.modelEntityType)) {\n        accept(\n          \"error\",\n          `A ${targetLabel} can only receive input from a ${expectedSourceLabel}, not from '${source.modelEntityType}'.`,\n          { node: frame, property: \"sourceFrames\" }\n        );\n      }\n    }\n  }\n};\n\n// src/language/eventmodeling/module.ts\nvar EventModelingModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new EventModelingTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n  },\n  validation: {\n    EventModelingValidator: /* @__PURE__ */ __name(() => new EventModelingValidator(), \"EventModelingValidator\")\n  }\n};\nfunction createEventModelingServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const EventModel = inject(\n    createDefaultCoreModule({ shared }),\n    EventModelingGeneratedModule,\n    EventModelingModule\n  );\n  shared.ServiceRegistry.register(EventModel);\n  registerValidationChecks(EventModel);\n  return { shared, EventModel };\n}\n__name(createEventModelingServices, \"createEventModelingServices\");\n\nexport {\n  EventModelingModule,\n  createEventModelingServices\n};\n"],
+  "mappings": "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",
+  "names": ["__name"]
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-O4A3IS3O.mjs

@@ -0,0 +1,132 @@
+import {
+  require_dist
+} from "./chunk-7TFACZ55.mjs";
+import {
+  lineBreakRegex
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  select_default
+} from "./chunk-V7P66DNM.mjs";
+import {
+  __name,
+  __toESM
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/diagrams/common/svgDrawCommon.ts
+var import_sanitize_url = __toESM(require_dist(), 1);
+var drawRect = /* @__PURE__ */ __name((element, rectData) => {
+  const rectElement = element.append("rect");
+  rectElement.attr("x", rectData.x);
+  rectElement.attr("y", rectData.y);
+  rectElement.attr("fill", rectData.fill);
+  rectElement.attr("stroke", rectData.stroke);
+  rectElement.attr("width", rectData.width);
+  rectElement.attr("height", rectData.height);
+  if (rectData.name) {
+    rectElement.attr("name", rectData.name);
+  }
+  if (rectData.rx) {
+    rectElement.attr("rx", rectData.rx);
+  }
+  if (rectData.ry) {
+    rectElement.attr("ry", rectData.ry);
+  }
+  if (rectData.attrs !== void 0) {
+    for (const attrKey in rectData.attrs) {
+      rectElement.attr(attrKey, rectData.attrs[attrKey]);
+    }
+  }
+  if (rectData.class) {
+    rectElement.attr("class", rectData.class);
+  }
+  return rectElement;
+}, "drawRect");
+var drawBackgroundRect = /* @__PURE__ */ __name((element, bounds) => {
+  const rectData = {
+    x: bounds.startx,
+    y: bounds.starty,
+    width: bounds.stopx - bounds.startx,
+    height: bounds.stopy - bounds.starty,
+    fill: bounds.fill,
+    stroke: bounds.stroke,
+    class: "rect"
+  };
+  const rectElement = drawRect(element, rectData);
+  rectElement.lower();
+}, "drawBackgroundRect");
+var drawText = /* @__PURE__ */ __name((element, textData) => {
+  const nText = textData.text.replace(lineBreakRegex, " ");
+  const textElem = element.append("text");
+  textElem.attr("x", textData.x);
+  textElem.attr("y", textData.y);
+  textElem.attr("class", "legend");
+  textElem.style("text-anchor", textData.anchor);
+  if (textData.class) {
+    textElem.attr("class", textData.class);
+  }
+  const tspan = textElem.append("tspan");
+  tspan.attr("x", textData.x + textData.textMargin * 2);
+  tspan.text(nText);
+  return textElem;
+}, "drawText");
+var drawImage = /* @__PURE__ */ __name((elem, x, y, link) => {
+  const imageElement = elem.append("image");
+  imageElement.attr("x", x);
+  imageElement.attr("y", y);
+  const sanitizedLink = (0, import_sanitize_url.sanitizeUrl)(link);
+  imageElement.attr("xlink:href", sanitizedLink);
+}, "drawImage");
+var drawEmbeddedImage = /* @__PURE__ */ __name((element, x, y, link) => {
+  const imageElement = element.append("use");
+  imageElement.attr("x", x);
+  imageElement.attr("y", y);
+  const sanitizedLink = (0, import_sanitize_url.sanitizeUrl)(link);
+  imageElement.attr("xlink:href", `#${sanitizedLink}`);
+}, "drawEmbeddedImage");
+var getNoteRect = /* @__PURE__ */ __name(() => {
+  const noteRectData = {
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    fill: "#EDF2AE",
+    stroke: "#666",
+    anchor: "start",
+    rx: 0,
+    ry: 0
+  };
+  return noteRectData;
+}, "getNoteRect");
+var getTextObj = /* @__PURE__ */ __name(() => {
+  const testObject = {
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    "text-anchor": "start",
+    style: "#666",
+    textMargin: 0,
+    rx: 0,
+    ry: 0,
+    tspan: true
+  };
+  return testObject;
+}, "getTextObj");
+var createTooltip = /* @__PURE__ */ __name(() => {
+  let tooltipElem = select_default(".mermaidTooltip");
+  if (tooltipElem.empty()) {
+    tooltipElem = select_default("body").append("div").attr("class", "mermaidTooltip").style("opacity", 0).style("position", "absolute").style("text-align", "center").style("max-width", "200px").style("padding", "2px").style("font-size", "12px").style("background", "#ffffde").style("border", "1px solid #333").style("border-radius", "2px").style("pointer-events", "none").style("z-index", "100");
+  }
+  return tooltipElem;
+}, "createTooltip");
+
+export {
+  drawRect,
+  drawBackgroundRect,
+  drawText,
+  drawImage,
+  drawEmbeddedImage,
+  getNoteRect,
+  getTextObj,
+  createTooltip
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-O4A3IS3O.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/diagrams/common/svgDrawCommon.ts"],
+  "sourcesContent": ["import { sanitizeUrl } from '@braintree/sanitize-url';\nimport { select } from 'd3';\nimport type { SVG, SVGGroup } from '../../diagram-api/types.js';\nimport { lineBreakRegex } from './common.js';\nimport type {\n  Bound,\n  D3ImageElement,\n  D3RectElement,\n  D3TSpanElement,\n  D3TextElement,\n  D3UseElement,\n  RectData,\n  TextData,\n  TextObject,\n} from './commonTypes.js';\n\nexport const drawRect = (element: SVG | SVGGroup, rectData: RectData): D3RectElement => {\n  const rectElement: D3RectElement = element.append('rect');\n  rectElement.attr('x', rectData.x);\n  rectElement.attr('y', rectData.y);\n  rectElement.attr('fill', rectData.fill);\n  rectElement.attr('stroke', rectData.stroke);\n  rectElement.attr('width', rectData.width);\n  rectElement.attr('height', rectData.height);\n  if (rectData.name) {\n    rectElement.attr('name', rectData.name);\n  }\n  if (rectData.rx) {\n    rectElement.attr('rx', rectData.rx);\n  }\n  if (rectData.ry) {\n    rectElement.attr('ry', rectData.ry);\n  }\n\n  if (rectData.attrs !== undefined) {\n    for (const attrKey in rectData.attrs) {\n      rectElement.attr(attrKey, rectData.attrs[attrKey]);\n    }\n  }\n\n  if (rectData.class) {\n    rectElement.attr('class', rectData.class);\n  }\n\n  return rectElement;\n};\n\n/**\n * Draws a background rectangle\n *\n * @param element - Diagram (reference for bounds)\n * @param bounds - Shape of the rectangle\n */\nexport const drawBackgroundRect = (element: SVG | SVGGroup, bounds: Bound): void => {\n  const rectData: RectData = {\n    x: bounds.startx,\n    y: bounds.starty,\n    width: bounds.stopx - bounds.startx,\n    height: bounds.stopy - bounds.starty,\n    fill: bounds.fill,\n    stroke: bounds.stroke,\n    class: 'rect',\n  };\n  const rectElement: D3RectElement = drawRect(element, rectData);\n  rectElement.lower();\n};\n\nexport const drawText = (element: SVG | SVGGroup, textData: TextData): D3TextElement => {\n  const nText: string = textData.text.replace(lineBreakRegex, ' ');\n\n  const textElem: D3TextElement = element.append('text');\n  textElem.attr('x', textData.x);\n  textElem.attr('y', textData.y);\n  textElem.attr('class', 'legend');\n\n  textElem.style('text-anchor', textData.anchor);\n  if (textData.class) {\n    textElem.attr('class', textData.class);\n  }\n\n  const tspan: D3TSpanElement = textElem.append('tspan');\n  tspan.attr('x', textData.x + textData.textMargin * 2);\n  tspan.text(nText);\n\n  return textElem;\n};\n\nexport const drawImage = (elem: SVG | SVGGroup, x: number, y: number, link: string): void => {\n  const imageElement: D3ImageElement = elem.append('image');\n  imageElement.attr('x', x);\n  imageElement.attr('y', y);\n  const sanitizedLink: string = sanitizeUrl(link);\n  imageElement.attr('xlink:href', sanitizedLink);\n};\n\nexport const drawEmbeddedImage = (\n  element: SVG | SVGGroup,\n  x: number,\n  y: number,\n  link: string\n): void => {\n  const imageElement: D3UseElement = element.append('use');\n  imageElement.attr('x', x);\n  imageElement.attr('y', y);\n  const sanitizedLink: string = sanitizeUrl(link);\n  imageElement.attr('xlink:href', `#${sanitizedLink}`);\n};\n\nexport const getNoteRect = (): RectData => {\n  const noteRectData: RectData = {\n    x: 0,\n    y: 0,\n    width: 100,\n    height: 100,\n    fill: '#EDF2AE',\n    stroke: '#666',\n    anchor: 'start',\n    rx: 0,\n    ry: 0,\n  };\n  return noteRectData;\n};\n\nexport const getTextObj = (): TextObject => {\n  const testObject: TextObject = {\n    x: 0,\n    y: 0,\n    width: 100,\n    height: 100,\n    'text-anchor': 'start',\n    style: '#666',\n    textMargin: 0,\n    rx: 0,\n    ry: 0,\n    tspan: true,\n  };\n  return testObject;\n};\n\nexport const createTooltip = () => {\n  let tooltipElem = select<HTMLDivElement, unknown>('.mermaidTooltip');\n  if (tooltipElem.empty()) {\n    tooltipElem = select('body')\n      .append('div')\n      .attr('class', 'mermaidTooltip')\n      .style('opacity', 0)\n      .style('position', 'absolute')\n      .style('text-align', 'center')\n      .style('max-width', '200px')\n      .style('padding', '2px')\n      .style('font-size', '12px')\n      .style('background', '#ffffde')\n      .style('border', '1px solid #333')\n      .style('border-radius', '2px')\n      .style('pointer-events', 'none')\n      .style('z-index', '100');\n  }\n  return tooltipElem;\n};\n"],
+  "mappings": "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",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-PTVI3W5X.mjs

@@ -0,0 +1,37 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __name,
+  __commonJS,
+  __export,
+  __toESM
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-PTVI3W5X.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-PUIB63ON.mjs

@@ -0,0 +1,26 @@
+import {
+  getConfig2 as getConfig
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  select_default
+} from "./chunk-V7P66DNM.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/rendering-util/selectSvgElement.ts
+var selectSvgElement = /* @__PURE__ */ __name((id) => {
+  const { securityLevel } = getConfig();
+  let root = select_default("body");
+  if (securityLevel === "sandbox") {
+    const sandboxElement = select_default(`#i${id}`);
+    const doc = sandboxElement.node()?.contentDocument ?? document;
+    root = select_default(doc.body);
+  }
+  const svg = root.select(`#${id}`);
+  return svg;
+}, "selectSvgElement");
+
+export {
+  selectSvgElement
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-PUIB63ON.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/rendering-util/selectSvgElement.ts"],
+  "sourcesContent": ["import { select } from 'd3';\nimport { getConfig } from '../diagram-api/diagramAPI.js';\nimport type { HTML, SVG } from '../diagram-api/types.js';\n\n/**\n * Selects the SVG element using {@link id}.\n *\n * @param id - The diagram ID.\n * @returns The selected {@link SVG} element using {@link id}.\n */\nexport const selectSvgElement = (id: string): SVG => {\n  const { securityLevel } = getConfig();\n  // handle root and document for when rendering in sandbox mode\n  let root: HTML = select('body');\n  if (securityLevel === 'sandbox') {\n    const sandboxElement: HTML = select(`#i${id}`);\n    const doc: Document = sandboxElement.node()?.contentDocument ?? document;\n    root = select(doc.body as HTMLIFrameElement);\n  }\n  const svg: SVG = root.select(`#${id}`);\n  return svg;\n};\n"],
+  "mappings": ";;;;;;;;;;;AAUO,IAAM,mBAAmB,wBAAC,OAAoB;AACnD,QAAM,EAAE,cAAc,IAAI,UAAU;AAEpC,MAAI,OAAa,eAAO,MAAM;AAC9B,MAAI,kBAAkB,WAAW;AAC/B,UAAM,iBAAuB,eAAO,KAAK,EAAE,EAAE;AAC7C,UAAM,MAAgB,eAAe,KAAK,GAAG,mBAAmB;AAChE,WAAO,eAAO,IAAI,IAAyB;AAAA,EAC7C;AACA,QAAM,MAAW,KAAK,OAAO,IAAI,EAAE,EAAE;AACrC,SAAO;AACT,GAXgC;",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-RTBOCTTP.mjs

@@ -0,0 +1,24 @@
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/diagrams/globalStyles.ts
+var getIconStyles = /* @__PURE__ */ __name(() => `
+  /* Font Awesome icon styling - consolidated */
+  .label-icon {
+    display: inline-block;
+    height: 1em;
+    overflow: visible;
+    vertical-align: -0.125em;
+  }
+  
+  .node .label-icon path {
+    fill: currentColor;
+    stroke: revert;
+    stroke-width: revert;
+  }
+`, "getIconStyles");
+
+export {
+  getIconStyles
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-RTBOCTTP.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/diagrams/globalStyles.ts"],
+  "sourcesContent": ["export const getIconStyles = () => `\n  /* Font Awesome icon styling - consolidated */\n  .label-icon {\n    display: inline-block;\n    height: 1em;\n    overflow: visible;\n    vertical-align: -0.125em;\n  }\n  \n  .node .label-icon path {\n    fill: currentColor;\n    stroke: revert;\n    stroke-width: revert;\n  }\n`;\n"],
+  "mappings": ";;;;;AAAO,IAAM,gBAAgB,6BAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAAN;",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-RTI7CJYH.mjs

@@ -0,0 +1,172 @@
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/rendering-util/labelTransform.ts
+var computeLabelTransform = /* @__PURE__ */ __name((bbox, useHtmlLabels) => {
+  if (useHtmlLabels) {
+    return "translate(" + -bbox.width / 2 + ", " + -bbox.height / 2 + ")";
+  }
+  const x = bbox.x ?? 0;
+  const y = bbox.y ?? 0;
+  return "translate(" + -(x + bbox.width / 2) + ", " + -(y + bbox.height / 2) + ")";
+}, "computeLabelTransform");
+
+// src/utils/lineWithOffset.ts
+var markerOffsets = {
+  aggregation: 17.25,
+  extension: 17.25,
+  composition: 17.25,
+  dependency: 6,
+  lollipop: 13.5,
+  arrow_point: 4,
+  arrow_barb: 0,
+  arrow_barb_neo: 5.5
+  //arrow_cross: 24,
+};
+var markerOffsets2 = {
+  arrow_point: 4,
+  arrow_cross: 12.5,
+  arrow_circle: 12.5
+};
+function calculateDeltaAndAngle(point1, point2) {
+  if (point1 === void 0 || point2 === void 0) {
+    return { angle: 0, deltaX: 0, deltaY: 0 };
+  }
+  point1 = pointTransformer(point1);
+  point2 = pointTransformer(point2);
+  const [x1, y1] = [point1.x, point1.y];
+  const [x2, y2] = [point2.x, point2.y];
+  const deltaX = x2 - x1;
+  const deltaY = y2 - y1;
+  return { angle: Math.atan(deltaY / deltaX), deltaX, deltaY };
+}
+__name(calculateDeltaAndAngle, "calculateDeltaAndAngle");
+var pointTransformer = /* @__PURE__ */ __name((data) => {
+  if (Array.isArray(data)) {
+    return { x: data[0], y: data[1] };
+  }
+  return data;
+}, "pointTransformer");
+var getLineFunctionsWithOffset = /* @__PURE__ */ __name((edge) => {
+  return {
+    x: /* @__PURE__ */ __name(function(d, i, data) {
+      let offset = 0;
+      const DIRECTION = pointTransformer(data[0]).x < pointTransformer(data[data.length - 1]).x ? "left" : "right";
+      if (i === 0 && Object.hasOwn(markerOffsets, edge.arrowTypeStart)) {
+        const { angle, deltaX } = calculateDeltaAndAngle(data[0], data[1]);
+        offset = markerOffsets[edge.arrowTypeStart] * Math.cos(angle) * (deltaX >= 0 ? 1 : -1);
+      } else if (i === data.length - 1 && Object.hasOwn(markerOffsets, edge.arrowTypeEnd)) {
+        const { angle, deltaX } = calculateDeltaAndAngle(
+          data[data.length - 1],
+          data[data.length - 2]
+        );
+        offset = markerOffsets[edge.arrowTypeEnd] * Math.cos(angle) * (deltaX >= 0 ? 1 : -1);
+      }
+      const differenceToEnd = Math.abs(
+        pointTransformer(d).x - pointTransformer(data[data.length - 1]).x
+      );
+      const differenceInYEnd = Math.abs(
+        pointTransformer(d).y - pointTransformer(data[data.length - 1]).y
+      );
+      const differenceToStart = Math.abs(pointTransformer(d).x - pointTransformer(data[0]).x);
+      const differenceInYStart = Math.abs(pointTransformer(d).y - pointTransformer(data[0]).y);
+      const startMarkerHeight = markerOffsets[edge.arrowTypeStart];
+      const endMarkerHeight = markerOffsets[edge.arrowTypeEnd];
+      const extraRoom = 1;
+      if (differenceToEnd < endMarkerHeight && differenceToEnd > 0 && differenceInYEnd < endMarkerHeight) {
+        let adjustment = endMarkerHeight + extraRoom - differenceToEnd;
+        adjustment *= DIRECTION === "right" ? -1 : 1;
+        offset -= adjustment;
+      }
+      if (differenceToStart < startMarkerHeight && differenceToStart > 0 && differenceInYStart < startMarkerHeight) {
+        let adjustment = startMarkerHeight + extraRoom - differenceToStart;
+        adjustment *= DIRECTION === "right" ? -1 : 1;
+        offset += adjustment;
+      }
+      return pointTransformer(d).x + offset;
+    }, "x"),
+    y: /* @__PURE__ */ __name(function(d, i, data) {
+      let offset = 0;
+      const DIRECTION = pointTransformer(data[0]).y < pointTransformer(data[data.length - 1]).y ? "down" : "up";
+      if (i === 0 && Object.hasOwn(markerOffsets, edge.arrowTypeStart)) {
+        const { angle, deltaY } = calculateDeltaAndAngle(data[0], data[1]);
+        offset = markerOffsets[edge.arrowTypeStart] * Math.abs(Math.sin(angle)) * (deltaY >= 0 ? 1 : -1);
+      } else if (i === data.length - 1 && Object.hasOwn(markerOffsets, edge.arrowTypeEnd)) {
+        const { angle, deltaY } = calculateDeltaAndAngle(
+          data[data.length - 1],
+          data[data.length - 2]
+        );
+        offset = markerOffsets[edge.arrowTypeEnd] * Math.abs(Math.sin(angle)) * (deltaY >= 0 ? 1 : -1);
+      }
+      const differenceToEnd = Math.abs(
+        pointTransformer(d).y - pointTransformer(data[data.length - 1]).y
+      );
+      const differenceInXEnd = Math.abs(
+        pointTransformer(d).x - pointTransformer(data[data.length - 1]).x
+      );
+      const differenceToStart = Math.abs(pointTransformer(d).y - pointTransformer(data[0]).y);
+      const differenceInXStart = Math.abs(pointTransformer(d).x - pointTransformer(data[0]).x);
+      const startMarkerHeight = markerOffsets[edge.arrowTypeStart];
+      const endMarkerHeight = markerOffsets[edge.arrowTypeEnd];
+      const extraRoom = 1;
+      if (differenceToEnd < endMarkerHeight && differenceToEnd > 0 && differenceInXEnd < endMarkerHeight) {
+        let adjustment = endMarkerHeight + extraRoom - differenceToEnd;
+        adjustment *= DIRECTION === "up" ? -1 : 1;
+        offset -= adjustment;
+      }
+      if (differenceToStart < startMarkerHeight && differenceToStart > 0 && differenceInXStart < startMarkerHeight) {
+        let adjustment = startMarkerHeight + extraRoom - differenceToStart;
+        adjustment *= DIRECTION === "up" ? -1 : 1;
+        offset += adjustment;
+      }
+      return pointTransformer(d).y + offset;
+    }, "y")
+  };
+}, "getLineFunctionsWithOffset");
+if (void 0) {
+  const { it, expect, describe } = void 0;
+  describe("calculateDeltaAndAngle", () => {
+    it("should calculate the angle and deltas between two points", () => {
+      expect(calculateDeltaAndAngle([0, 0], [0, 1])).toStrictEqual({
+        angle: 1.5707963267948966,
+        deltaX: 0,
+        deltaY: 1
+      });
+      expect(calculateDeltaAndAngle([1, 0], [0, -1])).toStrictEqual({
+        angle: 0.7853981633974483,
+        deltaX: -1,
+        deltaY: -1
+      });
+      expect(calculateDeltaAndAngle({ x: 1, y: 0 }, [0, -1])).toStrictEqual({
+        angle: 0.7853981633974483,
+        deltaX: -1,
+        deltaY: -1
+      });
+      expect(calculateDeltaAndAngle({ x: 1, y: 0 }, { x: 1, y: 0 })).toStrictEqual({
+        angle: NaN,
+        deltaX: 0,
+        deltaY: 0
+      });
+    });
+    it("should calculate the angle and deltas if one point in undefined", () => {
+      expect(calculateDeltaAndAngle(void 0, [0, 1])).toStrictEqual({
+        angle: 0,
+        deltaX: 0,
+        deltaY: 0
+      });
+      expect(calculateDeltaAndAngle([0, 1], void 0)).toStrictEqual({
+        angle: 0,
+        deltaX: 0,
+        deltaY: 0
+      });
+    });
+  });
+}
+
+export {
+  computeLabelTransform,
+  markerOffsets,
+  markerOffsets2,
+  getLineFunctionsWithOffset
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-SNQTKDUU.mjs

@@ -0,0 +1,104 @@
+import {
+  insertEdge,
+  insertEdgeLabel,
+  markers_default,
+  positionEdgeLabel
+} from "./chunk-TRQY2T3P.mjs";
+import {
+  insertCluster,
+  insertNode,
+  labelHelper
+} from "./chunk-HQMLCRZ6.mjs";
+import {
+  interpolateToCurve
+} from "./chunk-BSZA5ISF.mjs";
+import {
+  common_default,
+  getConfig
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  log
+} from "./chunk-V7P66DNM.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/internals.ts
+var internalHelpers = {
+  common: common_default,
+  getConfig,
+  insertCluster,
+  insertEdge,
+  insertEdgeLabel,
+  insertMarkers: markers_default,
+  insertNode,
+  interpolateToCurve,
+  labelHelper,
+  log,
+  positionEdgeLabel
+};
+
+// src/rendering-util/render.ts
+var layoutAlgorithms = {};
+var registerLayoutLoaders = /* @__PURE__ */ __name((loaders) => {
+  for (const loader of loaders) {
+    layoutAlgorithms[loader.name] = loader;
+  }
+}, "registerLayoutLoaders");
+var registerDefaultLayoutLoaders = /* @__PURE__ */ __name(() => {
+  registerLayoutLoaders([
+    {
+      name: "dagre",
+      loader: /* @__PURE__ */ __name(async () => await import("./dagre-ZXKKJJHT.mjs"), "loader")
+    },
+    ...true ? [
+      {
+        name: "cose-bilkent",
+        loader: /* @__PURE__ */ __name(async () => await import("./cose-bilkent-WZ3F43K2.mjs"), "loader")
+      }
+    ] : []
+  ]);
+}, "registerDefaultLayoutLoaders");
+registerDefaultLayoutLoaders();
+var render = /* @__PURE__ */ __name(async (data4Layout, svg) => {
+  if (!(data4Layout.layoutAlgorithm in layoutAlgorithms)) {
+    throw new Error(`Unknown layout algorithm: ${data4Layout.layoutAlgorithm}`);
+  }
+  if (data4Layout.diagramId) {
+    for (const node of data4Layout.nodes) {
+      const originalDomId = node.domId || node.id;
+      node.domId = `${data4Layout.diagramId}-${originalDomId}`;
+    }
+  }
+  const layoutDefinition = layoutAlgorithms[data4Layout.layoutAlgorithm];
+  const layoutRenderer = await layoutDefinition.loader();
+  const { theme, themeVariables } = data4Layout.config;
+  const { useGradient, gradientStart, gradientStop } = themeVariables;
+  const svgId = svg.attr("id");
+  svg.append("defs").append("filter").attr("id", `${svgId}-drop-shadow`).attr("height", "130%").attr("width", "130%").append("feDropShadow").attr("dx", "4").attr("dy", "4").attr("stdDeviation", 0).attr("flood-opacity", "0.06").attr("flood-color", `${theme?.includes("dark") ? "#FFFFFF" : "#000000"}`);
+  svg.append("defs").append("filter").attr("id", `${svgId}-drop-shadow-small`).attr("height", "150%").attr("width", "150%").append("feDropShadow").attr("dx", "2").attr("dy", "2").attr("stdDeviation", 0).attr("flood-opacity", "0.06").attr("flood-color", `${theme?.includes("dark") ? "#FFFFFF" : "#000000"}`);
+  if (useGradient) {
+    const gradient = svg.append("linearGradient").attr("id", svg.attr("id") + "-gradient").attr("gradientUnits", "objectBoundingBox").attr("x1", "0%").attr("y1", "0%").attr("x2", "100%").attr("y2", "0%");
+    gradient.append("svg:stop").attr("offset", "0%").attr("stop-color", gradientStart).attr("stop-opacity", 1);
+    gradient.append("svg:stop").attr("offset", "100%").attr("stop-color", gradientStop).attr("stop-opacity", 1);
+  }
+  return layoutRenderer.render(data4Layout, svg, internalHelpers, {
+    algorithm: layoutDefinition.algorithm
+  });
+}, "render");
+var getRegisteredLayoutAlgorithm = /* @__PURE__ */ __name((algorithm = "", { fallback = "dagre" } = {}) => {
+  if (algorithm in layoutAlgorithms) {
+    return algorithm;
+  }
+  if (fallback in layoutAlgorithms) {
+    log.warn(`Layout algorithm ${algorithm} is not registered. Using ${fallback} as fallback.`);
+    return fallback;
+  }
+  throw new Error(`Both layout algorithms ${algorithm} and ${fallback} are not registered.`);
+}, "getRegisteredLayoutAlgorithm");
+
+export {
+  registerLayoutLoaders,
+  render,
+  getRegisteredLayoutAlgorithm
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-SZ5Y56Q4.mjs

@@ -0,0 +1,68 @@
+import {
+  parseFontSize
+} from "./chunk-BSZA5ISF.mjs";
+import {
+  defaultConfig_default,
+  getConfig2 as getConfig
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/utils/subGraphTitleMargins.ts
+var getSubGraphTitleMargins = /* @__PURE__ */ __name(({
+  flowchart
+}) => {
+  const subGraphTitleTopMargin = flowchart?.subGraphTitleMargin?.top ?? 0;
+  const subGraphTitleBottomMargin = flowchart?.subGraphTitleMargin?.bottom ?? 0;
+  const subGraphTitleTotalMargin = subGraphTitleTopMargin + subGraphTitleBottomMargin;
+  return {
+    subGraphTitleTopMargin,
+    subGraphTitleBottomMargin,
+    subGraphTitleTotalMargin
+  };
+}, "getSubGraphTitleMargins");
+
+// src/rendering-util/rendering-elements/shapes/labelImageUtils.ts
+async function configureLabelImages(container, labelText) {
+  const images = container.getElementsByTagName("img");
+  if (!images || images.length === 0) {
+    return;
+  }
+  const noImgText = labelText.replace(/<img[^>]*>/g, "").trim() === "";
+  await Promise.all(
+    [...images].map(
+      (img) => new Promise((res) => {
+        function setupImage() {
+          img.style.display = "flex";
+          img.style.flexDirection = "column";
+          if (noImgText) {
+            const bodyFontSize = getConfig().fontSize ? getConfig().fontSize : window.getComputedStyle(document.body).fontSize;
+            const enlargingFactor = 5;
+            const [parsedBodyFontSize = defaultConfig_default.fontSize] = parseFontSize(bodyFontSize);
+            const width = parsedBodyFontSize * enlargingFactor + "px";
+            img.style.minWidth = width;
+            img.style.maxWidth = width;
+          } else {
+            img.style.width = "100%";
+          }
+          res(img);
+        }
+        __name(setupImage, "setupImage");
+        setTimeout(() => {
+          if (img.complete) {
+            setupImage();
+          }
+        });
+        img.addEventListener("error", setupImage);
+        img.addEventListener("load", setupImage);
+      })
+    )
+  );
+}
+__name(configureLabelImages, "configureLabelImages");
+
+export {
+  configureLabelImages,
+  getSubGraphTitleMargins
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-SZ5Y56Q4.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/subGraphTitleMargins.ts", "../../../src/rendering-util/rendering-elements/shapes/labelImageUtils.ts"],
+  "sourcesContent": ["import type { FlowchartDiagramConfig } from '../config.type.js';\n\nexport const getSubGraphTitleMargins = ({\n  flowchart,\n}: {\n  flowchart: FlowchartDiagramConfig;\n}): {\n  subGraphTitleTopMargin: number;\n  subGraphTitleBottomMargin: number;\n  subGraphTitleTotalMargin: number;\n} => {\n  const subGraphTitleTopMargin = flowchart?.subGraphTitleMargin?.top ?? 0;\n  const subGraphTitleBottomMargin = flowchart?.subGraphTitleMargin?.bottom ?? 0;\n  const subGraphTitleTotalMargin = subGraphTitleTopMargin + subGraphTitleBottomMargin;\n\n  return {\n    subGraphTitleTopMargin,\n    subGraphTitleBottomMargin,\n    subGraphTitleTotalMargin,\n  };\n};\n", "import { getConfig } from '../../../diagram-api/diagramAPI.js';\nimport defaultConfig from '../../../defaultConfig.js';\nimport { parseFontSize } from '../../../utils.js';\n\n/**\n * Waits for all images in a container to load and applies appropriate styling.\n * This ensures accurate bounding box measurements after images are loaded.\n *\n * @param container - The HTML element containing img tags\n * @param labelText - The original label text to check if there's text besides images\n * @returns Promise that resolves when all images are loaded and styled\n */\nexport async function configureLabelImages(\n  container: HTMLElement,\n  labelText: string\n): Promise<void> {\n  const images = container.getElementsByTagName('img');\n  if (!images || images.length === 0) {\n    return;\n  }\n\n  const noImgText = labelText.replace(/<img[^>]*>/g, '').trim() === '';\n\n  await Promise.all(\n    [...images].map(\n      (img) =>\n        new Promise((res) => {\n          function setupImage() {\n            img.style.display = 'flex';\n            img.style.flexDirection = 'column';\n\n            if (noImgText) {\n              // default size if no text\n              const bodyFontSize = getConfig().fontSize\n                ? getConfig().fontSize\n                : window.getComputedStyle(document.body).fontSize;\n              const enlargingFactor = 5;\n              const [parsedBodyFontSize = defaultConfig.fontSize] = parseFontSize(bodyFontSize);\n              const width = parsedBodyFontSize * enlargingFactor + 'px';\n              img.style.minWidth = width;\n              img.style.maxWidth = width;\n            } else {\n              img.style.width = '100%';\n            }\n            res(img);\n          }\n          setTimeout(() => {\n            if (img.complete) {\n              setupImage();\n            }\n          });\n          img.addEventListener('error', setupImage);\n          img.addEventListener('load', setupImage);\n        })\n    )\n  );\n}\n"],
+  "mappings": ";;;;;;;;;;;;AAEO,IAAM,0BAA0B,wBAAC;AAAA,EACtC;AACF,MAMK;AACH,QAAM,yBAAyB,WAAW,qBAAqB,OAAO;AACtE,QAAM,4BAA4B,WAAW,qBAAqB,UAAU;AAC5E,QAAM,2BAA2B,yBAAyB;AAE1D,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF,GAlBuC;;;ACUvC,eAAsB,qBACpB,WACA,WACe;AACf,QAAM,SAAS,UAAU,qBAAqB,KAAK;AACnD,MAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC;AAAA,EACF;AAEA,QAAM,YAAY,UAAU,QAAQ,eAAe,EAAE,EAAE,KAAK,MAAM;AAElE,QAAM,QAAQ;AAAA,IACZ,CAAC,GAAG,MAAM,EAAE;AAAA,MACV,CAAC,QACC,IAAI,QAAQ,CAAC,QAAQ;AACnB,iBAAS,aAAa;AACpB,cAAI,MAAM,UAAU;AACpB,cAAI,MAAM,gBAAgB;AAE1B,cAAI,WAAW;AAEb,kBAAM,eAAe,UAAU,EAAE,WAC7B,UAAU,EAAE,WACZ,OAAO,iBAAiB,SAAS,IAAI,EAAE;AAC3C,kBAAM,kBAAkB;AACxB,kBAAM,CAAC,qBAAqB,sBAAc,QAAQ,IAAI,cAAc,YAAY;AAChF,kBAAM,QAAQ,qBAAqB,kBAAkB;AACrD,gBAAI,MAAM,WAAW;AACrB,gBAAI,MAAM,WAAW;AAAA,UACvB,OAAO;AACL,gBAAI,MAAM,QAAQ;AAAA,UACpB;AACA,cAAI,GAAG;AAAA,QACT;AAlBS;AAmBT,mBAAW,MAAM;AACf,cAAI,IAAI,UAAU;AAChB,uBAAW;AAAA,UACb;AAAA,QACF,CAAC;AACD,YAAI,iBAAiB,SAAS,UAAU;AACxC,YAAI,iBAAiB,QAAQ,UAAU;AAAA,MACzC,CAAC;AAAA,IACL;AAAA,EACF;AACF;AA5CsB;",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-WM6EUEOH.mjs

@@ -0,0 +1,53 @@
+import {
+  AbstractMermaidTokenBuilder,
+  CommonValueConverter,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  RadarGrammarGeneratedModule,
+  __name as __name2,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../parser/dist/chunks/mermaid-parser.core/chunk-FHYWG6QK.mjs
+var RadarTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "RadarTokenBuilder");
+  }
+  static {
+    __name2(this, "RadarTokenBuilder");
+  }
+  constructor() {
+    super(["radar-beta"]);
+  }
+};
+var RadarModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name2(() => new RadarTokenBuilder(), "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name2(() => new CommonValueConverter(), "ValueConverter")
+  }
+};
+function createRadarServices(context = EmptyFileSystem) {
+  const shared = inject(
+    createDefaultSharedCoreModule(context),
+    MermaidGeneratedSharedModule
+  );
+  const Radar = inject(
+    createDefaultCoreModule({ shared }),
+    RadarGrammarGeneratedModule,
+    RadarModule
+  );
+  shared.ServiceRegistry.register(Radar);
+  return { shared, Radar };
+}
+__name(createRadarServices, "createRadarServices");
+__name2(createRadarServices, "createRadarServices");
+
+export {
+  RadarModule,
+  createRadarServices
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/chunk-WM6EUEOH.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-FHYWG6QK.mjs"],
+  "sourcesContent": ["import {\n  AbstractMermaidTokenBuilder,\n  CommonValueConverter,\n  EmptyFileSystem,\n  MermaidGeneratedSharedModule,\n  RadarGrammarGeneratedModule,\n  __name,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject,\n  lib_exports\n} from \"./chunk-NNHCCRGN.mjs\";\n\n// src/language/radar/tokenBuilder.ts\nvar RadarTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"RadarTokenBuilder\");\n  }\n  constructor() {\n    super([\"radar-beta\"]);\n  }\n};\n\n// src/language/radar/module.ts\nvar RadarModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new RadarTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createRadarServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const Radar = inject(\n    createDefaultCoreModule({ shared }),\n    RadarGrammarGeneratedModule,\n    RadarModule\n  );\n  shared.ServiceRegistry.register(Radar);\n  return { shared, Radar };\n}\n__name(createRadarServices, \"createRadarServices\");\n\nexport {\n  RadarModule,\n  createRadarServices\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAcA,IAAI,oBAAoB,cAAc,4BAA4B;AAAA,EAdlE,OAckE;AAAA;AAAA;AAAA,EAChE,OAAO;AACL,IAAAA,QAAO,MAAM,mBAAmB;AAAA,EAClC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,YAAY,CAAC;AAAA,EACtB;AACF;AAGA,IAAI,cAAc;AAAA,EAChB,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,kBAAkB,GAAG,cAAc;AAAA,IAClF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,gBAAgB;AAAA,EAC3F;AACF;AACA,SAAS,oBAAoB,UAAU,iBAAiB;AACtD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,QAAQ;AAAA,IACZ,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,KAAK;AACrC,SAAO,EAAE,QAAQ,MAAM;AACzB;AAZS;AAaTA,QAAO,qBAAqB,qBAAqB;",
+  "names": ["__name"]
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/classDiagram-SEOGYEGJ.mjs

@@ -0,0 +1,44 @@
+import {
+  ClassDB,
+  classDiagram_default,
+  classRenderer_v3_unified_default,
+  styles_default
+} from "./chunk-VFD24L5A.mjs";
+import "./chunk-RTBOCTTP.mjs";
+import "./chunk-O4A3IS3O.mjs";
+import "./chunk-7723GVCQ.mjs";
+import "./chunk-KEUPHFFI.mjs";
+import "./chunk-SNQTKDUU.mjs";
+import "./chunk-TRQY2T3P.mjs";
+import "./chunk-HQMLCRZ6.mjs";
+import "./chunk-PLCLPJVV.mjs";
+import "./chunk-GTILCTU2.mjs";
+import "./chunk-RTI7CJYH.mjs";
+import "./chunk-SZ5Y56Q4.mjs";
+import "./chunk-YSJUE5HW.mjs";
+import "./chunk-BSZA5ISF.mjs";
+import "./chunk-7TFACZ55.mjs";
+import "./chunk-Q52JI7PB.mjs";
+import "./chunk-V7P66DNM.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/diagrams/class/classDiagram.ts
+var diagram = {
+  parser: classDiagram_default,
+  get db() {
+    return new ClassDB();
+  },
+  renderer: classRenderer_v3_unified_default,
+  styles: styles_default,
+  init: /* @__PURE__ */ __name((cnf) => {
+    if (!cnf.class) {
+      cnf.class = {};
+    }
+    cnf.class.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute;
+  }, "init")
+};
+export {
+  diagram
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/classDiagram-SEOGYEGJ.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/diagrams/class/classDiagram.ts"],
+  "sourcesContent": ["import type { DiagramDefinition } from '../../diagram-api/types.js';\n// @ts-ignore: JISON doesn't support types\nimport parser from './parser/classDiagram.jison';\nimport { ClassDB } from './classDb.js';\nimport styles from './styles.js';\nimport renderer from './classRenderer-v3-unified.js';\n\nexport const diagram: DiagramDefinition = {\n  parser,\n  get db() {\n    return new ClassDB();\n  },\n  renderer,\n  styles,\n  init: (cnf) => {\n    if (!cnf.class) {\n      cnf.class = {};\n    }\n    cnf.class.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute;\n  },\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,IAAM,UAA6B;AAAA,EACxC;AAAA,EACA,IAAI,KAAK;AACP,WAAO,IAAI,QAAQ;AAAA,EACrB;AAAA,EACA;AAAA,EACA;AAAA,EACA,MAAM,wBAAC,QAAQ;AACb,QAAI,CAAC,IAAI,OAAO;AACd,UAAI,QAAQ,CAAC;AAAA,IACf;AACA,QAAI,MAAM,sBAAsB,IAAI;AAAA,EACtC,GALM;AAMR;",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/classDiagram-v2-AOBZDD47.mjs

@@ -0,0 +1,44 @@
+import {
+  ClassDB,
+  classDiagram_default,
+  classRenderer_v3_unified_default,
+  styles_default
+} from "./chunk-VFD24L5A.mjs";
+import "./chunk-RTBOCTTP.mjs";
+import "./chunk-O4A3IS3O.mjs";
+import "./chunk-7723GVCQ.mjs";
+import "./chunk-KEUPHFFI.mjs";
+import "./chunk-SNQTKDUU.mjs";
+import "./chunk-TRQY2T3P.mjs";
+import "./chunk-HQMLCRZ6.mjs";
+import "./chunk-PLCLPJVV.mjs";
+import "./chunk-GTILCTU2.mjs";
+import "./chunk-RTI7CJYH.mjs";
+import "./chunk-SZ5Y56Q4.mjs";
+import "./chunk-YSJUE5HW.mjs";
+import "./chunk-BSZA5ISF.mjs";
+import "./chunk-7TFACZ55.mjs";
+import "./chunk-Q52JI7PB.mjs";
+import "./chunk-V7P66DNM.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/diagrams/class/classDiagram-v2.ts
+var diagram = {
+  parser: classDiagram_default,
+  get db() {
+    return new ClassDB();
+  },
+  renderer: classRenderer_v3_unified_default,
+  styles: styles_default,
+  init: /* @__PURE__ */ __name((cnf) => {
+    if (!cnf.class) {
+      cnf.class = {};
+    }
+    cnf.class.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute;
+  }, "init")
+};
+export {
+  diagram
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/classDiagram-v2-AOBZDD47.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/diagrams/class/classDiagram-v2.ts"],
+  "sourcesContent": ["import type { DiagramDefinition } from '../../diagram-api/types.js';\n// @ts-ignore: JISON doesn't support types\nimport parser from './parser/classDiagram.jison';\nimport { ClassDB } from './classDb.js';\nimport styles from './styles.js';\nimport renderer from './classRenderer-v3-unified.js';\n\nexport const diagram: DiagramDefinition = {\n  parser,\n  get db() {\n    return new ClassDB();\n  },\n  renderer,\n  styles,\n  init: (cnf) => {\n    if (!cnf.class) {\n      cnf.class = {};\n    }\n    cnf.class.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute;\n  },\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,IAAM,UAA6B;AAAA,EACxC;AAAA,EACA,IAAI,KAAK;AACP,WAAO,IAAI,QAAQ;AAAA,EACrB;AAAA,EACA;AAAA,EACA;AAAA,EACA,MAAM,wBAAC,QAAQ;AACb,QAAI,CAAC,IAAI,OAAO;AACd,UAAI,QAAQ,CAAC;AAAA,IACf;AACA,QAAI,MAAM,sBAAsB,IAAI;AAAA,EACtC,GALM;AAMR;",
+  "names": []
+}

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/dagre-ZXKKJJHT.mjs

@@ -0,0 +1,750 @@
+import {
+  layout
+} from "./chunk-T5XCKZAJ.mjs";
+import {
+  Graph,
+  clone_default,
+  isUndefined_default,
+  map_default
+} from "./chunk-XAKTCX7R.mjs";
+import {
+  clear as clear2,
+  insertEdge,
+  insertEdgeLabel,
+  markers_default,
+  positionEdgeLabel
+} from "./chunk-TRQY2T3P.mjs";
+import {
+  clear,
+  clear2 as clear3,
+  insertCluster,
+  insertNode,
+  positionNode,
+  setNodeElem,
+  updateNodeBounds
+} from "./chunk-HQMLCRZ6.mjs";
+import "./chunk-PLCLPJVV.mjs";
+import "./chunk-GTILCTU2.mjs";
+import "./chunk-RTI7CJYH.mjs";
+import {
+  getSubGraphTitleMargins
+} from "./chunk-SZ5Y56Q4.mjs";
+import "./chunk-YSJUE5HW.mjs";
+import "./chunk-BSZA5ISF.mjs";
+import "./chunk-7TFACZ55.mjs";
+import {
+  getConfig2 as getConfig
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  log
+} from "./chunk-V7P66DNM.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/graphlib/json.js
+function write(g) {
+  var json = {
+    options: {
+      directed: g.isDirected(),
+      multigraph: g.isMultigraph(),
+      compound: g.isCompound()
+    },
+    nodes: writeNodes(g),
+    edges: writeEdges(g)
+  };
+  if (!isUndefined_default(g.graph())) {
+    json.value = clone_default(g.graph());
+  }
+  return json;
+}
+__name(write, "write");
+function writeNodes(g) {
+  return map_default(g.nodes(), function(v) {
+    var nodeValue = g.node(v);
+    var parent = g.parent(v);
+    var node = { v };
+    if (!isUndefined_default(nodeValue)) {
+      node.value = nodeValue;
+    }
+    if (!isUndefined_default(parent)) {
+      node.parent = parent;
+    }
+    return node;
+  });
+}
+__name(writeNodes, "writeNodes");
+function writeEdges(g) {
+  return map_default(g.edges(), function(e) {
+    var edgeValue = g.edge(e);
+    var edge = { v: e.v, w: e.w };
+    if (!isUndefined_default(e.name)) {
+      edge.name = e.name;
+    }
+    if (!isUndefined_default(edgeValue)) {
+      edge.value = edgeValue;
+    }
+    return edge;
+  });
+}
+__name(writeEdges, "writeEdges");
+
+// src/rendering-util/layout-algorithms/dagre/mermaid-graphlib.js
+var clusterDb = /* @__PURE__ */ new Map();
+var descendants = /* @__PURE__ */ new Map();
+var parents = /* @__PURE__ */ new Map();
+var clear4 = /* @__PURE__ */ __name(() => {
+  descendants.clear();
+  parents.clear();
+  clusterDb.clear();
+}, "clear");
+var isDescendant = /* @__PURE__ */ __name((id, ancestorId) => {
+  const ancestorDescendants = descendants.get(ancestorId) || [];
+  log.trace("In isDescendant", ancestorId, " ", id, " = ", ancestorDescendants.includes(id));
+  return ancestorDescendants.includes(id);
+}, "isDescendant");
+var edgeInCluster = /* @__PURE__ */ __name((edge, clusterId) => {
+  const clusterDescendants = descendants.get(clusterId) || [];
+  log.info("Descendants of ", clusterId, " is ", clusterDescendants);
+  log.info("Edge is ", edge);
+  if (edge.v === clusterId || edge.w === clusterId) {
+    return false;
+  }
+  if (!clusterDescendants) {
+    log.debug("Tilt, ", clusterId, ",not in descendants");
+    return false;
+  }
+  return clusterDescendants.includes(edge.v) || isDescendant(edge.v, clusterId) || isDescendant(edge.w, clusterId) || clusterDescendants.includes(edge.w);
+}, "edgeInCluster");
+var copy = /* @__PURE__ */ __name((clusterId, graph, newGraph, rootId) => {
+  log.warn(
+    "Copying children of ",
+    clusterId,
+    "root",
+    rootId,
+    "data",
+    graph.node(clusterId),
+    rootId
+  );
+  const nodes = graph.children(clusterId) || [];
+  if (clusterId !== rootId) {
+    nodes.push(clusterId);
+  }
+  log.warn("Copying (nodes) clusterId", clusterId, "nodes", nodes);
+  nodes.forEach((node) => {
+    if (graph.children(node).length > 0) {
+      copy(node, graph, newGraph, rootId);
+    } else {
+      const data = graph.node(node);
+      log.info("cp ", node, " to ", rootId, " with parent ", clusterId);
+      newGraph.setNode(node, data);
+      if (rootId !== graph.parent(node)) {
+        log.warn("Setting parent", node, graph.parent(node));
+        newGraph.setParent(node, graph.parent(node));
+      }
+      if (clusterId !== rootId && node !== clusterId) {
+        log.debug("Setting parent", node, clusterId);
+        newGraph.setParent(node, clusterId);
+      } else {
+        log.info("In copy ", clusterId, "root", rootId, "data", graph.node(clusterId), rootId);
+        log.debug(
+          "Not Setting parent for node=",
+          node,
+          "cluster!==rootId",
+          clusterId !== rootId,
+          "node!==clusterId",
+          node !== clusterId
+        );
+      }
+      const edges = graph.edges(node);
+      log.debug("Copying Edges", edges);
+      edges.forEach((edge) => {
+        log.info("Edge", edge);
+        const data2 = graph.edge(edge.v, edge.w, edge.name);
+        log.info("Edge data", data2, rootId);
+        try {
+          if (edgeInCluster(edge, rootId)) {
+            log.info("Copying as ", edge.v, edge.w, data2, edge.name);
+            newGraph.setEdge(edge.v, edge.w, data2, edge.name);
+            log.info("newGraph edges ", newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
+          } else {
+            log.info(
+              "Skipping copy of edge ",
+              edge.v,
+              "-->",
+              edge.w,
+              " rootId: ",
+              rootId,
+              " clusterId:",
+              clusterId
+            );
+          }
+        } catch (e) {
+          log.error(e);
+        }
+      });
+    }
+    log.debug("Removing node", node);
+    graph.removeNode(node);
+  });
+}, "copy");
+var extractDescendants = /* @__PURE__ */ __name((id, graph) => {
+  const children = graph.children(id);
+  let res = [...children];
+  for (const child of children) {
+    parents.set(child, id);
+    res = [...res, ...extractDescendants(child, graph)];
+  }
+  return res;
+}, "extractDescendants");
+var findCommonEdges = /* @__PURE__ */ __name((graph, id1, id2) => {
+  const edges1 = graph.edges().filter((edge) => edge.v === id1 || edge.w === id1);
+  const edges2 = graph.edges().filter((edge) => edge.v === id2 || edge.w === id2);
+  const edges1Prim = edges1.map((edge) => {
+    return { v: edge.v === id1 ? id2 : edge.v, w: edge.w === id1 ? id1 : edge.w };
+  });
+  const edges2Prim = edges2.map((edge) => {
+    return { v: edge.v, w: edge.w };
+  });
+  const result = edges1Prim.filter((edgeIn1) => {
+    return edges2Prim.some((edge) => edgeIn1.v === edge.v && edgeIn1.w === edge.w);
+  });
+  return result;
+}, "findCommonEdges");
+var findNonClusterChild = /* @__PURE__ */ __name((id, graph, clusterId) => {
+  const children = graph.children(id);
+  log.trace("Searching children of id ", id, children);
+  if (children.length < 1) {
+    return id;
+  }
+  let reserve;
+  for (const child of children) {
+    const _id = findNonClusterChild(child, graph, clusterId);
+    const commonEdges = findCommonEdges(graph, clusterId, _id);
+    if (_id) {
+      if (commonEdges.length > 0) {
+        reserve = _id;
+      } else {
+        return _id;
+      }
+    }
+  }
+  return reserve;
+}, "findNonClusterChild");
+var getAnchorId = /* @__PURE__ */ __name((id) => {
+  if (!clusterDb.has(id)) {
+    return id;
+  }
+  if (!clusterDb.get(id).externalConnections) {
+    return id;
+  }
+  if (clusterDb.has(id)) {
+    return clusterDb.get(id).id;
+  }
+  return id;
+}, "getAnchorId");
+var adjustClustersAndEdges = /* @__PURE__ */ __name((graph, depth) => {
+  if (!graph || depth > 10) {
+    log.debug("Opting out, no graph ");
+    return;
+  } else {
+    log.debug("Opting in, graph ");
+  }
+  graph.nodes().forEach(function(id) {
+    const children = graph.children(id);
+    if (children.length > 0) {
+      log.warn(
+        "Cluster identified",
+        id,
+        " Replacement id in edges: ",
+        findNonClusterChild(id, graph, id)
+      );
+      descendants.set(id, extractDescendants(id, graph));
+      clusterDb.set(id, { id: findNonClusterChild(id, graph, id), clusterData: graph.node(id) });
+    }
+  });
+  graph.nodes().forEach(function(id) {
+    const children = graph.children(id);
+    const edges = graph.edges();
+    if (children.length > 0) {
+      log.debug("Cluster identified", id, descendants);
+      edges.forEach((edge) => {
+        const d1 = isDescendant(edge.v, id);
+        const d2 = isDescendant(edge.w, id);
+        if (d1 ^ d2) {
+          log.warn("Edge: ", edge, " leaves cluster ", id);
+          log.warn("Descendants of XXX ", id, ": ", descendants.get(id));
+          clusterDb.get(id).externalConnections = true;
+        }
+      });
+    } else {
+      log.debug("Not a cluster ", id, descendants);
+    }
+  });
+  for (let id of clusterDb.keys()) {
+    const nonClusterChild = clusterDb.get(id).id;
+    const parent = graph.parent(nonClusterChild);
+    if (parent !== id && clusterDb.has(parent) && !clusterDb.get(parent).externalConnections) {
+      clusterDb.get(id).id = parent;
+    }
+  }
+  graph.edges().forEach(function(e) {
+    const edge = graph.edge(e);
+    log.warn("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e));
+    log.warn("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(graph.edge(e)));
+    let v = e.v;
+    let w = e.w;
+    log.warn(
+      "Fix XXX",
+      clusterDb,
+      "ids:",
+      e.v,
+      e.w,
+      "Translating: ",
+      clusterDb.get(e.v),
+      " --- ",
+      clusterDb.get(e.w)
+    );
+    if (clusterDb.get(e.v) || clusterDb.get(e.w)) {
+      log.warn("Fixing and trying - removing XXX", e.v, e.w, e.name);
+      v = getAnchorId(e.v);
+      w = getAnchorId(e.w);
+      graph.removeEdge(e.v, e.w, e.name);
+      if (v !== e.v) {
+        const parent = graph.parent(v);
+        clusterDb.get(parent).externalConnections = true;
+        edge.fromCluster = e.v;
+      }
+      if (w !== e.w) {
+        const parent = graph.parent(w);
+        clusterDb.get(parent).externalConnections = true;
+        edge.toCluster = e.w;
+      }
+      log.warn("Fix Replacing with XXX", v, w, e.name);
+      graph.setEdge(v, w, edge, e.name);
+    }
+  });
+  log.warn("Adjusted Graph", write(graph));
+  extractor(graph, 0);
+  log.trace(clusterDb);
+}, "adjustClustersAndEdges");
+var extractor = /* @__PURE__ */ __name((graph, depth) => {
+  log.warn("extractor - ", depth, write(graph), graph.children("D"));
+  if (depth > 10) {
+    log.error("Bailing out");
+    return;
+  }
+  let nodes = graph.nodes();
+  let hasChildren = false;
+  for (const node of nodes) {
+    const children = graph.children(node);
+    hasChildren = hasChildren || children.length > 0;
+  }
+  if (!hasChildren) {
+    log.debug("Done, no node has children", graph.nodes());
+    return;
+  }
+  log.debug("Nodes = ", nodes, depth);
+  for (const node of nodes) {
+    log.debug(
+      "Extracting node",
+      node,
+      clusterDb,
+      clusterDb.has(node) && !clusterDb.get(node).externalConnections,
+      !graph.parent(node),
+      graph.node(node),
+      graph.children("D"),
+      " Depth ",
+      depth
+    );
+    if (!clusterDb.has(node)) {
+      log.debug("Not a cluster", node, depth);
+    } else if (!clusterDb.get(node).externalConnections && graph.children(node) && graph.children(node).length > 0) {
+      log.warn(
+        "Cluster without external connections, without a parent and with children",
+        node,
+        depth
+      );
+      const graphSettings = graph.graph();
+      let dir = graphSettings.rankdir === "TB" ? "LR" : "TB";
+      if (clusterDb.get(node)?.clusterData?.dir) {
+        dir = clusterDb.get(node).clusterData.dir;
+        log.warn("Fixing dir", clusterDb.get(node).clusterData.dir, dir);
+      }
+      const clusterGraph = new Graph({
+        multigraph: true,
+        compound: true
+      }).setGraph({
+        rankdir: dir,
+        nodesep: 50,
+        ranksep: 50,
+        marginx: 8,
+        marginy: 8
+      }).setDefaultEdgeLabel(function() {
+        return {};
+      });
+      log.warn("Old graph before copy", write(graph));
+      copy(node, graph, clusterGraph, node);
+      graph.setNode(node, {
+        clusterNode: true,
+        id: node,
+        clusterData: clusterDb.get(node).clusterData,
+        label: clusterDb.get(node).label,
+        graph: clusterGraph
+      });
+      log.warn("New graph after copy node: (", node, ")", write(clusterGraph));
+      log.debug("Old graph after copy", write(graph));
+    } else {
+      log.warn(
+        "Cluster ** ",
+        node,
+        " **not meeting the criteria !externalConnections:",
+        !clusterDb.get(node).externalConnections,
+        " no parent: ",
+        !graph.parent(node),
+        " children ",
+        graph.children(node) && graph.children(node).length > 0,
+        graph.children("D"),
+        depth
+      );
+      log.debug(clusterDb);
+    }
+  }
+  nodes = graph.nodes();
+  log.warn("New list of nodes", nodes);
+  for (const node of nodes) {
+    const data = graph.node(node);
+    log.warn(" Now next level", node, data);
+    if (data?.clusterNode) {
+      extractor(data.graph, depth + 1);
+    }
+  }
+}, "extractor");
+var sorter = /* @__PURE__ */ __name((graph, nodes) => {
+  if (nodes.length === 0) {
+    return [];
+  }
+  let result = Object.assign([], nodes);
+  nodes.forEach((node) => {
+    const children = graph.children(node);
+    const sorted = sorter(graph, children);
+    result = [...result, ...sorted];
+  });
+  return result;
+}, "sorter");
+var sortNodesByHierarchy = /* @__PURE__ */ __name((graph) => sorter(graph, graph.children()), "sortNodesByHierarchy");
+
+// src/rendering-util/layout-algorithms/dagre/index.js
+var recursiveRender = /* @__PURE__ */ __name(async (_elem, graph, diagramType, id, parentCluster, siteConfig) => {
+  log.warn("Graph in recursive render:XAX", write(graph), parentCluster);
+  const dir = graph.graph().rankdir;
+  log.trace("Dir in recursive render - dir:", dir);
+  const elem = _elem.insert("g").attr("class", "root");
+  if (!graph.nodes()) {
+    log.info("No nodes found for", graph);
+  } else {
+    log.info("Recursive render XXX", graph.nodes());
+  }
+  if (graph.edges().length > 0) {
+    log.info("Recursive edges", graph.edge(graph.edges()[0]));
+  }
+  const clusters = elem.insert("g").attr("class", "clusters");
+  const edgePaths = elem.insert("g").attr("class", "edgePaths");
+  const edgeLabels = elem.insert("g").attr("class", "edgeLabels");
+  const nodes = elem.insert("g").attr("class", "nodes");
+  await Promise.all(
+    graph.nodes().map(async function(v) {
+      const node = graph.node(v);
+      if (parentCluster !== void 0) {
+        const data = JSON.parse(JSON.stringify(parentCluster.clusterData));
+        log.trace(
+          "Setting data for parent cluster XXX\n Node.id = ",
+          v,
+          "\n data=",
+          data.height,
+          "\nParent cluster",
+          parentCluster.height
+        );
+        graph.setNode(parentCluster.id, data);
+        if (!graph.parent(v)) {
+          log.trace("Setting parent", v, parentCluster.id);
+          graph.setParent(v, parentCluster.id, data);
+        }
+      }
+      log.info("(Insert) Node XXX" + v + ": " + JSON.stringify(graph.node(v)));
+      if (node?.clusterNode) {
+        log.info("Cluster identified XBX", v, node.width, graph.node(v));
+        const { ranksep, nodesep } = graph.graph();
+        node.graph.setGraph({
+          ...node.graph.graph(),
+          ranksep: ranksep + 25,
+          nodesep
+        });
+        const o = await recursiveRender(
+          nodes,
+          node.graph,
+          diagramType,
+          id,
+          graph.node(v),
+          siteConfig
+        );
+        const newEl = o.elem;
+        updateNodeBounds(node, newEl);
+        node.diff = o.diff || 0;
+        log.info(
+          "New compound node after recursive render XAX",
+          v,
+          "width",
+          // node,
+          node.width,
+          "height",
+          node.height
+          // node.x,
+          // node.y
+        );
+        setNodeElem(newEl, node);
+      } else {
+        if (graph.children(v).length > 0) {
+          log.trace(
+            "Cluster - the non recursive path XBX",
+            v,
+            node.id,
+            node,
+            node.width,
+            "Graph:",
+            graph
+          );
+          log.trace(findNonClusterChild(node.id, graph));
+          clusterDb.set(node.id, { id: findNonClusterChild(node.id, graph), node });
+        } else {
+          log.trace("Node - the non recursive path XAX", v, nodes, graph.node(v), dir);
+          await insertNode(nodes, graph.node(v), { config: siteConfig, dir });
+        }
+      }
+    })
+  );
+  const processEdges = /* @__PURE__ */ __name(async () => {
+    const edgePromises = graph.edges().map(async function(e) {
+      const edge = graph.edge(e.v, e.w, e.name);
+      log.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e));
+      log.info("Edge " + e.v + " -> " + e.w + ": ", e, " ", JSON.stringify(graph.edge(e)));
+      log.info(
+        "Fix",
+        clusterDb,
+        "ids:",
+        e.v,
+        e.w,
+        "Translating: ",
+        clusterDb.get(e.v),
+        clusterDb.get(e.w)
+      );
+      await insertEdgeLabel(edgeLabels, edge);
+    });
+    await Promise.all(edgePromises);
+  }, "processEdges");
+  await processEdges();
+  log.info("Graph before layout:", JSON.stringify(write(graph)));
+  log.info("############################################# XXX");
+  log.info("###                Layout                 ### XXX");
+  log.info("############################################# XXX");
+  layout(graph);
+  log.info("Graph after layout:", JSON.stringify(write(graph)));
+  let diff = 0;
+  let { subGraphTitleTotalMargin } = getSubGraphTitleMargins(siteConfig);
+  await Promise.all(
+    sortNodesByHierarchy(graph).map(async function(v) {
+      const node = graph.node(v);
+      log.info(
+        "Position XBX => " + v + ": (" + node.x,
+        "," + node.y,
+        ") width: ",
+        node.width,
+        " height: ",
+        node.height
+      );
+      if (node?.clusterNode) {
+        node.y += subGraphTitleTotalMargin;
+        log.info(
+          "A tainted cluster node XBX1",
+          v,
+          node.id,
+          node.width,
+          node.height,
+          node.x,
+          node.y,
+          graph.parent(v)
+        );
+        clusterDb.get(node.id).node = node;
+        positionNode(node);
+      } else {
+        if (graph.children(v).length > 0) {
+          log.info(
+            "A pure cluster node XBX1",
+            v,
+            node.id,
+            node.x,
+            node.y,
+            node.width,
+            node.height,
+            graph.parent(v)
+          );
+          node.height += subGraphTitleTotalMargin;
+          graph.node(node.parentId);
+          const halfPadding = node?.padding / 2 || 0;
+          const labelHeight = node?.labelBBox?.height || 0;
+          const offsetY = labelHeight - halfPadding || 0;
+          log.debug("OffsetY", offsetY, "labelHeight", labelHeight, "halfPadding", halfPadding);
+          await insertCluster(clusters, node);
+          clusterDb.get(node.id).node = node;
+        } else {
+          const parent = graph.node(node.parentId);
+          node.y += subGraphTitleTotalMargin / 2;
+          log.info(
+            "A regular node XBX1 - using the padding",
+            node.id,
+            "parent",
+            node.parentId,
+            node.width,
+            node.height,
+            node.x,
+            node.y,
+            "offsetY",
+            node.offsetY,
+            "parent",
+            parent,
+            parent?.offsetY,
+            node
+          );
+          positionNode(node);
+        }
+      }
+    })
+  );
+  graph.edges().forEach(function(e) {
+    const edge = graph.edge(e);
+    log.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(edge), edge);
+    edge.points.forEach((point) => point.y += subGraphTitleTotalMargin / 2);
+    const startNode = graph.node(e.v);
+    var endNode = graph.node(e.w);
+    const paths = insertEdge(edgePaths, edge, clusterDb, diagramType, startNode, endNode, id);
+    positionEdgeLabel(edge, paths);
+  });
+  graph.nodes().forEach(function(v) {
+    const n = graph.node(v);
+    log.info(v, n.type, n.diff);
+    if (n.isGroup) {
+      diff = n.diff;
+    }
+  });
+  log.warn("Returning from recursive render XAX", elem, diff);
+  return { elem, diff };
+}, "recursiveRender");
+var render = /* @__PURE__ */ __name(async (data4Layout, svg) => {
+  const graph = new Graph({
+    multigraph: true,
+    compound: true
+  }).setGraph({
+    rankdir: data4Layout.direction,
+    nodesep: data4Layout.config?.nodeSpacing || data4Layout.config?.flowchart?.nodeSpacing || data4Layout.nodeSpacing,
+    ranksep: data4Layout.config?.rankSpacing || data4Layout.config?.flowchart?.rankSpacing || data4Layout.rankSpacing,
+    marginx: 8,
+    marginy: 8
+  }).setDefaultEdgeLabel(function() {
+    return {};
+  });
+  const element = svg.select("g");
+  markers_default(element, data4Layout.markers, data4Layout.type, data4Layout.diagramId);
+  clear3();
+  clear2();
+  clear();
+  clear4();
+  data4Layout.nodes.forEach((node) => {
+    graph.setNode(node.id, { ...node });
+    if (node.parentId) {
+      graph.setParent(node.id, node.parentId);
+    }
+  });
+  log.debug("Edges:", data4Layout.edges);
+  data4Layout.edges.forEach((edge) => {
+    if (edge.start === edge.end) {
+      const nodeId = edge.start;
+      const specialId1 = nodeId + "---" + nodeId + "---1";
+      const specialId2 = nodeId + "---" + nodeId + "---2";
+      const node = graph.node(nodeId);
+      graph.setNode(specialId1, {
+        domId: specialId1,
+        id: specialId1,
+        parentId: node.parentId,
+        labelStyle: "",
+        label: "",
+        padding: 0,
+        shape: "labelRect",
+        // shape: 'rect',
+        style: "",
+        width: 10,
+        height: 10
+      });
+      graph.setParent(specialId1, node.parentId);
+      graph.setNode(specialId2, {
+        domId: specialId2,
+        id: specialId2,
+        parentId: node.parentId,
+        labelStyle: "",
+        padding: 0,
+        // shape: 'rect',
+        shape: "labelRect",
+        label: "",
+        style: "",
+        width: 10,
+        height: 10
+      });
+      graph.setParent(specialId2, node.parentId);
+      const edge1 = structuredClone(edge);
+      const edgeMid = structuredClone(edge);
+      const edge2 = structuredClone(edge);
+      edge1.label = "";
+      edge1.arrowTypeEnd = "none";
+      edge1.endLabelLeft = "";
+      edge1.endLabelRight = "";
+      edge1.startLabelLeft = "";
+      edge1.id = nodeId + "-cyclic-special-1";
+      edgeMid.startLabelRight = "";
+      edgeMid.startLabelLeft = "";
+      edgeMid.endLabelLeft = "";
+      edgeMid.endLabelRight = "";
+      edgeMid.arrowTypeStart = "none";
+      edgeMid.arrowTypeEnd = "none";
+      edgeMid.id = nodeId + "-cyclic-special-mid";
+      edge2.label = "";
+      edge2.startLabelRight = "";
+      edge2.startLabelLeft = "";
+      edge2.arrowTypeStart = "none";
+      if (node.isGroup) {
+        edge1.fromCluster = nodeId;
+        edge2.toCluster = nodeId;
+      }
+      edge2.id = nodeId + "-cyclic-special-2";
+      edge2.arrowTypeStart = "none";
+      graph.setEdge(nodeId, specialId1, edge1, nodeId + "-cyclic-special-0");
+      graph.setEdge(specialId1, specialId2, edgeMid, nodeId + "-cyclic-special-1");
+      graph.setEdge(specialId2, nodeId, edge2, nodeId + "-cyc<lic-special-2");
+    } else {
+      graph.setEdge(edge.start, edge.end, { ...edge }, edge.id);
+    }
+  });
+  log.warn("Graph at first:", JSON.stringify(write(graph)));
+  adjustClustersAndEdges(graph);
+  log.warn("Graph after XAX:", JSON.stringify(write(graph)));
+  const siteConfig = getConfig();
+  await recursiveRender(
+    element,
+    graph,
+    data4Layout.type,
+    data4Layout.diagramId,
+    void 0,
+    siteConfig
+  );
+}, "render");
+export {
+  render
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/diagram-AU3YPP64.mjs

@@ -0,0 +1,699 @@
+import {
+  populateCommonDb
+} from "./chunk-6ZKBGPIT.mjs";
+import {
+  parse
+} from "./chunk-2ENXBMWA.mjs";
+import "./chunk-HQDACWF7.mjs";
+import "./chunk-CYW2HGLJ.mjs";
+import "./chunk-CT5Q72BK.mjs";
+import "./chunk-3O5MS6M4.mjs";
+import "./chunk-D6UAH5RW.mjs";
+import "./chunk-LJRZYMMA.mjs";
+import "./chunk-NZTEHIZO.mjs";
+import "./chunk-WM6EUEOH.mjs";
+import "./chunk-D6MTONMS.mjs";
+import {
+  calculateTextDimensions,
+  cleanAndMerge,
+  wrapLabel
+} from "./chunk-BSZA5ISF.mjs";
+import "./chunk-7TFACZ55.mjs";
+import {
+  clear,
+  defaultConfig_default,
+  getAccDescription,
+  getAccTitle,
+  getConfig,
+  getConfig2,
+  getDiagramTitle,
+  sanitizeText,
+  setAccDescription,
+  setAccTitle,
+  setDiagramTitle,
+  setupGraphViewbox2 as setupGraphViewbox
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  log,
+  select_default
+} from "./chunk-V7P66DNM.mjs";
+import "./chunk-BBDM4ZFP.mjs";
+import {
+  isEmResetFrame
+} from "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/diagrams/eventmodeling/types.ts
+var PositionFrameKind = "position frame";
+var FramePositionedKind = "frame positioned";
+var PositionRelationKind = "position relation";
+var RelationPositionedKind = "relation positioned";
+
+// src/diagrams/eventmodeling/db.ts
+var setOptions = /* @__PURE__ */ __name(function(_rawOptString) {
+  log.debug("options str", _rawOptString);
+}, "setOptions");
+var getOptions = /* @__PURE__ */ __name(function() {
+  return {};
+}, "getOptions");
+var clear2 = /* @__PURE__ */ __name(function() {
+  reset();
+  clear();
+}, "clear");
+function reset() {
+  store = {};
+}
+__name(reset, "reset");
+var DEFAULT_EVENTMODELING_CONFIG = defaultConfig_default.eventmodeling;
+var getConfig3 = /* @__PURE__ */ __name(() => {
+  const config = cleanAndMerge({
+    ...DEFAULT_EVENTMODELING_CONFIG,
+    ...getConfig().eventmodeling
+  });
+  return config;
+}, "getConfig");
+var store = {};
+function getState() {
+  let state = initial;
+  const { ast } = store;
+  const diagramProps2 = getDiagramProps();
+  if (!ast) {
+    throw new Error("No data for EventModel");
+  }
+  ast.frames.forEach((frame, index) => {
+    const textProps = calculateTextProps(frame, ast.dataEntities, diagramProps2);
+    state = dispatch(state, {
+      $kind: PositionFrameKind,
+      index,
+      frame,
+      textProps
+    });
+    let sourceFrames = void 0;
+    if (hasSourceFrame(frame)) {
+      log.debug(`source frame`, frame.sourceFrames);
+      sourceFrames = ast.frames.filter((currentFrame) => {
+        return frame.sourceFrames.some((sf) => sf.$refText === currentFrame.name);
+      });
+      sourceFrames.forEach((sourceFrame) => {
+        state = dispatch(state, {
+          $kind: PositionRelationKind,
+          index,
+          frame,
+          sourceFrame
+        });
+      });
+    } else {
+      state = dispatch(state, {
+        $kind: PositionRelationKind,
+        index,
+        frame
+      });
+    }
+  });
+  state = {
+    ...state,
+    sortedSwimlanesArray: sortedSwimlanesArray(state.swimlanes)
+  };
+  return state;
+}
+__name(getState, "getState");
+function setAst(ast) {
+  store.ast = ast;
+}
+__name(setAst, "setAst");
+var diagramProps = {
+  swimlaneMinHeight: 70,
+  swimlanePadding: 15,
+  swimlaneGap: 10,
+  boxPadding: 10,
+  boxOverlap: 90,
+  boxDefaultY: 0,
+  boxMinWidth: 80,
+  boxMaxWidth: 450,
+  boxMinHeight: 80,
+  boxMaxHeight: 750,
+  contentStartX: 250,
+  textMaxWidth: 450 - 2 * 10,
+  boxTextFontWeight: "bold",
+  boxTextPadding: 10,
+  swimlaneTextFontWeight: "bold",
+  labelUiAutomation: "UI/Automation",
+  labelUiAutomationPrefix: "UI/A: ",
+  labelCommandReadModel: "Command/Read Model",
+  labelCommandReadModelPrefix: "C/RM: ",
+  labelEvents: "Events",
+  labelEventsPrefix: "Stream: "
+};
+function getDiagramProps() {
+  return diagramProps;
+}
+__name(getDiagramProps, "getDiagramProps");
+var initial = {
+  boxes: [],
+  swimlanes: {},
+  relations: [],
+  maxR: 0,
+  sortedSwimlanesArray: []
+};
+function extractNamespace(entityIdentifier) {
+  const spl = entityIdentifier.split(".");
+  if (spl.length === 2) {
+    return spl[0];
+  }
+  return void 0;
+}
+__name(extractNamespace, "extractNamespace");
+function extractName(entityIdentifier) {
+  const spl = entityIdentifier.split(".");
+  if (spl.length === 2) {
+    return spl[1];
+  }
+  return entityIdentifier;
+}
+__name(extractName, "extractName");
+function findSwimlaneByNamespace(swimlanes, namespace) {
+  if (!namespace || namespace.length === 0) {
+    return void 0;
+  }
+  return Object.values(swimlanes).find((swimlane) => swimlane.namespace === namespace);
+}
+__name(findSwimlaneByNamespace, "findSwimlaneByNamespace");
+function findNextAvailableIndex(swimlanes, boundaryMin, boundaryMax) {
+  return Math.max(
+    boundaryMin,
+    ...Object.keys(swimlanes).filter((key) => {
+      const index = Number.parseInt(key);
+      return index > boundaryMin && index < boundaryMax;
+    }).map((key) => Number.parseInt(key))
+  ) + 1;
+}
+__name(findNextAvailableIndex, "findNextAvailableIndex");
+function calculateSwimlaneProps(frame, swimlanes) {
+  const namespace = extractNamespace(frame.entityIdentifier);
+  const sw = findSwimlaneByNamespace(swimlanes, namespace);
+  switch (frame.modelEntityType) {
+    case "ui":
+    case "pcr":
+    case "processor":
+      if (sw) {
+        return {
+          index: sw.index,
+          label: sw.namespace || diagramProps.labelUiAutomation
+        };
+      } else if (namespace) {
+        return {
+          index: findNextAvailableIndex(swimlanes, 0, 100),
+          label: diagramProps.labelUiAutomationPrefix + namespace
+        };
+      }
+      return { index: 0, label: diagramProps.labelUiAutomation };
+    case "rmo":
+    case "readmodel":
+    case "cmd":
+    case "command":
+      if (sw) {
+        return {
+          index: sw.index,
+          label: sw.namespace || diagramProps.labelCommandReadModel
+        };
+      } else if (namespace) {
+        return {
+          index: findNextAvailableIndex(swimlanes, 100, 200),
+          label: diagramProps.labelCommandReadModelPrefix + namespace
+        };
+      }
+      return { index: 100, label: diagramProps.labelCommandReadModel };
+    case "evt":
+    case "event":
+    default:
+      if (sw) {
+        return {
+          index: sw.index,
+          label: sw.namespace || diagramProps.labelEvents
+        };
+      } else if (namespace) {
+        return {
+          index: findNextAvailableIndex(swimlanes, 200, 300),
+          label: diagramProps.labelEventsPrefix + namespace
+        };
+      }
+      return { index: 200, label: diagramProps.labelEvents };
+  }
+}
+__name(calculateSwimlaneProps, "calculateSwimlaneProps");
+function calculateEntityVisualProps(frame) {
+  const { themeVariables } = getConfig();
+  switch (frame.modelEntityType) {
+    case "ui":
+      return {
+        fill: themeVariables.emUiFill ?? "white",
+        stroke: themeVariables.emUiStroke ?? "#dbdada"
+      };
+    case "pcr":
+    case "processor":
+      return {
+        fill: themeVariables.emProcessorFill ?? "#edb3f6",
+        stroke: themeVariables.emProcessorStroke ?? "#b88cbf"
+      };
+    case "rmo":
+    case "readmodel":
+      return {
+        fill: themeVariables.emReadModelFill ?? "#d3f1a2",
+        stroke: themeVariables.emReadModelStroke ?? "#a3b732"
+      };
+    case "cmd":
+    case "command":
+      return {
+        fill: themeVariables.emCommandFill ?? "#bcd6fe",
+        stroke: themeVariables.emCommandStroke ?? "#679ac3"
+      };
+    case "evt":
+    case "event":
+      return {
+        fill: themeVariables.emEventFill ?? "#ffb778",
+        stroke: themeVariables.emEventStroke ?? "#c19a0f"
+      };
+    default:
+      return {
+        fill: "red",
+        stroke: "black"
+      };
+  }
+}
+__name(calculateEntityVisualProps, "calculateEntityVisualProps");
+function calculateTextProps(frame, dataEntities, diagramProps2) {
+  const config = getConfig();
+  const name = sanitizeText(extractName(frame.entityIdentifier) ?? "", config);
+  let toHtml;
+  const wrapLabelConfig = {
+    fontSize: 16,
+    fontWeight: 700,
+    fontFamily: '"trebuchet ms", verdana, arial, sans-serif',
+    joinWith: "<br/>"
+  };
+  const wrappedName = wrapLabel(name, diagramProps2.textMaxWidth, wrapLabelConfig);
+  let content = `<b>${wrappedName}</b>`;
+  if (frame.dataInlineValue) {
+    toHtml = frame.dataInlineValue;
+    toHtml = toHtml.substring(toHtml.indexOf("{") + 1);
+    toHtml = toHtml.substring(0, toHtml.lastIndexOf("}") - 1);
+    toHtml = sanitizeText(toHtml, config);
+    toHtml = wrapLabel(toHtml, diagramProps2.textMaxWidth, wrapLabelConfig);
+    toHtml = toHtml.replaceAll(" ", "&nbsp;");
+  }
+  if (frame.dataReference) {
+    const dataEntity = dataEntities.find(
+      (dataEntity2) => dataEntity2.name === frame.dataReference?.$refText
+    );
+    if (dataEntity) {
+      toHtml = dataEntity.dataBlockValue;
+      toHtml = toHtml.substring(toHtml.indexOf("{\n") + 2);
+      toHtml = toHtml.substring(0, toHtml.lastIndexOf("}") - 1);
+      toHtml = sanitizeText(toHtml, config);
+      toHtml = wrapLabel(toHtml, diagramProps2.textMaxWidth, wrapLabelConfig);
+      toHtml = toHtml.replaceAll(" ", "&nbsp;");
+      toHtml += `<br/>`;
+    }
+  }
+  const hasRenderedData = toHtml !== void 0;
+  if (hasRenderedData) {
+    content += `<br/><br/><code style="text-align: left; display: block;max-width:${diagramProps2.textMaxWidth}px">${toHtml}</code>`;
+  }
+  const textDimensionConfig = {
+    fontSize: wrapLabelConfig.fontSize,
+    fontWeight: wrapLabelConfig.fontWeight,
+    fontFamily: wrapLabelConfig.fontFamily
+  };
+  const dimensions = calculateTextDimensions(content, textDimensionConfig);
+  const calculatedWidthFix = hasRenderedData ? dimensions.width / 3 : dimensions.width;
+  const props = {
+    content,
+    width: calculatedWidthFix,
+    height: dimensions.height
+  };
+  log.debug(`[${frame.name}] ${frame.entityIdentifier} text`, props);
+  return props;
+}
+__name(calculateTextProps, "calculateTextProps");
+function decidePositionFrame(state, _command) {
+  const command = _command;
+  const visual = calculateEntityVisualProps(command.frame);
+  const dimension = {
+    width: command.textProps.width + 2 * diagramProps.boxTextPadding,
+    height: command.textProps.height + 2 * diagramProps.boxTextPadding
+  };
+  const event = {
+    $kind: FramePositionedKind,
+    frame: command.frame,
+    index: command.index,
+    visual,
+    dimension,
+    textProps: command.textProps
+  };
+  return [event];
+}
+__name(decidePositionFrame, "decidePositionFrame");
+function calculateX(swimlane, previousSwimlane, lastBox) {
+  if (previousSwimlane === void 0) {
+    return diagramProps.contentStartX;
+  }
+  if (previousSwimlane.index === swimlane.index && swimlane.r) {
+    return swimlane.r + diagramProps.boxPadding;
+  }
+  if (lastBox === void 0) {
+    return diagramProps.contentStartX;
+  }
+  return lastBox.r - diagramProps.boxOverlap + diagramProps.boxPadding;
+}
+__name(calculateX, "calculateX");
+function calculateMaxRight(swimlanes, swimlaneR) {
+  const rs = [...swimlanes.map((s) => s.r), swimlaneR];
+  return Math.max(...rs);
+}
+__name(calculateMaxRight, "calculateMaxRight");
+function sortedSwimlanesArray(swimlanes) {
+  return Object.values(swimlanes).sort((a, b) => a.index - b.index);
+}
+__name(sortedSwimlanesArray, "sortedSwimlanesArray");
+function evolveFramePositioned(state, _event) {
+  const event = _event;
+  const swimlaneProps = calculateSwimlaneProps(event.frame, state.swimlanes);
+  let swimlane;
+  if (swimlaneProps.index in state.swimlanes) {
+    swimlane = state.swimlanes[swimlaneProps.index];
+  } else {
+    swimlane = {
+      index: swimlaneProps.index,
+      label: swimlaneProps.label,
+      r: 0,
+      y: swimlaneProps.index * diagramProps.swimlaneMinHeight + diagramProps.swimlaneGap,
+      height: diagramProps.swimlaneMinHeight,
+      maxHeight: diagramProps.swimlaneMinHeight
+    };
+  }
+  const lastBox = state.boxes.length > 0 ? state.boxes[state.boxes.length - 1] : void 0;
+  const previousSwimlane = state.previousSwimlaneNumber !== void 0 ? state.swimlanes[state.previousSwimlaneNumber] : void 0;
+  const dimension = {
+    width: Math.max(
+      diagramProps.boxMinWidth,
+      Math.min(diagramProps.boxMaxWidth, event.dimension.width)
+    ) + 2 * diagramProps.boxPadding,
+    height: Math.max(
+      diagramProps.boxMinHeight,
+      Math.min(diagramProps.boxMaxHeight, event.dimension.height)
+    ) + 2 * diagramProps.boxPadding
+  };
+  const x = calculateX(swimlane, previousSwimlane, lastBox);
+  const r = x + dimension.width + diagramProps.boxPadding;
+  const maxR = calculateMaxRight(Object.values(state.swimlanes), r);
+  swimlane.r = x + dimension.width;
+  swimlane.maxHeight = Math.max(swimlane.maxHeight, dimension.height);
+  swimlane.height = Math.max(diagramProps.swimlaneMinHeight, swimlane.maxHeight) + 2 * diagramProps.swimlanePadding;
+  const box = {
+    x,
+    y: diagramProps.swimlanePadding + swimlane.y,
+    // y: diagramProps.swimlanePadding + (swimlane.y || diagramProps.boxDefaultY),
+    r,
+    dimension,
+    leftSibling: false,
+    swimlane,
+    visual: event.visual,
+    text: event.textProps.content,
+    frame: event.frame,
+    index: event.index
+  };
+  const newState = {
+    ...state,
+    boxes: [...state.boxes, box],
+    swimlanes: {
+      ...state.swimlanes,
+      [`${swimlane.index}`]: swimlane
+    },
+    previousSwimlaneNumber: swimlaneProps.index,
+    previousFrame: event.frame,
+    maxR
+  };
+  const swimlanes = sortedSwimlanesArray(newState.swimlanes);
+  if (swimlanes.length > 0) {
+    swimlanes[0].y = 0;
+  }
+  for (let i = 1; i < swimlanes.length; i++) {
+    const sw = swimlanes[i];
+    const prevSw = swimlanes[i - 1];
+    sw.y = prevSw.y + prevSw.height + diagramProps.swimlaneGap;
+  }
+  return newState;
+}
+__name(evolveFramePositioned, "evolveFramePositioned");
+function isFirstFrame(index, frame) {
+  if (index === 0 && frame.sourceFrames.length === 0) {
+    return true;
+  }
+  return false;
+}
+__name(isFirstFrame, "isFirstFrame");
+function hasSourceFrame(frame) {
+  return frame.sourceFrames !== void 0 && frame.sourceFrames !== null && frame.sourceFrames.length > 0;
+}
+__name(hasSourceFrame, "hasSourceFrame");
+function findBoxByFrame(boxes, frame) {
+  if (frame === void 0 || frame === null) {
+    return void 0;
+  }
+  return boxes.find((box) => box.frame.name === frame.name);
+}
+__name(findBoxByFrame, "findBoxByFrame");
+function findBoxByLineIndex(boxes, targetSwimlane, lineIndex) {
+  if (lineIndex < 0) {
+    return void 0;
+  }
+  for (let i = lineIndex; i >= 0; i--) {
+    const box = boxes[i];
+    if (box.swimlane.index !== targetSwimlane) {
+      return box;
+    }
+  }
+  return void 0;
+}
+__name(findBoxByLineIndex, "findBoxByLineIndex");
+function decidePositionRelation(state, _command) {
+  const command = _command;
+  if (isEmResetFrame(command.frame) || isFirstFrame(command.index, command.frame)) {
+    return [];
+  }
+  const targetBox = findBoxByFrame(state.boxes, command.frame);
+  if (targetBox === void 0) {
+    throw new Error(`Target box not found for frame ${command.frame.name}`);
+  }
+  let sourceBox;
+  if (command.sourceFrame) {
+    sourceBox = findBoxByFrame(state.boxes, command.sourceFrame);
+  } else {
+    sourceBox = findBoxByLineIndex(state.boxes, targetBox.swimlane.index, command.index - 1);
+  }
+  if (sourceBox === void 0) {
+    return [];
+  }
+  const event = {
+    $kind: RelationPositionedKind,
+    frame: command.frame,
+    index: command.index,
+    sourceBox,
+    targetBox
+  };
+  return [event];
+}
+__name(decidePositionRelation, "decidePositionRelation");
+function evolveRelationPositioned(state, _event) {
+  const event = _event;
+  const relation = {
+    visual: {
+      fill: "none",
+      stroke: "#000"
+    },
+    source: {
+      x: event.sourceBox.x,
+      y: event.sourceBox.y
+    },
+    target: {
+      x: event.targetBox.x,
+      y: event.targetBox.y
+    },
+    sourceBox: event.sourceBox,
+    targetBox: event.targetBox
+  };
+  const newState = {
+    ...state,
+    relations: [...state.relations, relation]
+  };
+  return newState;
+}
+__name(evolveRelationPositioned, "evolveRelationPositioned");
+var deciders = {
+  [PositionFrameKind]: decidePositionFrame,
+  [PositionRelationKind]: decidePositionRelation
+};
+var evolvers = {
+  [FramePositionedKind]: evolveFramePositioned,
+  [RelationPositionedKind]: evolveRelationPositioned
+};
+function decide(state, command) {
+  const fn = deciders[command.$kind];
+  if (fn === void 0 || fn === null) {
+    return [];
+  }
+  const events = fn(state, command);
+  log.debug(`decided events`, events);
+  return events;
+}
+__name(decide, "decide");
+function evolve(state, events) {
+  const newState = events.reduce((previousState, event) => {
+    const fn = evolvers[event.$kind];
+    if (fn === void 0 || fn === null) {
+      return previousState;
+    }
+    return fn(previousState, event);
+  }, state);
+  log.debug(`evolve events`, { state, newState, events });
+  return newState;
+}
+__name(evolve, "evolve");
+function dispatch(state, command) {
+  const events = decide(state, command);
+  const newState = evolve(state, events);
+  return newState;
+}
+__name(dispatch, "dispatch");
+var db = {
+  getConfig: getConfig3,
+  setOptions,
+  getOptions,
+  clear: clear2,
+  setAccTitle,
+  getAccTitle,
+  getAccDescription,
+  setAccDescription,
+  setDiagramTitle,
+  getDiagramTitle,
+  setAst,
+  getDiagramProps,
+  getState
+};
+
+// src/diagrams/eventmodeling/parser.ts
+var parser = {
+  parse: /* @__PURE__ */ __name(async (input) => {
+    const ast = await parse("eventmodeling", input);
+    log.debug(ast);
+    db.setAst(ast);
+    populateCommonDb(ast, db);
+  }, "parse")
+};
+if (void 0) {
+  const { it, expect, describe } = void 0;
+  describe("EventModeling Parser", () => {
+    it("should parse simple model", () => {
+      const result = parser.parse(`eventmodeling
+  tf 01 evt Start
+
+    `);
+      expect(result !== void 0);
+    });
+  });
+}
+
+// src/diagrams/eventmodeling/renderer.ts
+var DEFAULT_CONFIG = getConfig2();
+var DEFAULT_EVENTMODELING_CONFIG2 = DEFAULT_CONFIG?.eventmodeling;
+function renderD3Box(diagram2, diagramProps2) {
+  return (box) => {
+    const y = box.swimlane.y + diagramProps2.swimlanePadding;
+    const g = diagram2.append("g").attr("class", "em-box");
+    g.append("rect").attr("x", box.x).attr("y", y).attr("rx", "3").attr("width", box.dimension.width).attr("height", box.dimension.height).attr("stroke", box.visual.stroke).attr("fill", box.visual.fill);
+    const f = g.append("foreignObject").attr("x", box.x + diagramProps2.boxPadding).attr("y", y + 10).attr("width", box.dimension.width - 2 * diagramProps2.boxPadding).attr("height", box.dimension.height - 2 * diagramProps2.boxPadding);
+    const text = f.append("xhtml:div").style("display", "table").style("height", "100%").style("width", "100%");
+    text.append("span").style("display", "table-cell").style("text-align", "center").style("vertical-align", "middle").html(box.text);
+  };
+}
+__name(renderD3Box, "renderD3Box");
+function dirUpwards(sourceY, targetY) {
+  return sourceY > targetY;
+}
+__name(dirUpwards, "dirUpwards");
+function renderD3Relation(diagram2, diagramProps2, arrowheadId, themeVariables) {
+  return (relation) => {
+    const sourceBoxY = relation.sourceBox.swimlane.y + diagramProps2.swimlanePadding;
+    const targetBoxY = relation.targetBox.swimlane.y + diagramProps2.swimlanePadding;
+    const upwards = dirUpwards(sourceBoxY, targetBoxY);
+    const sourceX = relation.sourceBox.x + relation.sourceBox.dimension.width * 2 / 3;
+    const targetX = relation.targetBox.x + relation.targetBox.dimension.width / 3;
+    let sourceY;
+    let targetY;
+    log.debug(`rendering relation up=${upwards} for `, {
+      sourceBox: relation.sourceBox,
+      targetBox: relation.targetBox
+    });
+    if (upwards) {
+      sourceY = sourceBoxY;
+      targetY = targetBoxY + relation.targetBox.dimension.height;
+    } else {
+      sourceY = sourceBoxY + relation.sourceBox.dimension.height;
+      targetY = targetBoxY;
+    }
+    const relationStroke = themeVariables.emRelationStroke ?? relation.visual.stroke;
+    diagram2.append("path").attr("class", "em-relation").attr("fill", relation.visual.fill).attr("stroke", relationStroke).attr("stroke-width", "1").attr("marker-end", `url(#${arrowheadId})`).attr("d", `M${sourceX} ${sourceY} L${targetX} ${targetY}`);
+  };
+}
+__name(renderD3Relation, "renderD3Relation");
+function renderD3Swimlane(diagram2, maxR, diagramProps2, themeVariables) {
+  return (swimlane) => {
+    const g = diagram2.append("g").attr("class", "em-swimlane");
+    const oddBackground = themeVariables.emSwimlaneBackgroundOdd ?? "rgb(250,250,250)";
+    const backgroundStroke = themeVariables.emSwimlaneBackgroundStroke ?? "rgb(240,240,240)";
+    g.append("rect").attr("x", 0).attr("y", swimlane.y).attr("rx", "3").attr("width", maxR + diagramProps2.swimlanePadding).attr("height", swimlane.height).attr("fill", oddBackground).attr("stroke", backgroundStroke);
+    g.append("text").attr("font-weight", diagramProps2.swimlaneTextFontWeight).attr("x", 30).attr("y", swimlane.y + 30).text(swimlane.label);
+  };
+}
+__name(renderD3Swimlane, "renderD3Swimlane");
+var draw = /* @__PURE__ */ __name(function(txt, id, ver, diagObj) {
+  log.debug("in eventmodeling renderer", txt + "\n", "id:", id, ver);
+  if (!DEFAULT_EVENTMODELING_CONFIG2) {
+    throw new Error("EventModeling config not found");
+  }
+  const db2 = diagObj.db;
+  const { themeVariables, eventmodeling: config } = getConfig2();
+  const diagram2 = select_default(`[id="${id}"]`);
+  const diagramProps2 = db2.getDiagramProps();
+  const state = db2.getState();
+  const arrowheadId = `em-arrowhead-${id}`;
+  const arrowheadColor = themeVariables.emArrowhead ?? "#000000";
+  state.sortedSwimlanesArray.forEach(
+    renderD3Swimlane(diagram2, state.maxR, diagramProps2, themeVariables)
+  );
+  state.boxes.forEach(renderD3Box(diagram2, diagramProps2));
+  state.relations.forEach(renderD3Relation(diagram2, diagramProps2, arrowheadId, themeVariables));
+  const marker = diagram2.append("defs").append("marker").attr("id", arrowheadId).attr("markerWidth", "10").attr("markerHeight", "7").attr("refX", "10").attr("refY", "3.5").attr("orient", "auto");
+  marker.append("polygon").attr("points", "0 0, 10 3.5, 0 7").attr("fill", arrowheadColor);
+  setupGraphViewbox(void 0, diagram2, config?.padding ?? 30, config?.useMaxWidth);
+}, "draw");
+var renderer_default = {
+  draw
+};
+
+// src/diagrams/eventmodeling/styles.js
+var getStyles = /* @__PURE__ */ __name((_options) => ``, "getStyles");
+var styles_default = getStyles;
+
+// src/diagrams/eventmodeling/diagram.ts
+var diagram = {
+  parser,
+  db,
+  renderer: renderer_default,
+  styles: styles_default
+};
+export {
+  diagram
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/diagram-CAG56N7L.mjs

@@ -0,0 +1,220 @@
+import {
+  ImperativeState
+} from "./chunk-IALYP65X.mjs";
+import {
+  populateCommonDb
+} from "./chunk-6ZKBGPIT.mjs";
+import {
+  parse
+} from "./chunk-2ENXBMWA.mjs";
+import "./chunk-HQDACWF7.mjs";
+import "./chunk-CYW2HGLJ.mjs";
+import "./chunk-CT5Q72BK.mjs";
+import "./chunk-3O5MS6M4.mjs";
+import "./chunk-D6UAH5RW.mjs";
+import "./chunk-LJRZYMMA.mjs";
+import "./chunk-NZTEHIZO.mjs";
+import "./chunk-WM6EUEOH.mjs";
+import "./chunk-D6MTONMS.mjs";
+import {
+  selectSvgElement
+} from "./chunk-PUIB63ON.mjs";
+import {
+  cleanAndMerge
+} from "./chunk-BSZA5ISF.mjs";
+import "./chunk-7TFACZ55.mjs";
+import {
+  clear,
+  configureSvgSize,
+  defaultConfig_default,
+  getAccDescription,
+  getAccTitle,
+  getConfig,
+  getDiagramTitle,
+  setAccDescription,
+  setAccTitle,
+  setDiagramTitle
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  log
+} from "./chunk-V7P66DNM.mjs";
+import "./chunk-BBDM4ZFP.mjs";
+import "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/diagrams/treeView/db.ts
+var state = new ImperativeState(() => ({
+  cnt: 1,
+  stack: [
+    {
+      id: 0,
+      level: -1,
+      name: "/",
+      children: []
+    }
+  ]
+}));
+var clear2 = /* @__PURE__ */ __name(() => {
+  state.reset();
+  clear();
+}, "clear");
+var getRoot = /* @__PURE__ */ __name(() => {
+  return state.records.stack[0];
+}, "getRoot");
+var getCount = /* @__PURE__ */ __name(() => state.records.cnt, "getCount");
+var defaultConfig = defaultConfig_default.treeView;
+var getConfig2 = /* @__PURE__ */ __name(() => {
+  return cleanAndMerge(defaultConfig, getConfig().treeView);
+}, "getConfig");
+var addNode = /* @__PURE__ */ __name((level, name) => {
+  while (level <= state.records.stack[state.records.stack.length - 1].level) {
+    state.records.stack.pop();
+  }
+  const node = {
+    id: state.records.cnt++,
+    level,
+    name,
+    children: []
+  };
+  state.records.stack[state.records.stack.length - 1].children.push(node);
+  state.records.stack.push(node);
+}, "addNode");
+var db = {
+  clear: clear2,
+  addNode,
+  getRoot,
+  getCount,
+  getConfig: getConfig2,
+  getAccTitle,
+  getAccDescription,
+  getDiagramTitle,
+  setAccDescription,
+  setAccTitle,
+  setDiagramTitle
+};
+var db_default = db;
+
+// src/diagrams/treeView/parser.ts
+var populate = /* @__PURE__ */ __name((ast) => {
+  populateCommonDb(ast, db_default);
+  ast.nodes.map((node) => db_default.addNode(node.indent ? parseInt(node.indent) : 0, node.name));
+}, "populate");
+var parser = {
+  parse: /* @__PURE__ */ __name(async (input) => {
+    const ast = await parse("treeView", input);
+    log.debug(ast);
+    populate(ast);
+  }, "parse")
+};
+
+// src/diagrams/treeView/renderer.ts
+var positionLabel = /* @__PURE__ */ __name((x, y, node, domElem, config) => {
+  const label = domElem.append("text").text(node.name).attr("dominant-baseline", "middle").attr("class", "treeView-node-label");
+  const { height: labelHeight, width: labelWidth } = label.node().getBBox();
+  const height = labelHeight + config.paddingY * 2;
+  const width = labelWidth + config.paddingX * 2;
+  label.attr("x", x + config.paddingX);
+  label.attr("y", y + height / 2);
+  node.BBox = {
+    x,
+    y,
+    width,
+    height
+  };
+}, "positionLabel");
+var positionLine = /* @__PURE__ */ __name((domElem, x1, y1, x2, y2, lineThickness) => {
+  return domElem.append("line").attr("x1", x1).attr("y1", y1).attr("x2", x2).attr("y2", y2).attr("stroke-width", lineThickness).attr("class", "treeView-node-line");
+}, "positionLine");
+var drawTree = /* @__PURE__ */ __name((elem, root, config) => {
+  let totalHeight = 0;
+  let totalWidth = 0;
+  const drawNode = /* @__PURE__ */ __name((elem2, node, config2, depth) => {
+    const indent = depth * (config2.rowIndent + config2.paddingX);
+    positionLabel(indent, totalHeight, node, elem2, config2);
+    const { height, width } = node.BBox;
+    positionLine(
+      elem2,
+      indent - config2.rowIndent,
+      totalHeight + height / 2,
+      indent,
+      totalHeight + height / 2,
+      config2.lineThickness
+    );
+    totalWidth = Math.max(totalWidth, indent + width);
+    totalHeight += height;
+  }, "drawNode");
+  const processNode = /* @__PURE__ */ __name((node, depth = 0) => {
+    drawNode(elem, node, config, depth);
+    node.children.forEach((child) => {
+      processNode(child, depth + 1);
+    });
+    const { x, y, height } = node.BBox;
+    if (node.children.length) {
+      const { y: endY, height: endHeight } = node.children[node.children.length - 1].BBox;
+      positionLine(
+        elem,
+        x + config.paddingX,
+        y + height,
+        x + config.paddingX,
+        endY + endHeight / 2 + config.lineThickness / 2,
+        config.lineThickness
+      );
+    }
+  }, "processNode");
+  processNode(root);
+  return { totalHeight, totalWidth };
+}, "drawTree");
+var draw = /* @__PURE__ */ __name((text, id, _ver, diagObj) => {
+  log.debug("Rendering treeView diagram\n" + text);
+  const db2 = diagObj.db;
+  const root = db2.getRoot();
+  const config = db2.getConfig();
+  const svg = selectSvgElement(id);
+  const treeElem = svg.append("g");
+  treeElem.attr("class", "tree-view");
+  const { totalHeight, totalWidth } = drawTree(treeElem, root, config);
+  svg.attr("viewBox", `-${config.lineThickness / 2} 0 ${totalWidth} ${totalHeight}`);
+  configureSvgSize(svg, totalHeight, totalWidth, config.useMaxWidth);
+}, "draw");
+var renderer = {
+  draw
+};
+var renderer_default = renderer;
+
+// src/diagrams/treeView/styles.ts
+var defaultTreeViewDiagramStyles = {
+  labelFontSize: "16px",
+  labelColor: "black",
+  lineColor: "black"
+};
+var styles = /* @__PURE__ */ __name(({
+  treeView
+}) => {
+  const { labelFontSize, labelColor, lineColor } = cleanAndMerge(
+    defaultTreeViewDiagramStyles,
+    treeView
+  );
+  return `
+    .treeView-node-label {
+        font-size: ${labelFontSize};
+        fill: ${labelColor};
+    }
+    .treeView-node-line {
+        stroke: ${lineColor};
+    }
+    `;
+}, "styles");
+var styles_default = styles;
+
+// src/diagrams/treeView/diagram.ts
+var diagram = {
+  db: db_default,
+  renderer: renderer_default,
+  parser,
+  styles: styles_default
+};
+export {
+  diagram
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/diagram-N34NG4AO.mjs

@@ -0,0 +1,261 @@
+import {
+  populateCommonDb
+} from "./chunk-6ZKBGPIT.mjs";
+import {
+  parse
+} from "./chunk-2ENXBMWA.mjs";
+import "./chunk-HQDACWF7.mjs";
+import "./chunk-CYW2HGLJ.mjs";
+import "./chunk-CT5Q72BK.mjs";
+import "./chunk-3O5MS6M4.mjs";
+import "./chunk-D6UAH5RW.mjs";
+import "./chunk-LJRZYMMA.mjs";
+import "./chunk-NZTEHIZO.mjs";
+import "./chunk-WM6EUEOH.mjs";
+import "./chunk-D6MTONMS.mjs";
+import {
+  selectSvgElement
+} from "./chunk-PUIB63ON.mjs";
+import {
+  cleanAndMerge
+} from "./chunk-BSZA5ISF.mjs";
+import "./chunk-7TFACZ55.mjs";
+import {
+  clear,
+  configureSvgSize,
+  defaultConfig_default,
+  getAccDescription,
+  getAccTitle,
+  getConfig,
+  getDiagramTitle,
+  setAccDescription,
+  setAccTitle,
+  setDiagramTitle
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  log
+} from "./chunk-V7P66DNM.mjs";
+import "./chunk-BBDM4ZFP.mjs";
+import "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/diagrams/packet/db.ts
+var DEFAULT_PACKET_CONFIG = defaultConfig_default.packet;
+var PacketDB = class {
+  constructor() {
+    this.packet = [];
+    this.setAccTitle = setAccTitle;
+    this.getAccTitle = getAccTitle;
+    this.setDiagramTitle = setDiagramTitle;
+    this.getDiagramTitle = getDiagramTitle;
+    this.getAccDescription = getAccDescription;
+    this.setAccDescription = setAccDescription;
+  }
+  static {
+    __name(this, "PacketDB");
+  }
+  getConfig() {
+    const config = cleanAndMerge({
+      ...DEFAULT_PACKET_CONFIG,
+      ...getConfig().packet
+    });
+    if (config.showBits) {
+      config.paddingY += 10;
+    }
+    return config;
+  }
+  getPacket() {
+    return this.packet;
+  }
+  pushWord(word) {
+    if (word.length > 0) {
+      this.packet.push(word);
+    }
+  }
+  clear() {
+    clear();
+    this.packet = [];
+  }
+};
+
+// src/diagrams/packet/parser.ts
+var maxPacketSize = 1e4;
+var populate = /* @__PURE__ */ __name((ast, db) => {
+  populateCommonDb(ast, db);
+  let lastBit = -1;
+  let word = [];
+  let row = 1;
+  const { bitsPerRow } = db.getConfig();
+  for (let { start, end, bits, label } of ast.blocks) {
+    if (start !== void 0 && end !== void 0 && end < start) {
+      throw new Error(`Packet block ${start} - ${end} is invalid. End must be greater than start.`);
+    }
+    start ??= lastBit + 1;
+    if (start !== lastBit + 1) {
+      throw new Error(
+        `Packet block ${start} - ${end ?? start} is not contiguous. It should start from ${lastBit + 1}.`
+      );
+    }
+    if (bits === 0) {
+      throw new Error(`Packet block ${start} is invalid. Cannot have a zero bit field.`);
+    }
+    end ??= start + (bits ?? 1) - 1;
+    bits ??= end - start + 1;
+    lastBit = end;
+    log.debug(`Packet block ${start} - ${lastBit} with label ${label}`);
+    while (word.length <= bitsPerRow + 1 && db.getPacket().length < maxPacketSize) {
+      const [block, nextBlock] = getNextFittingBlock({ start, end, bits, label }, row, bitsPerRow);
+      word.push(block);
+      if (block.end + 1 === row * bitsPerRow) {
+        db.pushWord(word);
+        word = [];
+        row++;
+      }
+      if (!nextBlock) {
+        break;
+      }
+      ({ start, end, bits, label } = nextBlock);
+    }
+  }
+  db.pushWord(word);
+}, "populate");
+var getNextFittingBlock = /* @__PURE__ */ __name((block, row, bitsPerRow) => {
+  if (block.start === void 0) {
+    throw new Error("start should have been set during first phase");
+  }
+  if (block.end === void 0) {
+    throw new Error("end should have been set during first phase");
+  }
+  if (block.start > block.end) {
+    throw new Error(`Block start ${block.start} is greater than block end ${block.end}.`);
+  }
+  if (block.end + 1 <= row * bitsPerRow) {
+    return [block, void 0];
+  }
+  const rowEnd = row * bitsPerRow - 1;
+  const rowStart = row * bitsPerRow;
+  return [
+    {
+      start: block.start,
+      end: rowEnd,
+      label: block.label,
+      bits: rowEnd - block.start
+    },
+    {
+      start: rowStart,
+      end: block.end,
+      label: block.label,
+      bits: block.end - rowStart
+    }
+  ];
+}, "getNextFittingBlock");
+var parser = {
+  // @ts-expect-error - PacketDB is not assignable to DiagramDB
+  parser: { yy: void 0 },
+  parse: /* @__PURE__ */ __name(async (input) => {
+    const ast = await parse("packet", input);
+    const db = parser.parser?.yy;
+    if (!(db instanceof PacketDB)) {
+      throw new Error(
+        "parser.parser?.yy was not a PacketDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues."
+      );
+    }
+    log.debug(ast);
+    populate(ast, db);
+  }, "parse")
+};
+
+// src/diagrams/packet/renderer.ts
+var draw = /* @__PURE__ */ __name((_text, id, _version, diagram2) => {
+  const db = diagram2.db;
+  const config = db.getConfig();
+  const { rowHeight, paddingY, bitWidth, bitsPerRow } = config;
+  const words = db.getPacket();
+  const title = db.getDiagramTitle();
+  const totalRowHeight = rowHeight + paddingY;
+  const svgHeight = totalRowHeight * (words.length + 1) - (title ? 0 : rowHeight);
+  const svgWidth = bitWidth * bitsPerRow + 2;
+  const svg = selectSvgElement(id);
+  svg.attr("viewBox", `0 0 ${svgWidth} ${svgHeight}`);
+  configureSvgSize(svg, svgHeight, svgWidth, config.useMaxWidth);
+  for (const [word, packet] of words.entries()) {
+    drawWord(svg, packet, word, config);
+  }
+  svg.append("text").text(title).attr("x", svgWidth / 2).attr("y", svgHeight - totalRowHeight / 2).attr("dominant-baseline", "middle").attr("text-anchor", "middle").attr("class", "packetTitle");
+}, "draw");
+var drawWord = /* @__PURE__ */ __name((svg, word, rowNumber, { rowHeight, paddingX, paddingY, bitWidth, bitsPerRow, showBits }) => {
+  const group = svg.append("g");
+  const wordY = rowNumber * (rowHeight + paddingY) + paddingY;
+  for (const block of word) {
+    const blockX = block.start % bitsPerRow * bitWidth + 1;
+    const width = (block.end - block.start + 1) * bitWidth - paddingX;
+    group.append("rect").attr("x", blockX).attr("y", wordY).attr("width", width).attr("height", rowHeight).attr("class", "packetBlock");
+    group.append("text").attr("x", blockX + width / 2).attr("y", wordY + rowHeight / 2).attr("class", "packetLabel").attr("dominant-baseline", "middle").attr("text-anchor", "middle").text(block.label);
+    if (!showBits) {
+      continue;
+    }
+    const isSingleBlock = block.end === block.start;
+    const bitNumberY = wordY - 2;
+    group.append("text").attr("x", blockX + (isSingleBlock ? width / 2 : 0)).attr("y", bitNumberY).attr("class", "packetByte start").attr("dominant-baseline", "auto").attr("text-anchor", isSingleBlock ? "middle" : "start").text(block.start);
+    if (!isSingleBlock) {
+      group.append("text").attr("x", blockX + width).attr("y", bitNumberY).attr("class", "packetByte end").attr("dominant-baseline", "auto").attr("text-anchor", "end").text(block.end);
+    }
+  }
+}, "drawWord");
+var renderer = { draw };
+
+// src/diagrams/packet/styles.ts
+var defaultPacketStyleOptions = {
+  byteFontSize: "10px",
+  startByteColor: "black",
+  endByteColor: "black",
+  labelColor: "black",
+  labelFontSize: "12px",
+  titleColor: "black",
+  titleFontSize: "14px",
+  blockStrokeColor: "black",
+  blockStrokeWidth: "1",
+  blockFillColor: "#efefef"
+};
+var styles = /* @__PURE__ */ __name(({ packet } = {}) => {
+  const options = cleanAndMerge(defaultPacketStyleOptions, packet);
+  return `
+	.packetByte {
+		font-size: ${options.byteFontSize};
+	}
+	.packetByte.start {
+		fill: ${options.startByteColor};
+	}
+	.packetByte.end {
+		fill: ${options.endByteColor};
+	}
+	.packetLabel {
+		fill: ${options.labelColor};
+		font-size: ${options.labelFontSize};
+	}
+	.packetTitle {
+		fill: ${options.titleColor};
+		font-size: ${options.titleFontSize};
+	}
+	.packetBlock {
+		stroke: ${options.blockStrokeColor};
+		stroke-width: ${options.blockStrokeWidth};
+		fill: ${options.blockFillColor};
+	}
+	`;
+}, "styles");
+
+// src/diagrams/packet/diagram.ts
+var diagram = {
+  parser,
+  get db() {
+    return new PacketDB();
+  },
+  renderer,
+  styles
+};
+export {
+  diagram
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/diagram-OKXK7GIF.mjs

@@ -0,0 +1,586 @@
+import {
+  populateCommonDb
+} from "./chunk-6ZKBGPIT.mjs";
+import {
+  parse
+} from "./chunk-2ENXBMWA.mjs";
+import "./chunk-HQDACWF7.mjs";
+import "./chunk-CYW2HGLJ.mjs";
+import "./chunk-CT5Q72BK.mjs";
+import "./chunk-3O5MS6M4.mjs";
+import "./chunk-D6UAH5RW.mjs";
+import "./chunk-LJRZYMMA.mjs";
+import "./chunk-NZTEHIZO.mjs";
+import "./chunk-WM6EUEOH.mjs";
+import "./chunk-D6MTONMS.mjs";
+import {
+  selectSvgElement
+} from "./chunk-PUIB63ON.mjs";
+import {
+  setupViewPortForSVG
+} from "./chunk-KEUPHFFI.mjs";
+import {
+  isLabelStyle,
+  styles2String
+} from "./chunk-GTILCTU2.mjs";
+import {
+  cleanAndMerge
+} from "./chunk-BSZA5ISF.mjs";
+import "./chunk-7TFACZ55.mjs";
+import {
+  clear,
+  configureSvgSize,
+  defaultConfig_default,
+  getAccDescription,
+  getAccTitle,
+  getConfig,
+  getDiagramTitle,
+  getThemeVariables,
+  setAccDescription,
+  setAccTitle,
+  setDiagramTitle
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  format,
+  hierarchy,
+  log,
+  ordinal,
+  select_default,
+  treemap_default
+} from "./chunk-V7P66DNM.mjs";
+import "./chunk-BBDM4ZFP.mjs";
+import "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/diagrams/treemap/db.ts
+var TreeMapDB = class {
+  constructor() {
+    this.nodes = [];
+    this.levels = /* @__PURE__ */ new Map();
+    this.outerNodes = [];
+    this.classes = /* @__PURE__ */ new Map();
+    this.setAccTitle = setAccTitle;
+    this.getAccTitle = getAccTitle;
+    this.setDiagramTitle = setDiagramTitle;
+    this.getDiagramTitle = getDiagramTitle;
+    this.getAccDescription = getAccDescription;
+    this.setAccDescription = setAccDescription;
+  }
+  static {
+    __name(this, "TreeMapDB");
+  }
+  getNodes() {
+    return this.nodes;
+  }
+  getConfig() {
+    const defaultConfig = defaultConfig_default;
+    const userConfig = getConfig();
+    return cleanAndMerge({
+      ...defaultConfig.treemap,
+      ...userConfig.treemap ?? {}
+    });
+  }
+  addNode(node, level) {
+    this.nodes.push(node);
+    this.levels.set(node, level);
+    if (level === 0) {
+      this.outerNodes.push(node);
+      this.root ??= node;
+    }
+  }
+  getRoot() {
+    return { name: "", children: this.outerNodes };
+  }
+  addClass(id, _style) {
+    const styleClass = this.classes.get(id) ?? { id, styles: [], textStyles: [] };
+    const styles = _style.replace(/\\,/g, "\xA7\xA7\xA7").replace(/,/g, ";").replace(/§§§/g, ",").split(";");
+    if (styles) {
+      styles.forEach((s) => {
+        if (isLabelStyle(s)) {
+          if (styleClass?.textStyles) {
+            styleClass.textStyles.push(s);
+          } else {
+            styleClass.textStyles = [s];
+          }
+        }
+        if (styleClass?.styles) {
+          styleClass.styles.push(s);
+        } else {
+          styleClass.styles = [s];
+        }
+      });
+    }
+    this.classes.set(id, styleClass);
+  }
+  getClasses() {
+    return this.classes;
+  }
+  getStylesForClass(classSelector) {
+    return this.classes.get(classSelector)?.styles ?? [];
+  }
+  clear() {
+    clear();
+    this.nodes = [];
+    this.levels = /* @__PURE__ */ new Map();
+    this.outerNodes = [];
+    this.classes = /* @__PURE__ */ new Map();
+    this.root = void 0;
+  }
+};
+
+// src/diagrams/treemap/utils.ts
+function buildHierarchy(items) {
+  if (!items.length) {
+    return [];
+  }
+  const root = [];
+  const stack = [];
+  items.forEach((item) => {
+    const node = {
+      name: item.name,
+      children: item.type === "Leaf" ? void 0 : []
+    };
+    node.classSelector = item?.classSelector;
+    if (item?.cssCompiledStyles) {
+      node.cssCompiledStyles = item.cssCompiledStyles;
+    }
+    if (item.type === "Leaf" && item.value !== void 0) {
+      node.value = item.value;
+    }
+    while (stack.length > 0 && stack[stack.length - 1].level >= item.level) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      root.push(node);
+    } else {
+      const parent = stack[stack.length - 1].node;
+      if (parent.children) {
+        parent.children.push(node);
+      } else {
+        parent.children = [node];
+      }
+    }
+    if (item.type !== "Leaf") {
+      stack.push({ node, level: item.level });
+    }
+  });
+  return root;
+}
+__name(buildHierarchy, "buildHierarchy");
+
+// src/diagrams/treemap/parser.ts
+var populate = /* @__PURE__ */ __name((ast, db) => {
+  populateCommonDb(ast, db);
+  const items = [];
+  for (const row of ast.TreemapRows ?? []) {
+    if (row.$type === "ClassDefStatement") {
+      db.addClass(row.className ?? "", row.styleText ?? "");
+    }
+  }
+  for (const row of ast.TreemapRows ?? []) {
+    const item = row.item;
+    if (!item) {
+      continue;
+    }
+    const level = row.indent ? parseInt(row.indent) : 0;
+    const name = getItemName(item);
+    const styles = item.classSelector ? db.getStylesForClass(item.classSelector) : [];
+    const cssCompiledStyles = styles.length > 0 ? styles : void 0;
+    const itemData = {
+      level,
+      name,
+      type: item.$type,
+      value: item.value,
+      classSelector: item.classSelector,
+      cssCompiledStyles
+    };
+    items.push(itemData);
+  }
+  const hierarchyNodes = buildHierarchy(items);
+  const addNodesRecursively = /* @__PURE__ */ __name((nodes, level) => {
+    for (const node of nodes) {
+      db.addNode(node, level);
+      if (node.children && node.children.length > 0) {
+        addNodesRecursively(node.children, level + 1);
+      }
+    }
+  }, "addNodesRecursively");
+  addNodesRecursively(hierarchyNodes, 0);
+}, "populate");
+var getItemName = /* @__PURE__ */ __name((item) => {
+  return item.name ? String(item.name) : "";
+}, "getItemName");
+var parser = {
+  // @ts-expect-error - TreeMapDB is not assignable to DiagramDB
+  parser: { yy: void 0 },
+  parse: /* @__PURE__ */ __name(async (text) => {
+    try {
+      const parseFunc = parse;
+      const ast = await parseFunc("treemap", text);
+      log.debug("Treemap AST:", ast);
+      const db = parser.parser?.yy;
+      if (!(db instanceof TreeMapDB)) {
+        throw new Error(
+          "parser.parser?.yy was not a TreemapDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues."
+        );
+      }
+      populate(ast, db);
+    } catch (error) {
+      log.error("Error parsing treemap:", error);
+      throw error;
+    }
+  }, "parse")
+};
+
+// src/diagrams/treemap/renderer.ts
+var DEFAULT_INNER_PADDING = 10;
+var SECTION_INNER_PADDING = 10;
+var SECTION_HEADER_HEIGHT = 25;
+var draw = /* @__PURE__ */ __name((_text, id, _version, diagram2) => {
+  const treemapDb = diagram2.db;
+  const config = treemapDb.getConfig();
+  const treemapInnerPadding = config.padding ?? DEFAULT_INNER_PADDING;
+  const title = treemapDb.getDiagramTitle();
+  const root = treemapDb.getRoot();
+  const { themeVariables } = getConfig();
+  if (!root) {
+    return;
+  }
+  const titleHeight = title ? 30 : 0;
+  const svg = selectSvgElement(id);
+  const width = config.nodeWidth ? config.nodeWidth * SECTION_INNER_PADDING : 960;
+  const height = config.nodeHeight ? config.nodeHeight * SECTION_INNER_PADDING : 500;
+  const svgWidth = width;
+  const svgHeight = height + titleHeight;
+  svg.attr("viewBox", `0 0 ${svgWidth} ${svgHeight}`);
+  configureSvgSize(svg, svgHeight, svgWidth, config.useMaxWidth);
+  let valueFormat;
+  try {
+    const formatStr = config.valueFormat || ",";
+    if (formatStr === "$0,0") {
+      valueFormat = /* @__PURE__ */ __name((value) => "$" + format(",")(value), "valueFormat");
+    } else if (formatStr.startsWith("$") && formatStr.includes(",")) {
+      const precision = /\.\d+/.exec(formatStr);
+      const precisionStr = precision ? precision[0] : "";
+      valueFormat = /* @__PURE__ */ __name((value) => "$" + format("," + precisionStr)(value), "valueFormat");
+    } else if (formatStr.startsWith("$")) {
+      const restOfFormat = formatStr.substring(1);
+      valueFormat = /* @__PURE__ */ __name((value) => "$" + format(restOfFormat || "")(value), "valueFormat");
+    } else {
+      valueFormat = format(formatStr);
+    }
+  } catch (error) {
+    log.error("Error creating format function:", error);
+    valueFormat = format(",");
+  }
+  const colorScale = ordinal().range([
+    "transparent",
+    themeVariables.cScale0,
+    themeVariables.cScale1,
+    themeVariables.cScale2,
+    themeVariables.cScale3,
+    themeVariables.cScale4,
+    themeVariables.cScale5,
+    themeVariables.cScale6,
+    themeVariables.cScale7,
+    themeVariables.cScale8,
+    themeVariables.cScale9,
+    themeVariables.cScale10,
+    themeVariables.cScale11
+  ]);
+  const colorScalePeer = ordinal().range([
+    "transparent",
+    themeVariables.cScalePeer0,
+    themeVariables.cScalePeer1,
+    themeVariables.cScalePeer2,
+    themeVariables.cScalePeer3,
+    themeVariables.cScalePeer4,
+    themeVariables.cScalePeer5,
+    themeVariables.cScalePeer6,
+    themeVariables.cScalePeer7,
+    themeVariables.cScalePeer8,
+    themeVariables.cScalePeer9,
+    themeVariables.cScalePeer10,
+    themeVariables.cScalePeer11
+  ]);
+  const colorScaleLabel = ordinal().range([
+    themeVariables.cScaleLabel0,
+    themeVariables.cScaleLabel1,
+    themeVariables.cScaleLabel2,
+    themeVariables.cScaleLabel3,
+    themeVariables.cScaleLabel4,
+    themeVariables.cScaleLabel5,
+    themeVariables.cScaleLabel6,
+    themeVariables.cScaleLabel7,
+    themeVariables.cScaleLabel8,
+    themeVariables.cScaleLabel9,
+    themeVariables.cScaleLabel10,
+    themeVariables.cScaleLabel11
+  ]);
+  if (title) {
+    svg.append("text").attr("x", svgWidth / 2).attr("y", titleHeight / 2).attr("class", "treemapTitle").attr("text-anchor", "middle").attr("dominant-baseline", "middle").text(title);
+  }
+  const g = svg.append("g").attr("transform", `translate(0, ${titleHeight})`).attr("class", "treemapContainer");
+  const hierarchyRoot = hierarchy(root).sum((d) => d.value ?? 0).sort((a, b) => (b.value ?? 0) - (a.value ?? 0));
+  const treemapLayout = treemap_default().size([width, height]).paddingTop(
+    (d) => d.children && d.children.length > 0 ? SECTION_HEADER_HEIGHT + SECTION_INNER_PADDING : 0
+  ).paddingInner(treemapInnerPadding).paddingLeft((d) => d.children && d.children.length > 0 ? SECTION_INNER_PADDING : 0).paddingRight((d) => d.children && d.children.length > 0 ? SECTION_INNER_PADDING : 0).paddingBottom((d) => d.children && d.children.length > 0 ? SECTION_INNER_PADDING : 0).round(true);
+  const treemapData = treemapLayout(hierarchyRoot);
+  const branchNodes = treemapData.descendants().filter((d) => d.children && d.children.length > 0);
+  const sections = g.selectAll(".treemapSection").data(branchNodes).enter().append("g").attr("class", "treemapSection").attr("transform", (d) => `translate(${d.x0},${d.y0})`);
+  sections.append("rect").attr("width", (d) => d.x1 - d.x0).attr("height", SECTION_HEADER_HEIGHT).attr("class", "treemapSectionHeader").attr("fill", "none").attr("fill-opacity", 0.6).attr("stroke-width", 0.6).attr("style", (d) => {
+    if (d.depth === 0) {
+      return "display: none;";
+    }
+    return "";
+  });
+  sections.append("clipPath").attr("id", (_d, i) => `clip-section-${id}-${i}`).append("rect").attr("width", (d) => Math.max(0, d.x1 - d.x0 - 12)).attr("height", SECTION_HEADER_HEIGHT);
+  sections.append("rect").attr("width", (d) => d.x1 - d.x0).attr("height", (d) => d.y1 - d.y0).attr("class", (_d, i) => {
+    return `treemapSection section${i}`;
+  }).attr("fill", (d) => colorScale(d.data.name)).attr("fill-opacity", 0.6).attr("stroke", (d) => colorScalePeer(d.data.name)).attr("stroke-width", 2).attr("stroke-opacity", 0.4).attr("style", (d) => {
+    if (d.depth === 0) {
+      return "display: none;";
+    }
+    const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
+    return styles.nodeStyles + ";" + styles.borderStyles.join(";");
+  });
+  sections.append("text").attr("class", "treemapSectionLabel").attr("x", 6).attr("y", SECTION_HEADER_HEIGHT / 2).attr("dominant-baseline", "middle").text((d) => d.depth === 0 ? "" : d.data.name).attr("font-weight", "bold").attr("style", (d) => {
+    if (d.depth === 0) {
+      return "display: none;";
+    }
+    const labelStyles = "dominant-baseline: middle; font-size: 12px; fill:" + colorScaleLabel(d.data.name) + "; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;";
+    const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
+    return labelStyles + styles.labelStyles.replace("color:", "fill:");
+  }).each(function(d) {
+    if (d.depth === 0) {
+      return;
+    }
+    const self = select_default(this);
+    const originalText = d.data.name;
+    self.text(originalText);
+    const totalHeaderWidth = d.x1 - d.x0;
+    const labelXPosition = 6;
+    let spaceForTextContent;
+    if (config.showValues !== false && d.value) {
+      const valueEndsAtXRelative = totalHeaderWidth - 10;
+      const estimatedValueTextActualWidth = 30;
+      const gapBetweenLabelAndValue = 10;
+      const labelMustEndBeforeX = valueEndsAtXRelative - estimatedValueTextActualWidth - gapBetweenLabelAndValue;
+      spaceForTextContent = labelMustEndBeforeX - labelXPosition;
+    } else {
+      const labelOwnRightPadding = 6;
+      spaceForTextContent = totalHeaderWidth - labelXPosition - labelOwnRightPadding;
+    }
+    const minimumWidthToDisplay = 15;
+    const actualAvailableWidth = Math.max(minimumWidthToDisplay, spaceForTextContent);
+    const textNode = self.node();
+    const currentTextContentLength = textNode.getComputedTextLength();
+    if (currentTextContentLength > actualAvailableWidth) {
+      const ellipsis = "...";
+      let currentTruncatedText = originalText;
+      while (currentTruncatedText.length > 0) {
+        currentTruncatedText = originalText.substring(0, currentTruncatedText.length - 1);
+        if (currentTruncatedText.length === 0) {
+          self.text(ellipsis);
+          if (textNode.getComputedTextLength() > actualAvailableWidth) {
+            self.text("");
+          }
+          break;
+        }
+        self.text(currentTruncatedText + ellipsis);
+        if (textNode.getComputedTextLength() <= actualAvailableWidth) {
+          break;
+        }
+      }
+    }
+  });
+  if (config.showValues !== false) {
+    sections.append("text").attr("class", "treemapSectionValue").attr("x", (d) => d.x1 - d.x0 - 10).attr("y", SECTION_HEADER_HEIGHT / 2).attr("text-anchor", "end").attr("dominant-baseline", "middle").text((d) => d.value ? valueFormat(d.value) : "").attr("font-style", "italic").attr("style", (d) => {
+      if (d.depth === 0) {
+        return "display: none;";
+      }
+      const labelStyles = "text-anchor: end; dominant-baseline: middle; font-size: 10px; fill:" + colorScaleLabel(d.data.name) + "; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;";
+      const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
+      return labelStyles + styles.labelStyles.replace("color:", "fill:");
+    });
+  }
+  const leafNodes = treemapData.leaves();
+  const cell = g.selectAll(".treemapLeafGroup").data(leafNodes).enter().append("g").attr("class", (d, i) => {
+    return `treemapNode treemapLeafGroup leaf${i}${d.data.classSelector ? ` ${d.data.classSelector}` : ""}x`;
+  }).attr("transform", (d) => `translate(${d.x0},${d.y0})`);
+  cell.append("rect").attr("width", (d) => d.x1 - d.x0).attr("height", (d) => d.y1 - d.y0).attr("class", "treemapLeaf").attr("fill", (d) => {
+    return d.parent ? colorScale(d.parent.data.name) : colorScale(d.data.name);
+  }).attr("style", (d) => {
+    const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
+    return styles.nodeStyles;
+  }).attr("fill-opacity", 0.3).attr("stroke", (d) => {
+    return d.parent ? colorScale(d.parent.data.name) : colorScale(d.data.name);
+  }).attr("stroke-width", 3);
+  cell.append("clipPath").attr("id", (_d, i) => `clip-${id}-${i}`).append("rect").attr("width", (d) => Math.max(0, d.x1 - d.x0 - 4)).attr("height", (d) => Math.max(0, d.y1 - d.y0 - 4));
+  const leafLabels = cell.append("text").attr("class", "treemapLabel").attr("x", (d) => (d.x1 - d.x0) / 2).attr("y", (d) => (d.y1 - d.y0) / 2).attr("style", (d) => {
+    const labelStyles = "text-anchor: middle; dominant-baseline: middle; font-size: 38px;fill:" + colorScaleLabel(d.data.name) + ";";
+    const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
+    return labelStyles + styles.labelStyles.replace("color:", "fill:");
+  }).attr("clip-path", (_d, i) => `url(#clip-${id}-${i})`).text((d) => d.data.name);
+  leafLabels.each(function(d) {
+    const self = select_default(this);
+    const nodeWidth = d.x1 - d.x0;
+    const nodeHeight = d.y1 - d.y0;
+    const textNode = self.node();
+    const padding = 4;
+    const availableWidth = nodeWidth - 2 * padding;
+    const availableHeight = nodeHeight - 2 * padding;
+    if (availableWidth < 10 || availableHeight < 10) {
+      self.style("display", "none");
+      return;
+    }
+    let currentLabelFontSize = parseInt(self.style("font-size"), 10);
+    const minLabelFontSize = 8;
+    const originalValueRelFontSize = 28;
+    const valueScaleFactor = 0.6;
+    const minValueFontSize = 6;
+    const spacingBetweenLabelAndValue = 2;
+    while (textNode.getComputedTextLength() > availableWidth && currentLabelFontSize > minLabelFontSize) {
+      currentLabelFontSize--;
+      self.style("font-size", `${currentLabelFontSize}px`);
+    }
+    let prospectiveValueFontSize = Math.max(
+      minValueFontSize,
+      Math.min(originalValueRelFontSize, Math.round(currentLabelFontSize * valueScaleFactor))
+    );
+    let combinedHeight = currentLabelFontSize + spacingBetweenLabelAndValue + prospectiveValueFontSize;
+    while (combinedHeight > availableHeight && currentLabelFontSize > minLabelFontSize) {
+      currentLabelFontSize--;
+      prospectiveValueFontSize = Math.max(
+        minValueFontSize,
+        Math.min(originalValueRelFontSize, Math.round(currentLabelFontSize * valueScaleFactor))
+      );
+      if (prospectiveValueFontSize < minValueFontSize && currentLabelFontSize === minLabelFontSize) {
+        break;
+      }
+      self.style("font-size", `${currentLabelFontSize}px`);
+      combinedHeight = currentLabelFontSize + spacingBetweenLabelAndValue + prospectiveValueFontSize;
+      if (prospectiveValueFontSize <= minValueFontSize && combinedHeight > availableHeight) {
+      }
+    }
+    self.style("font-size", `${currentLabelFontSize}px`);
+    if (textNode.getComputedTextLength() > availableWidth || currentLabelFontSize < minLabelFontSize || availableHeight < currentLabelFontSize) {
+      self.style("display", "none");
+    }
+  });
+  if (config.showValues !== false) {
+    const leafValues = cell.append("text").attr("class", "treemapValue").attr("x", (d) => (d.x1 - d.x0) / 2).attr("y", function(d) {
+      return (d.y1 - d.y0) / 2;
+    }).attr("style", (d) => {
+      const labelStyles = "text-anchor: middle; dominant-baseline: hanging; font-size: 28px;fill:" + colorScaleLabel(d.data.name) + ";";
+      const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
+      return labelStyles + styles.labelStyles.replace("color:", "fill:");
+    }).attr("clip-path", (_d, i) => `url(#clip-${id}-${i})`).text((d) => d.value ? valueFormat(d.value) : "");
+    leafValues.each(function(d) {
+      const valueTextElement = select_default(this);
+      const parentCellNode = this.parentNode;
+      if (!parentCellNode) {
+        valueTextElement.style("display", "none");
+        return;
+      }
+      const labelElement = select_default(parentCellNode).select(".treemapLabel");
+      if (labelElement.empty() || labelElement.style("display") === "none") {
+        valueTextElement.style("display", "none");
+        return;
+      }
+      const finalLabelFontSize = parseFloat(labelElement.style("font-size"));
+      const originalValueFontSize = 28;
+      const valueScaleFactor = 0.6;
+      const minValueFontSize = 6;
+      const spacingBetweenLabelAndValue = 2;
+      const actualValueFontSize = Math.max(
+        minValueFontSize,
+        Math.min(originalValueFontSize, Math.round(finalLabelFontSize * valueScaleFactor))
+      );
+      valueTextElement.style("font-size", `${actualValueFontSize}px`);
+      const labelCenterY = (d.y1 - d.y0) / 2;
+      const valueTopActualY = labelCenterY + finalLabelFontSize / 2 + spacingBetweenLabelAndValue;
+      valueTextElement.attr("y", valueTopActualY);
+      const nodeWidth = d.x1 - d.x0;
+      const nodeTotalHeight = d.y1 - d.y0;
+      const cellBottomPadding = 4;
+      const maxValueBottomY = nodeTotalHeight - cellBottomPadding;
+      const availableWidthForValue = nodeWidth - 2 * 4;
+      if (valueTextElement.node().getComputedTextLength() > availableWidthForValue || valueTopActualY + actualValueFontSize > maxValueBottomY || actualValueFontSize < minValueFontSize) {
+        valueTextElement.style("display", "none");
+      } else {
+        valueTextElement.style("display", null);
+      }
+    });
+  }
+  const diagramPadding = config.diagramPadding ?? 8;
+  setupViewPortForSVG(svg, diagramPadding, "flowchart", config?.useMaxWidth || false);
+}, "draw");
+var getClasses = /* @__PURE__ */ __name(function(_text, diagramObj) {
+  return diagramObj.db.getClasses();
+}, "getClasses");
+var renderer = { draw, getClasses };
+
+// src/diagrams/treemap/styles.ts
+var defaultTreemapStyleOptions = {
+  sectionStrokeColor: "black",
+  sectionStrokeWidth: "1",
+  sectionFillColor: "#efefef",
+  leafStrokeColor: "black",
+  leafStrokeWidth: "1",
+  leafFillColor: "#efefef",
+  labelFontSize: "12px",
+  valueFontSize: "10px",
+  titleFontSize: "14px"
+};
+var getStyles = /* @__PURE__ */ __name(({
+  treemap
+} = {}) => {
+  const defaultThemeVariables = getThemeVariables();
+  const currentConfig = getConfig();
+  const themeVariables = cleanAndMerge(defaultThemeVariables, currentConfig.themeVariables);
+  const options = cleanAndMerge(defaultTreemapStyleOptions, treemap);
+  const titleColor = options.titleColor ?? themeVariables.titleColor;
+  const labelColor = options.labelColor ?? themeVariables.textColor;
+  const valueColor = options.valueColor ?? themeVariables.textColor;
+  return `
+  .treemapNode.section {
+    stroke: ${options.sectionStrokeColor};
+    stroke-width: ${options.sectionStrokeWidth};
+    fill: ${options.sectionFillColor};
+  }
+  .treemapNode.leaf {
+    stroke: ${options.leafStrokeColor};
+    stroke-width: ${options.leafStrokeWidth};
+    fill: ${options.leafFillColor};
+  }
+  .treemapLabel {
+    fill: ${labelColor};
+    font-size: ${options.labelFontSize};
+  }
+  .treemapValue {
+    fill: ${valueColor};
+    font-size: ${options.valueFontSize};
+  }
+  .treemapTitle {
+    fill: ${titleColor};
+    font-size: ${options.titleFontSize};
+  }
+  `;
+}, "getStyles");
+var styles_default = getStyles;
+
+// src/diagrams/treemap/diagram.ts
+var diagram = {
+  parser,
+  get db() {
+    return new TreeMapDB();
+  },
+  renderer,
+  styles: styles_default
+};
+export {
+  diagram
+};

praesentation/node_modules/mermaid/dist/chunks/mermaid.esm/diagram-ZEGC52LS.mjs

@@ -0,0 +1,351 @@
+import {
+  populateCommonDb
+} from "./chunk-6ZKBGPIT.mjs";
+import {
+  parse
+} from "./chunk-2ENXBMWA.mjs";
+import "./chunk-HQDACWF7.mjs";
+import "./chunk-CYW2HGLJ.mjs";
+import "./chunk-CT5Q72BK.mjs";
+import "./chunk-3O5MS6M4.mjs";
+import "./chunk-D6UAH5RW.mjs";
+import "./chunk-LJRZYMMA.mjs";
+import "./chunk-NZTEHIZO.mjs";
+import "./chunk-WM6EUEOH.mjs";
+import "./chunk-D6MTONMS.mjs";
+import {
+  selectSvgElement
+} from "./chunk-PUIB63ON.mjs";
+import {
+  cleanAndMerge
+} from "./chunk-BSZA5ISF.mjs";
+import "./chunk-7TFACZ55.mjs";
+import {
+  clear,
+  configureSvgSize,
+  defaultConfig_default,
+  getAccDescription,
+  getAccTitle,
+  getConfig,
+  getDiagramTitle,
+  getThemeVariables,
+  setAccDescription,
+  setAccTitle,
+  setDiagramTitle
+} from "./chunk-Q52JI7PB.mjs";
+import {
+  log
+} from "./chunk-V7P66DNM.mjs";
+import "./chunk-BBDM4ZFP.mjs";
+import "./chunk-NW2N4LI3.mjs";
+import {
+  __name
+} from "./chunk-PTVI3W5X.mjs";
+
+// src/diagrams/radar/db.ts
+var defaultOptions = {
+  showLegend: true,
+  ticks: 5,
+  max: null,
+  min: 0,
+  graticule: "circle"
+};
+var defaultRadarData = {
+  axes: [],
+  curves: [],
+  options: defaultOptions
+};
+var data = structuredClone(defaultRadarData);
+var DEFAULT_RADAR_CONFIG = defaultConfig_default.radar;
+var getConfig2 = /* @__PURE__ */ __name(() => {
+  const config = cleanAndMerge({
+    ...DEFAULT_RADAR_CONFIG,
+    ...getConfig().radar
+  });
+  return config;
+}, "getConfig");
+var getAxes = /* @__PURE__ */ __name(() => data.axes, "getAxes");
+var getCurves = /* @__PURE__ */ __name(() => data.curves, "getCurves");
+var getOptions = /* @__PURE__ */ __name(() => data.options, "getOptions");
+var setAxes = /* @__PURE__ */ __name((axes) => {
+  data.axes = axes.map((axis) => {
+    return {
+      name: axis.name,
+      label: axis.label ?? axis.name
+    };
+  });
+}, "setAxes");
+var setCurves = /* @__PURE__ */ __name((curves) => {
+  data.curves = curves.map((curve) => {
+    return {
+      name: curve.name,
+      label: curve.label ?? curve.name,
+      entries: computeCurveEntries(curve.entries)
+    };
+  });
+}, "setCurves");
+var computeCurveEntries = /* @__PURE__ */ __name((entries) => {
+  if (entries[0].axis == void 0) {
+    return entries.map((entry) => entry.value);
+  }
+  const axes = getAxes();
+  if (axes.length === 0) {
+    throw new Error("Axes must be populated before curves for reference entries");
+  }
+  return axes.map((axis) => {
+    const entry = entries.find((entry2) => entry2.axis?.$refText === axis.name);
+    if (entry === void 0) {
+      throw new Error("Missing entry for axis " + axis.label);
+    }
+    return entry.value;
+  });
+}, "computeCurveEntries");
+var setOptions = /* @__PURE__ */ __name((options) => {
+  const optionMap = options.reduce(
+    (acc, option) => {
+      acc[option.name] = option;
+      return acc;
+    },
+    {}
+  );
+  data.options = {
+    showLegend: optionMap.showLegend?.value ?? defaultOptions.showLegend,
+    ticks: optionMap.ticks?.value ?? defaultOptions.ticks,
+    max: optionMap.max?.value ?? defaultOptions.max,
+    min: optionMap.min?.value ?? defaultOptions.min,
+    graticule: optionMap.graticule?.value ?? defaultOptions.graticule
+  };
+}, "setOptions");
+var clear2 = /* @__PURE__ */ __name(() => {
+  clear();
+  data = structuredClone(defaultRadarData);
+}, "clear");
+var db = {
+  getAxes,
+  getCurves,
+  getOptions,
+  setAxes,
+  setCurves,
+  setOptions,
+  getConfig: getConfig2,
+  clear: clear2,
+  setAccTitle,
+  getAccTitle,
+  setDiagramTitle,
+  getDiagramTitle,
+  getAccDescription,
+  setAccDescription
+};
+
+// src/diagrams/radar/parser.ts
+var populate = /* @__PURE__ */ __name((ast) => {
+  populateCommonDb(ast, db);
+  const { axes, curves, options } = ast;
+  db.setAxes(axes);
+  db.setCurves(curves);
+  db.setOptions(options);
+}, "populate");
+var parser = {
+  parse: /* @__PURE__ */ __name(async (input) => {
+    const ast = await parse("radar", input);
+    log.debug(ast);
+    populate(ast);
+  }, "parse")
+};
+
+// src/diagrams/radar/renderer.ts
+var draw = /* @__PURE__ */ __name((_text, id, _version, diagram2) => {
+  const db2 = diagram2.db;
+  const axes = db2.getAxes();
+  const curves = db2.getCurves();
+  const options = db2.getOptions();
+  const config = db2.getConfig();
+  const title = db2.getDiagramTitle();
+  const svg = selectSvgElement(id);
+  const g = drawFrame(svg, config);
+  const maxValue = options.max ?? Math.max(...curves.map((curve) => Math.max(...curve.entries)));
+  const minValue = options.min;
+  const radius = Math.min(config.width, config.height) / 2;
+  drawGraticule(g, axes, radius, options.ticks, options.graticule);
+  drawAxes(g, axes, radius, config);
+  drawCurves(g, axes, curves, minValue, maxValue, options.graticule, config);
+  drawLegend(g, curves, options.showLegend, config);
+  g.append("text").attr("class", "radarTitle").text(title).attr("x", 0).attr("y", -config.height / 2 - config.marginTop);
+}, "draw");
+var drawFrame = /* @__PURE__ */ __name((svg, config) => {
+  const totalWidth = config.width + config.marginLeft + config.marginRight;
+  const totalHeight = config.height + config.marginTop + config.marginBottom;
+  const center = {
+    x: config.marginLeft + config.width / 2,
+    y: config.marginTop + config.height / 2
+  };
+  configureSvgSize(svg, totalHeight, totalWidth, config.useMaxWidth ?? true);
+  svg.attr("viewBox", `0 0 ${totalWidth} ${totalHeight}`);
+  return svg.append("g").attr("transform", `translate(${center.x}, ${center.y})`);
+}, "drawFrame");
+var drawGraticule = /* @__PURE__ */ __name((g, axes, radius, ticks, graticule) => {
+  if (graticule === "circle") {
+    for (let i = 0; i < ticks; i++) {
+      const r = radius * (i + 1) / ticks;
+      g.append("circle").attr("r", r).attr("class", "radarGraticule");
+    }
+  } else if (graticule === "polygon") {
+    const numAxes = axes.length;
+    for (let i = 0; i < ticks; i++) {
+      const r = radius * (i + 1) / ticks;
+      const points = axes.map((_, j) => {
+        const angle = 2 * j * Math.PI / numAxes - Math.PI / 2;
+        const x = r * Math.cos(angle);
+        const y = r * Math.sin(angle);
+        return `${x},${y}`;
+      }).join(" ");
+      g.append("polygon").attr("points", points).attr("class", "radarGraticule");
+    }
+  }
+}, "drawGraticule");
+var drawAxes = /* @__PURE__ */ __name((g, axes, radius, config) => {
+  const numAxes = axes.length;
+  for (let i = 0; i < numAxes; i++) {
+    const label = axes[i].label;
+    const angle = 2 * i * Math.PI / numAxes - Math.PI / 2;
+    g.append("line").attr("x1", 0).attr("y1", 0).attr("x2", radius * config.axisScaleFactor * Math.cos(angle)).attr("y2", radius * config.axisScaleFactor * Math.sin(angle)).attr("class", "radarAxisLine");
+    g.append("text").text(label).attr("x", radius * config.axisLabelFactor * Math.cos(angle)).attr("y", radius * config.axisLabelFactor * Math.sin(angle)).attr("class", "radarAxisLabel");
+  }
+}, "drawAxes");
+function drawCurves(g, axes, curves, minValue, maxValue, graticule, config) {
+  const numAxes = axes.length;
+  const radius = Math.min(config.width, config.height) / 2;
+  curves.forEach((curve, index) => {
+    if (curve.entries.length !== numAxes) {
+      return;
+    }
+    const points = curve.entries.map((entry, i) => {
+      const angle = 2 * Math.PI * i / numAxes - Math.PI / 2;
+      const r = relativeRadius(entry, minValue, maxValue, radius);
+      const x = r * Math.cos(angle);
+      const y = r * Math.sin(angle);
+      return { x, y };
+    });
+    if (graticule === "circle") {
+      g.append("path").attr("d", closedRoundCurve(points, config.curveTension)).attr("class", `radarCurve-${index}`);
+    } else if (graticule === "polygon") {
+      g.append("polygon").attr("points", points.map((p) => `${p.x},${p.y}`).join(" ")).attr("class", `radarCurve-${index}`);
+    }
+  });
+}
+__name(drawCurves, "drawCurves");
+function relativeRadius(value, minValue, maxValue, radius) {
+  const clippedValue = Math.min(Math.max(value, minValue), maxValue);
+  return radius * (clippedValue - minValue) / (maxValue - minValue);
+}
+__name(relativeRadius, "relativeRadius");
+function closedRoundCurve(points, tension) {
+  const numPoints = points.length;
+  let d = `M${points[0].x},${points[0].y}`;
+  for (let i = 0; i < numPoints; i++) {
+    const p0 = points[(i - 1 + numPoints) % numPoints];
+    const p1 = points[i];
+    const p2 = points[(i + 1) % numPoints];
+    const p3 = points[(i + 2) % numPoints];
+    const cp1 = {
+      x: p1.x + (p2.x - p0.x) * tension,
+      y: p1.y + (p2.y - p0.y) * tension
+    };
+    const cp2 = {
+      x: p2.x - (p3.x - p1.x) * tension,
+      y: p2.y - (p3.y - p1.y) * tension
+    };
+    d += ` C${cp1.x},${cp1.y} ${cp2.x},${cp2.y} ${p2.x},${p2.y}`;
+  }
+  return `${d} Z`;
+}
+__name(closedRoundCurve, "closedRoundCurve");
+function drawLegend(g, curves, showLegend, config) {
+  if (!showLegend) {
+    return;
+  }
+  const legendX = (config.width / 2 + config.marginRight) * 3 / 4;
+  const legendY = -(config.height / 2 + config.marginTop) * 3 / 4;
+  const lineHeight = 20;
+  curves.forEach((curve, index) => {
+    const itemGroup = g.append("g").attr("transform", `translate(${legendX}, ${legendY + index * lineHeight})`);
+    itemGroup.append("rect").attr("width", 12).attr("height", 12).attr("class", `radarLegendBox-${index}`);
+    itemGroup.append("text").attr("x", 16).attr("y", 0).attr("class", "radarLegendText").text(curve.label);
+  });
+}
+__name(drawLegend, "drawLegend");
+var renderer = { draw };
+
+// src/diagrams/radar/styles.ts
+var genIndexStyles = /* @__PURE__ */ __name((themeVariables, radarOptions) => {
+  let sections = "";
+  for (let i = 0; i < themeVariables.THEME_COLOR_LIMIT; i++) {
+    const indexColor = themeVariables[`cScale${i}`];
+    sections += `
+		.radarCurve-${i} {
+			color: ${indexColor};
+			fill: ${indexColor};
+			fill-opacity: ${radarOptions.curveOpacity};
+			stroke: ${indexColor};
+			stroke-width: ${radarOptions.curveStrokeWidth};
+		}
+		.radarLegendBox-${i} {
+			fill: ${indexColor};
+			fill-opacity: ${radarOptions.curveOpacity};
+			stroke: ${indexColor};
+		}
+		`;
+  }
+  return sections;
+}, "genIndexStyles");
+var buildRadarStyleOptions = /* @__PURE__ */ __name((radar) => {
+  const defaultThemeVariables = getThemeVariables();
+  const currentConfig = getConfig();
+  const themeVariables = cleanAndMerge(defaultThemeVariables, currentConfig.themeVariables);
+  const radarOptions = cleanAndMerge(themeVariables.radar, radar);
+  return { themeVariables, radarOptions };
+}, "buildRadarStyleOptions");
+var styles = /* @__PURE__ */ __name(({ radar } = {}) => {
+  const { themeVariables, radarOptions } = buildRadarStyleOptions(radar);
+  return `
+	.radarTitle {
+		font-size: ${themeVariables.fontSize};
+		color: ${themeVariables.titleColor};
+		dominant-baseline: hanging;
+		text-anchor: middle;
+	}
+	.radarAxisLine {
+		stroke: ${radarOptions.axisColor};
+		stroke-width: ${radarOptions.axisStrokeWidth};
+	}
+	.radarAxisLabel {
+		dominant-baseline: middle;
+		text-anchor: middle;
+		font-size: ${radarOptions.axisLabelFontSize}px;
+		color: ${radarOptions.axisColor};
+	}
+	.radarGraticule {
+		fill: ${radarOptions.graticuleColor};
+		fill-opacity: ${radarOptions.graticuleOpacity};
+		stroke: ${radarOptions.graticuleColor};
+		stroke-width: ${radarOptions.graticuleStrokeWidth};
+	}
+	.radarLegendText {
+		text-anchor: start;
+		font-size: ${radarOptions.legendFontSize}px;
+		dominant-baseline: hanging;
+	}
+	${genIndexStyles(themeVariables, radarOptions)}
+	`;
+}, "styles");
+
+// src/diagrams/radar/diagram.ts
+var diagram = {
+  parser,
+  db,
+  renderer,
+  styles
+};
+export {
+  diagram
+};