@fecp/designer 5.6.6 → 5.6.8

package/es/node_modules/mermaid/dist/mermaid.core.mjs

@@ -0,0 +1,1468 @@
+var _a;
+import { selectSvgElement } from "./chunks/mermaid.core/chunk-VAUOI2AC.mjs";
+import { load, JSON_SCHEMA } from "./chunks/mermaid.core/chunk-ZIRB5QZD.mjs";
+import { registerLayoutLoaders } from "./chunks/mermaid.core/chunk-FWX5IMBZ.mjs";
+import "./chunks/mermaid.core/chunk-52WLFC77.mjs";
+import "./chunks/mermaid.core/chunk-ZGVPDNZ5.mjs";
+import { detectType, registerLazyLoadedDiagrams, defaultConfig, updateSiteConfig, getSiteConfig, setConfig, getConfig, reset, registerDiagram, detectors, getDiagram, assignWithDepth_default, saveConfigFromInitialize, themes_default, setSiteConfig, evaluate, configureSvgSize, getDiagramLoader, UnknownDiagramError, addDirective, styles_default, getEffectiveHtmlLabels, cssStyleSheetToString, frontMatterRegex, sanitizeCss } from "./chunks/mermaid.core/chunk-WYO6CB5R.mjs";
+import { __name } from "./chunks/mermaid.core/chunk-Y2CYZVJY.mjs";
+import "./chunks/mermaid.core/chunk-7BUUIJ7U.mjs";
+import "./chunks/mermaid.core/chunk-OGEWGWER.mjs";
+import "./chunks/mermaid.core/chunk-Q4XR5HBZ.mjs";
+import { registerIconPacks } from "./chunks/mermaid.core/chunk-HOUHSVGY.mjs";
+import { isDetailedError, utils_default, cleanAndMerge, encodeEntities, decodeEntities, removeDirectives } from "./chunks/mermaid.core/chunk-ICXQ74PX.mjs";
+import { log, setLogLevel } from "./chunks/mermaid.core/chunk-X3CZISLH.mjs";
+import { dedent } from "../../ts-dedent/esm/index.mjs";
+import "../../d3-transition/src/selection/index.mjs";
+import "../../d3-zoom/src/transform.mjs";
+import purify from "../../dompurify/dist/purify.es.mjs";
+import { isEmpty } from "../../es-toolkit/dist/compat/predicate/isEmpty.mjs";
+import { serialize, stringify } from "../../stylis/src/Serializer.mjs";
+import { compile } from "../../stylis/src/Parser.mjs";
+import { middleware } from "../../stylis/src/Middleware.mjs";
+import { KEYFRAMES, MEDIA, SUPPORTS, LAYER, SCOPE, COMMENT } from "../../stylis/src/Enum.mjs";
+import select from "../../d3-selection/src/select.mjs";
+var id = "c4";
+var detector = /* @__PURE__ */ __name((txt) => {
+  return /^\s*C4Context|C4Container|C4Component|C4Dynamic|C4Deployment/.test(txt);
+}, "detector");
+var loader = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/c4Diagram-LMCZKHZV.mjs");
+  return { id, diagram: diagram2 };
+}, "loader");
+var plugin = {
+  id,
+  detector,
+  loader
+};
+var c4Detector_default = plugin;
+var id2 = "flowchart";
+var detector2 = /* @__PURE__ */ __name((txt, config) => {
+  var _a2, _b;
+  if (((_a2 = config == null ? void 0 : config.flowchart) == null ? void 0 : _a2.defaultRenderer) === "dagre-wrapper" || ((_b = config == null ? void 0 : config.flowchart) == null ? void 0 : _b.defaultRenderer) === "elk") {
+    return false;
+  }
+  return /^\s*graph/.test(txt);
+}, "detector");
+var loader2 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/flowDiagram-23GEKE2U.mjs");
+  return { id: id2, diagram: diagram2 };
+}, "loader");
+var plugin2 = {
+  id: id2,
+  detector: detector2,
+  loader: loader2
+};
+var flowDetector_default = plugin2;
+var id3 = "flowchart-v2";
+var detector3 = /* @__PURE__ */ __name((txt, config) => {
+  var _a2, _b, _c;
+  if (((_a2 = config == null ? void 0 : config.flowchart) == null ? void 0 : _a2.defaultRenderer) === "dagre-d3") {
+    return false;
+  }
+  if (((_b = config == null ? void 0 : config.flowchart) == null ? void 0 : _b.defaultRenderer) === "elk") {
+    config.layout = "elk";
+  }
+  if (/^\s*graph/.test(txt) && ((_c = config == null ? void 0 : config.flowchart) == null ? void 0 : _c.defaultRenderer) === "dagre-wrapper") {
+    return true;
+  }
+  return /^\s*flowchart/.test(txt);
+}, "detector");
+var loader3 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/flowDiagram-23GEKE2U.mjs");
+  return { id: id3, diagram: diagram2 };
+}, "loader");
+var plugin3 = {
+  id: id3,
+  detector: detector3,
+  loader: loader3
+};
+var flowDetector_v2_default = plugin3;
+var id4 = "swimlane";
+var detector4 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*swimlane-beta\b/.test(txt);
+}, "detector");
+var loader4 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/swimlanesDiagram-G3AALYLV.mjs");
+  return { id: id4, diagram: diagram2 };
+}, "loader");
+var plugin4 = {
+  id: id4,
+  detector: detector4,
+  loader: loader4
+};
+var detector_default = plugin4;
+var id5 = "er";
+var detector5 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*erDiagram/.test(txt);
+}, "detector");
+var loader5 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/erDiagram-Q63AITRT.mjs");
+  return { id: id5, diagram: diagram2 };
+}, "loader");
+var plugin5 = {
+  id: id5,
+  detector: detector5,
+  loader: loader5
+};
+var erDetector_default = plugin5;
+var id6 = "gitGraph";
+var detector6 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*gitGraph/.test(txt);
+}, "detector");
+var loader6 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/gitGraphDiagram-IHSO6WYX.mjs");
+  return { id: id6, diagram: diagram2 };
+}, "loader");
+var plugin6 = {
+  id: id6,
+  detector: detector6,
+  loader: loader6
+};
+var gitGraphDetector_default = plugin6;
+var id7 = "gantt";
+var detector7 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*gantt/.test(txt);
+}, "detector");
+var loader7 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/ganttDiagram-NO4QXBWP.mjs");
+  return { id: id7, diagram: diagram2 };
+}, "loader");
+var plugin7 = {
+  id: id7,
+  detector: detector7,
+  loader: loader7
+};
+var ganttDetector_default = plugin7;
+var id8 = "info";
+var detector8 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*info/.test(txt);
+}, "detector");
+var loader8 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/infoDiagram-FWYZ7A6U.mjs");
+  return { id: id8, diagram: diagram2 };
+}, "loader");
+var info = {
+  id: id8,
+  detector: detector8,
+  loader: loader8
+};
+var id9 = "pie";
+var detector9 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*pie/.test(txt);
+}, "detector");
+var loader9 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/pieDiagram-ENE6RG2P.mjs");
+  return { id: id9, diagram: diagram2 };
+}, "loader");
+var pie = {
+  id: id9,
+  detector: detector9,
+  loader: loader9
+};
+var id10 = "quadrantChart";
+var detector10 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*quadrantChart/.test(txt);
+}, "detector");
+var loader10 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/quadrantDiagram-ABIIQ3AL.mjs");
+  return { id: id10, diagram: diagram2 };
+}, "loader");
+var plugin8 = {
+  id: id10,
+  detector: detector10,
+  loader: loader10
+};
+var quadrantDetector_default = plugin8;
+var id11 = "xychart";
+var detector11 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*xychart(-beta)?/.test(txt);
+}, "detector");
+var loader11 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/xychartDiagram-FW5EYKEG.mjs");
+  return { id: id11, diagram: diagram2 };
+}, "loader");
+var plugin9 = {
+  id: id11,
+  detector: detector11,
+  loader: loader11
+};
+var xychartDetector_default = plugin9;
+var id12 = "requirement";
+var detector12 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*requirement(Diagram)?/.test(txt);
+}, "detector");
+var loader12 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/requirementDiagram-TGXJPOKE.mjs");
+  return { id: id12, diagram: diagram2 };
+}, "loader");
+var plugin10 = {
+  id: id12,
+  detector: detector12,
+  loader: loader12
+};
+var requirementDetector_default = plugin10;
+var id13 = "sequence";
+var detector13 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*sequenceDiagram/.test(txt);
+}, "detector");
+var loader13 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/sequenceDiagram-DBY2YBRQ.mjs");
+  return { id: id13, diagram: diagram2 };
+}, "loader");
+var plugin11 = {
+  id: id13,
+  detector: detector13,
+  loader: loader13
+};
+var sequenceDetector_default = plugin11;
+var id14 = "class";
+var detector14 = /* @__PURE__ */ __name((txt, config) => {
+  var _a2;
+  if (((_a2 = config == null ? void 0 : config.class) == null ? void 0 : _a2.defaultRenderer) === "dagre-wrapper") {
+    return false;
+  }
+  return /^\s*classDiagram/.test(txt);
+}, "detector");
+var loader14 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/classDiagram-OUVF2IWQ.mjs");
+  return { id: id14, diagram: diagram2 };
+}, "loader");
+var plugin12 = {
+  id: id14,
+  detector: detector14,
+  loader: loader14
+};
+var classDetector_default = plugin12;
+var id15 = "classDiagram";
+var detector15 = /* @__PURE__ */ __name((txt, config) => {
+  var _a2;
+  if (/^\s*classDiagram/.test(txt) && ((_a2 = config == null ? void 0 : config.class) == null ? void 0 : _a2.defaultRenderer) === "dagre-wrapper") {
+    return true;
+  }
+  return /^\s*classDiagram-v2/.test(txt);
+}, "detector");
+var loader15 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/classDiagram-v2-EOCWNBFH.mjs");
+  return { id: id15, diagram: diagram2 };
+}, "loader");
+var plugin13 = {
+  id: id15,
+  detector: detector15,
+  loader: loader15
+};
+var classDetector_V2_default = plugin13;
+var id16 = "state";
+var detector16 = /* @__PURE__ */ __name((txt, config) => {
+  var _a2;
+  if (((_a2 = config == null ? void 0 : config.state) == null ? void 0 : _a2.defaultRenderer) === "dagre-wrapper") {
+    return false;
+  }
+  return /^\s*stateDiagram/.test(txt);
+}, "detector");
+var loader16 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/stateDiagram-2N3HPSRC.mjs");
+  return { id: id16, diagram: diagram2 };
+}, "loader");
+var plugin14 = {
+  id: id16,
+  detector: detector16,
+  loader: loader16
+};
+var stateDetector_default = plugin14;
+var id17 = "stateDiagram";
+var detector17 = /* @__PURE__ */ __name((txt, config) => {
+  var _a2;
+  if (/^\s*stateDiagram-v2/.test(txt)) {
+    return true;
+  }
+  if (/^\s*stateDiagram/.test(txt) && ((_a2 = config == null ? void 0 : config.state) == null ? void 0 : _a2.defaultRenderer) === "dagre-wrapper") {
+    return true;
+  }
+  return false;
+}, "detector");
+var loader17 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/stateDiagram-v2-6OUMAXLB.mjs");
+  return { id: id17, diagram: diagram2 };
+}, "loader");
+var plugin15 = {
+  id: id17,
+  detector: detector17,
+  loader: loader17
+};
+var stateDetector_V2_default = plugin15;
+var id18 = "journey";
+var detector18 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*journey/.test(txt);
+}, "detector");
+var loader18 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/journeyDiagram-5HDEW3XC.mjs");
+  return { id: id18, diagram: diagram2 };
+}, "loader");
+var plugin16 = {
+  id: id18,
+  detector: detector18,
+  loader: loader18
+};
+var journeyDetector_default = plugin16;
+var draw = /* @__PURE__ */ __name((_text, id39, version) => {
+  log.debug("rendering svg for syntax error\n");
+  const svg = selectSvgElement(id39);
+  const g = svg.append("g");
+  svg.attr("viewBox", "0 0 2412 512");
+  configureSvgSize(svg, 100, 512, true);
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m411.313,123.313c6.25-6.25 6.25-16.375 0-22.625s-16.375-6.25-22.625,0l-32,32-9.375,9.375-20.688-20.688c-12.484-12.5-32.766-12.5-45.25,0l-16,16c-1.261,1.261-2.304,2.648-3.31,4.051-21.739-8.561-45.324-13.426-70.065-13.426-105.867,0-192,86.133-192,192s86.133,192 192,192 192-86.133 192-192c0-24.741-4.864-48.327-13.426-70.065 1.402-1.007 2.79-2.049 4.051-3.31l16-16c12.5-12.492 12.5-32.758 0-45.25l-20.688-20.688 9.375-9.375 32.001-31.999zm-219.313,100.687c-52.938,0-96,43.063-96,96 0,8.836-7.164,16-16,16s-16-7.164-16-16c0-70.578 57.422-128 128-128 8.836,0 16,7.164 16,16s-7.164,16-16,16z"
+  );
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m459.02,148.98c-6.25-6.25-16.375-6.25-22.625,0s-6.25,16.375 0,22.625l16,16c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688 6.25-6.25 6.25-16.375 0-22.625l-16.001-16z"
+  );
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m340.395,75.605c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688 6.25-6.25 6.25-16.375 0-22.625l-16-16c-6.25-6.25-16.375-6.25-22.625,0s-6.25,16.375 0,22.625l15.999,16z"
+  );
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m400,64c8.844,0 16-7.164 16-16v-32c0-8.836-7.156-16-16-16-8.844,0-16,7.164-16,16v32c0,8.836 7.156,16 16,16z"
+  );
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m496,96.586h-32c-8.844,0-16,7.164-16,16 0,8.836 7.156,16 16,16h32c8.844,0 16-7.164 16-16 0-8.836-7.156-16-16-16z"
+  );
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m436.98,75.605c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688l32-32c6.25-6.25 6.25-16.375 0-22.625s-16.375-6.25-22.625,0l-32,32c-6.251,6.25-6.251,16.375-0.001,22.625z"
+  );
+  g.append("text").attr("class", "error-text").attr("x", 1440).attr("y", 250).attr("font-size", "150px").style("text-anchor", "middle").text("Syntax error in text");
+  g.append("text").attr("class", "error-text").attr("x", 1250).attr("y", 400).attr("font-size", "100px").style("text-anchor", "middle").text(`mermaid version ${version}`);
+}, "draw");
+var renderer = { draw };
+var errorRenderer_default = renderer;
+var diagram = {
+  db: {},
+  renderer,
+  parser: {
+    parse: /* @__PURE__ */ __name(() => {
+      return;
+    }, "parse")
+  }
+};
+var errorDiagram_default = diagram;
+var id19 = "flowchart-elk";
+var detector19 = /* @__PURE__ */ __name((txt, config = {}) => {
+  var _a2;
+  if (
+    // If diagram explicitly states flowchart-elk
+    /^\s*flowchart-elk/.test(txt) || // If a flowchart/graph diagram has their default renderer set to elk
+    /^\s*(flowchart|graph)/.test(txt) && ((_a2 = config == null ? void 0 : config.flowchart) == null ? void 0 : _a2.defaultRenderer) === "elk"
+  ) {
+    config.layout = "elk";
+    return true;
+  }
+  return false;
+}, "detector");
+var loader19 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/flowDiagram-23GEKE2U.mjs");
+  return { id: id19, diagram: diagram2 };
+}, "loader");
+var plugin17 = {
+  id: id19,
+  detector: detector19,
+  loader: loader19
+};
+var detector_default2 = plugin17;
+var id20 = "timeline";
+var detector20 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*timeline/.test(txt);
+}, "detector");
+var loader20 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/timeline-definition-FHXFAJF6.mjs");
+  return { id: id20, diagram: diagram2 };
+}, "loader");
+var plugin18 = {
+  id: id20,
+  detector: detector20,
+  loader: loader20
+};
+var detector_default3 = plugin18;
+var id21 = "mindmap";
+var detector21 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*mindmap/.test(txt);
+}, "detector");
+var loader21 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/mindmap-definition-LN4V7U3C.mjs");
+  return { id: id21, diagram: diagram2 };
+}, "loader");
+var plugin19 = {
+  id: id21,
+  detector: detector21,
+  loader: loader21
+};
+var detector_default4 = plugin19;
+var id22 = "kanban";
+var detector22 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*kanban/.test(txt);
+}, "detector");
+var loader22 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/kanban-definition-HUTT4EX6.mjs");
+  return { id: id22, diagram: diagram2 };
+}, "loader");
+var plugin20 = {
+  id: id22,
+  detector: detector22,
+  loader: loader22
+};
+var detector_default5 = plugin20;
+var id23 = "sankey";
+var detector23 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*sankey(-beta)?/.test(txt);
+}, "detector");
+var loader23 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/sankeyDiagram-HTMAVEWB.mjs");
+  return { id: id23, diagram: diagram2 };
+}, "loader");
+var plugin21 = {
+  id: id23,
+  detector: detector23,
+  loader: loader23
+};
+var sankeyDetector_default = plugin21;
+var id24 = "packet";
+var detector24 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*packet(-beta)?/.test(txt);
+}, "detector");
+var loader24 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/diagram-NH7WQ7WH.mjs");
+  return { id: id24, diagram: diagram2 };
+}, "loader");
+var packet = {
+  id: id24,
+  detector: detector24,
+  loader: loader24
+};
+var id25 = "radar";
+var detector25 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*radar-beta/.test(txt);
+}, "detector");
+var loader25 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/diagram-WEI45ONY.mjs");
+  return { id: id25, diagram: diagram2 };
+}, "loader");
+var radar = {
+  id: id25,
+  detector: detector25,
+  loader: loader25
+};
+var id26 = "block";
+var detector26 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*block(-beta)?/.test(txt);
+}, "detector");
+var loader26 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/blockDiagram-677ZJIJ3.mjs");
+  return { id: id26, diagram: diagram2 };
+}, "loader");
+var plugin22 = {
+  id: id26,
+  detector: detector26,
+  loader: loader26
+};
+var blockDetector_default = plugin22;
+var id27 = "treeView";
+var detector27 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*treeView-beta/.test(txt);
+}, "detector");
+var loader27 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/diagram-OA4YK3LP.mjs");
+  return { id: id27, diagram: diagram2 };
+}, "loader");
+var plugin23 = {
+  id: id27,
+  detector: detector27,
+  loader: loader27
+};
+var detector_default6 = plugin23;
+var id28 = "architecture";
+var detector28 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*architecture/.test(txt);
+}, "detector");
+var loader28 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/architectureDiagram-ZJ3FMSHR.mjs");
+  return { id: id28, diagram: diagram2 };
+}, "loader");
+var architecture = {
+  id: id28,
+  detector: detector28,
+  loader: loader28
+};
+var architectureDetector_default = architecture;
+var id29 = "eventmodeling";
+var detector29 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*eventmodeling/.test(txt);
+}, "detector");
+var loader29 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/diagram-FQU43EPY.mjs");
+  return { id: id29, diagram: diagram2 };
+}, "loader");
+var plugin24 = {
+  id: id29,
+  detector: detector29,
+  loader: loader29
+};
+var detector_default7 = plugin24;
+var id30 = "ishikawa";
+var detector30 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*ishikawa(-beta)?\b/i.test(txt);
+}, "detector");
+var loader30 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/ishikawaDiagram-FXEZZL3T.mjs");
+  return { id: id30, diagram: diagram2 };
+}, "loader");
+var ishikawa = {
+  id: id30,
+  detector: detector30,
+  loader: loader30
+};
+var id31 = "venn";
+var detector31 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*venn-beta/.test(txt);
+}, "detector");
+var loader31 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/vennDiagram-L72KCM5P.mjs");
+  return { id: id31, diagram: diagram2 };
+}, "loader");
+var plugin25 = {
+  id: id31,
+  detector: detector31,
+  loader: loader31
+};
+var vennDetector_default = plugin25;
+var id32 = "treemap";
+var detector32 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*treemap/.test(txt);
+}, "detector");
+var loader32 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/diagram-G47NLZAW.mjs");
+  return { id: id32, diagram: diagram2 };
+}, "loader");
+var treemap = {
+  id: id32,
+  detector: detector32,
+  loader: loader32
+};
+var id33 = "wardley";
+var detector33 = /* @__PURE__ */ __name((text) => {
+  return /^\s*wardley-beta/i.test(text);
+}, "detector");
+var loader33 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/wardleyDiagram-EHGQE667.mjs");
+  return { id: id33, diagram: diagram2 };
+}, "loader");
+var plugin26 = {
+  id: id33,
+  detector: detector33,
+  loader: loader33
+};
+var wardleyDetector_default = plugin26;
+var id34 = "cynefin";
+var detector34 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*cynefin-beta(?:[\s:]|$)/.test(txt);
+}, "detector");
+var loader34 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/cynefinDiagram-TSTJHNR4.mjs");
+  return { id: id34, diagram: diagram2 };
+}, "loader");
+var cynefin = {
+  id: id34,
+  detector: detector34,
+  loader: loader34
+};
+var id35 = "railroad";
+var detector35 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*railroad-beta/i.test(txt);
+}, "detector");
+var loader35 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/railroadDiagram-RFXS5EU6.mjs");
+  return { id: id35, diagram: diagram2 };
+}, "loader");
+var railroad = {
+  id: id35,
+  detector: detector35,
+  loader: loader35
+};
+var id36 = "railroadEbnf";
+var detector36 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*railroad-ebnf-beta/i.test(txt);
+}, "detector");
+var loader36 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/ebnfDiagram-CCIWWBDH.mjs");
+  return { id: id36, diagram: diagram2 };
+}, "loader");
+var railroadEbnf = {
+  id: id36,
+  detector: detector36,
+  loader: loader36
+};
+var id37 = "railroadAbnf";
+var detector37 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*railroad-abnf-beta/i.test(txt);
+}, "detector");
+var loader37 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/abnfDiagram-VRR7QNED.mjs");
+  return { id: id37, diagram: diagram2 };
+}, "loader");
+var railroadAbnf = {
+  id: id37,
+  detector: detector37,
+  loader: loader37
+};
+var id38 = "railroadPeg";
+var detector38 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*railroad-peg-beta/i.test(txt);
+}, "detector");
+var loader38 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./chunks/mermaid.core/pegDiagram-2B236MQR.mjs");
+  return { id: id38, diagram: diagram2 };
+}, "loader");
+var railroadPeg = {
+  id: id38,
+  detector: detector38,
+  loader: loader38
+};
+var hasLoadedDiagrams = false;
+var addDiagrams = /* @__PURE__ */ __name(() => {
+  if (hasLoadedDiagrams) {
+    return;
+  }
+  hasLoadedDiagrams = true;
+  registerDiagram("error", errorDiagram_default, (text) => {
+    return text.toLowerCase().trim() === "error";
+  });
+  registerDiagram(
+    "---",
+    // --- diagram type may appear if YAML front-matter is not parsed correctly
+    {
+      db: {
+        clear: /* @__PURE__ */ __name(() => {
+        }, "clear")
+      },
+      styles: {},
+      // should never be used
+      renderer: {
+        draw: /* @__PURE__ */ __name(() => {
+        }, "draw")
+      },
+      parser: {
+        parse: /* @__PURE__ */ __name(() => {
+          throw new Error(
+            "Diagrams beginning with --- are not valid. If you were trying to use a YAML front-matter, please ensure that you've correctly opened and closed the YAML front-matter with un-indented `---` blocks"
+          );
+        }, "parse")
+      },
+      init: /* @__PURE__ */ __name(() => null, "init")
+      // no op
+    },
+    (text) => {
+      return text.toLowerCase().trimStart().startsWith("---");
+    }
+  );
+  {
+    registerLazyLoadedDiagrams(detector_default2, detector_default4, architectureDetector_default);
+  }
+  registerLazyLoadedDiagrams(
+    c4Detector_default,
+    detector_default5,
+    classDetector_V2_default,
+    classDetector_default,
+    erDetector_default,
+    ganttDetector_default,
+    info,
+    pie,
+    requirementDetector_default,
+    sequenceDetector_default,
+    detector_default,
+    flowDetector_v2_default,
+    flowDetector_default,
+    detector_default3,
+    gitGraphDetector_default,
+    stateDetector_V2_default,
+    stateDetector_default,
+    journeyDetector_default,
+    quadrantDetector_default,
+    sankeyDetector_default,
+    packet,
+    xychartDetector_default,
+    blockDetector_default,
+    detector_default7,
+    detector_default6,
+    radar,
+    ishikawa,
+    treemap,
+    railroad,
+    railroadEbnf,
+    railroadAbnf,
+    railroadPeg,
+    vennDetector_default,
+    wardleyDetector_default,
+    cynefin
+  );
+}, "addDiagrams");
+var loadRegisteredDiagrams = /* @__PURE__ */ __name(async () => {
+  log.debug(`Loading registered diagrams`);
+  const results = await Promise.allSettled(
+    Object.entries(detectors).map(async ([key, { detector: detector39, loader: loader39 }]) => {
+      if (!loader39) {
+        return;
+      }
+      try {
+        getDiagram(key);
+      } catch {
+        try {
+          const { diagram: diagram2, id: id39 } = await loader39();
+          registerDiagram(id39, diagram2, detector39);
+        } catch (err) {
+          log.error(`Failed to load external diagram with key ${key}. Removing from detectors.`);
+          delete detectors[key];
+          throw err;
+        }
+      }
+    })
+  );
+  const failed = results.filter((result) => result.status === "rejected");
+  if (failed.length > 0) {
+    log.error(`Failed to load ${failed.length} external diagrams`);
+    for (const res of failed) {
+      log.error(res);
+    }
+    throw new Error(`Failed to load ${failed.length} external diagrams`);
+  }
+}, "loadRegisteredDiagrams");
+var SVG_ROLE = "graphics-document document";
+function setA11yDiagramInfo(svg, diagramType) {
+  svg.attr("role", SVG_ROLE);
+  if (diagramType !== "") {
+    svg.attr("aria-roledescription", diagramType);
+  }
+}
+__name(setA11yDiagramInfo, "setA11yDiagramInfo");
+function addSVGa11yTitleDescription(svg, a11yTitle, a11yDesc, baseId) {
+  if (svg.insert === void 0) {
+    return;
+  }
+  if (a11yDesc) {
+    const descId = `chart-desc-${baseId}`;
+    svg.attr("aria-describedby", descId);
+    svg.insert("desc", ":first-child").attr("id", descId).text(a11yDesc);
+  }
+  if (a11yTitle) {
+    const titleId = `chart-title-${baseId}`;
+    svg.attr("aria-labelledby", titleId);
+    svg.insert("title", ":first-child").attr("id", titleId).text(a11yTitle);
+  }
+}
+__name(addSVGa11yTitleDescription, "addSVGa11yTitleDescription");
+var Diagram = (_a = class {
+  constructor(type, text, db, parser, renderer2) {
+    this.type = type;
+    this.text = text;
+    this.db = db;
+    this.parser = parser;
+    this.renderer = renderer2;
+  }
+  static async fromText(text, metadata = {}) {
+    var _a2, _b;
+    const config = getConfig();
+    const type = detectType(text, config);
+    text = encodeEntities(text) + "\n";
+    try {
+      getDiagram(type);
+    } catch {
+      const loader39 = getDiagramLoader(type);
+      if (!loader39) {
+        throw new UnknownDiagramError(`Diagram ${type} not found.`);
+      }
+      const { id: id39, diagram: diagram2 } = await loader39();
+      registerDiagram(id39, diagram2);
+    }
+    const { db, parser, renderer: renderer2, init: init2 } = getDiagram(type);
+    if (parser.parser) {
+      parser.parser.yy = db;
+    }
+    (_a2 = db.clear) == null ? void 0 : _a2.call(db);
+    init2 == null ? void 0 : init2(config);
+    if (metadata.title) {
+      (_b = db.setDiagramTitle) == null ? void 0 : _b.call(db, metadata.title);
+    }
+    await parser.parse(text);
+    return new _a(type, text, db, parser, renderer2);
+  }
+  async render(id39, version) {
+    await this.renderer.draw(this.text, id39, version, this);
+  }
+  getParser() {
+    return this.parser;
+  }
+  getType() {
+    return this.type;
+  }
+}, __name(_a, "Diagram"), _a);
+var interactionFunctions = [];
+var attachFunctions = /* @__PURE__ */ __name(() => {
+  interactionFunctions.forEach((f) => {
+    f();
+  });
+  interactionFunctions = [];
+}, "attachFunctions");
+var cleanupComments = /* @__PURE__ */ __name((text) => {
+  return text.replace(/^\s*%%(?!{)[^\n]+\n?/gm, "").trimStart();
+}, "cleanupComments");
+function extractFrontMatter(text) {
+  const matches = text.match(frontMatterRegex);
+  if (!matches) {
+    return {
+      text,
+      metadata: {}
+    };
+  }
+  const indent = matches[1];
+  const yamlBody = indent ? matches[2].split("\n").map((line) => line.startsWith(indent) ? line.slice(indent.length) : line).join("\n") : matches[2];
+  let parsed = load(yamlBody, {
+    // To support config, we need JSON schema.
+    // https://www.yaml.org/spec/1.2/spec.html#id2803231
+    schema: JSON_SCHEMA
+  }) ?? {};
+  parsed = typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  const metadata = {};
+  if (parsed.displayMode) {
+    metadata.displayMode = parsed.displayMode.toString();
+  }
+  if (parsed.title) {
+    metadata.title = parsed.title.toString();
+  }
+  if (parsed.config) {
+    metadata.config = parsed.config;
+  }
+  return {
+    text: text.slice(matches[0].length),
+    metadata
+  };
+}
+__name(extractFrontMatter, "extractFrontMatter");
+var cleanupText = /* @__PURE__ */ __name((code) => {
+  return code.replace(/\r\n?/g, "\n").replace(
+    /<(\w+)([^>]*)>/g,
+    (match, tag, attributes) => "<" + tag + attributes.replace(/="([^"]*)"/g, "='$1'") + ">"
+  );
+}, "cleanupText");
+var processFrontmatter = /* @__PURE__ */ __name((code) => {
+  const { text, metadata } = extractFrontMatter(code);
+  const { displayMode, title, config = {} } = metadata;
+  if (displayMode) {
+    if (!config.gantt) {
+      config.gantt = {};
+    }
+    config.gantt.displayMode = displayMode;
+  }
+  return { title, config, text };
+}, "processFrontmatter");
+var processDirectives = /* @__PURE__ */ __name((code) => {
+  const initDirective = utils_default.detectInit(code) ?? {};
+  const wrapDirectives = utils_default.detectDirective(code, "wrap");
+  if (Array.isArray(wrapDirectives)) {
+    initDirective.wrap = wrapDirectives.some(({ type }) => type === "wrap");
+  } else if ((wrapDirectives == null ? void 0 : wrapDirectives.type) === "wrap") {
+    initDirective.wrap = true;
+  }
+  return {
+    text: removeDirectives(code),
+    directive: initDirective
+  };
+}, "processDirectives");
+function preprocessDiagram(code) {
+  const cleanedCode = cleanupText(code);
+  const frontMatterResult = processFrontmatter(cleanedCode);
+  const directiveResult = processDirectives(frontMatterResult.text);
+  const config = cleanAndMerge(frontMatterResult.config, directiveResult.directive);
+  code = cleanupComments(directiveResult.text);
+  return {
+    code,
+    title: frontMatterResult.title,
+    config
+  };
+}
+__name(preprocessDiagram, "preprocessDiagram");
+function toBase64(str) {
+  const utf8Bytes = new TextEncoder().encode(str);
+  const utf8Str = Array.from(utf8Bytes, (byte) => String.fromCodePoint(byte)).join("");
+  return btoa(utf8Str);
+}
+__name(toBase64, "toBase64");
+var MAX_TEXTLENGTH = 5e4;
+var MAX_TEXTLENGTH_EXCEEDED_MSG = "graph TB;a[Maximum text size in diagram exceeded];style a fill:#faa";
+var SECURITY_LVL_SANDBOX = "sandbox";
+var SECURITY_LVL_LOOSE = "loose";
+var XMLNS_SVG_STD = "http://www.w3.org/2000/svg";
+var XMLNS_XLINK_STD = "http://www.w3.org/1999/xlink";
+var XMLNS_XHTML_STD = "http://www.w3.org/1999/xhtml";
+var IFRAME_WIDTH = "100%";
+var IFRAME_HEIGHT = "100%";
+var IFRAME_STYLES = "border:0;margin:0;";
+var IFRAME_BODY_STYLE = "margin:0";
+var IFRAME_SANDBOX_OPTS = "allow-top-navigation-by-user-activation allow-popups";
+var IFRAME_NOT_SUPPORTED_MSG = 'The "iframe" tag is not supported by your browser.';
+var DOMPURIFY_TAGS = ["foreignobject"];
+var DOMPURIFY_ATTR = ["dominant-baseline"];
+function processAndSetConfigs(text) {
+  const processed = preprocessDiagram(text);
+  reset();
+  addDirective(processed.config ?? {});
+  return processed;
+}
+__name(processAndSetConfigs, "processAndSetConfigs");
+async function parse(text, parseOptions) {
+  addDiagrams();
+  try {
+    const { code, config } = processAndSetConfigs(text);
+    const diagram2 = await getDiagramFromText(code);
+    return { diagramType: diagram2.type, config };
+  } catch (error) {
+    if (parseOptions == null ? void 0 : parseOptions.suppressErrors) {
+      return false;
+    }
+    throw error;
+  }
+}
+__name(parse, "parse");
+var cssImportantStyles = /* @__PURE__ */ __name((cssClass, element, cssClasses = []) => {
+  const declarationBlock = sanitizeCss(`{ ${cssClasses.join(" !important; ")} !important; }`);
+  return `.${cssClass} ${element} ${declarationBlock}`;
+}, "cssImportantStyles");
+var createCssStyles = /* @__PURE__ */ __name((config, classDefs = /* @__PURE__ */ new Map()) => {
+  const cssStyles = new CSSStyleSheet();
+  if (config.fontFamily !== void 0) {
+    cssStyles.insertRule(
+      `:root { --mermaid-font-family: ${config.fontFamily}}`,
+      cssStyles.cssRules.length
+    );
+  }
+  if (config.altFontFamily !== void 0) {
+    cssStyles.insertRule(
+      `:root { --mermaid-alt-font-family: ${config.altFontFamily}}`,
+      cssStyles.cssRules.length
+    );
+  }
+  if (classDefs instanceof Map) {
+    const htmlLabels = getEffectiveHtmlLabels(config);
+    const cssHtmlElements = ["> *", "span"];
+    const cssShapeElements = ["rect", "polygon", "ellipse", "circle", "path"];
+    const cssElements = htmlLabels ? cssHtmlElements : cssShapeElements;
+    classDefs.forEach((styleClassDef) => {
+      if (!isEmpty(styleClassDef.styles)) {
+        cssElements.forEach((cssElement) => {
+          cssStyles.insertRule(
+            cssImportantStyles(styleClassDef.id, cssElement, styleClassDef.styles),
+            cssStyles.cssRules.length
+          );
+        });
+      }
+      if (!isEmpty(styleClassDef.textStyles)) {
+        cssStyles.insertRule(
+          cssImportantStyles(
+            styleClassDef.id,
+            "tspan",
+            ((styleClassDef == null ? void 0 : styleClassDef.textStyles) || []).map((s) => s.replace("color", "fill"))
+          ),
+          cssStyles.cssRules.length
+        );
+      }
+    });
+  }
+  let cssString = "";
+  if (config.themeCSS !== void 0) {
+    if (typeof cssStyles.replaceSync === "function") {
+      const themeCssStyleSheet = new CSSStyleSheet();
+      themeCssStyleSheet.replaceSync(config.themeCSS);
+      cssString = cssStyleSheetToString(themeCssStyleSheet) + "\n";
+    } else {
+      cssString += `${config.themeCSS}
+`;
+    }
+  }
+  return cssString + cssStyleSheetToString(cssStyles);
+}, "createCssStyles");
+var compileCSS = /* @__PURE__ */ __name((namespace, css) => {
+  return serialize(
+    compile(`${namespace}{${css}}`),
+    middleware([
+      /* @__PURE__ */ __name(function addNamespace(element, _index, _children, _callback) {
+        if (element.type === "rule" && Array.isArray(element.props)) {
+          if (element.parent && element.parent.type === KEYFRAMES) {
+            return;
+          }
+          element.props = element.props.map((prop) => {
+            if (!prop.startsWith(namespace)) {
+              return `${namespace} ${prop}`;
+            }
+            return prop;
+          });
+        } else if (element.type.startsWith("@")) {
+          const nestedAtRules = [
+            MEDIA,
+            SUPPORTS,
+            LAYER,
+            SCOPE,
+            "@container",
+            "@starting-style"
+          ];
+          const allowedAtRules = [
+            ...nestedAtRules,
+            KEYFRAMES
+            // needed for Mermaid's animation feature
+          ];
+          if (!allowedAtRules.includes(element.type)) {
+            log.warn(`Removing unsupported at-rule ${element.type} from CSS`);
+            element.type = COMMENT;
+          }
+        }
+      }, "addNamespace"),
+      stringify
+    ])
+  );
+}, "compileCSS");
+var createUserStyles = /* @__PURE__ */ __name((config, graphType, classDefs, svgId) => {
+  const userCSSstyles = createCssStyles(config, classDefs);
+  const allStyles = styles_default(
+    graphType,
+    userCSSstyles,
+    { ...config.themeVariables, theme: config.theme, look: config.look },
+    svgId
+  );
+  return compileCSS(svgId, allStyles);
+}, "createUserStyles");
+var cleanUpSvgCode = /* @__PURE__ */ __name((svgCode = "", inSandboxMode, useArrowMarkerUrls) => {
+  let cleanedUpSvg = svgCode;
+  if (!useArrowMarkerUrls && !inSandboxMode) {
+    cleanedUpSvg = cleanedUpSvg.replace(
+      /marker-end="url\([\d+./:=?A-Za-z-]*?#/g,
+      'marker-end="url(#'
+    );
+  }
+  cleanedUpSvg = decodeEntities(cleanedUpSvg);
+  cleanedUpSvg = cleanedUpSvg.replace(/<br>/g, "<br/>");
+  return cleanedUpSvg;
+}, "cleanUpSvgCode");
+var putIntoIFrame = /* @__PURE__ */ __name((svgCode = "", svgElement) => {
+  var _a2, _b;
+  const height = ((_b = (_a2 = svgElement == null ? void 0 : svgElement.viewBox) == null ? void 0 : _a2.baseVal) == null ? void 0 : _b.height) ? svgElement.viewBox.baseVal.height + "px" : IFRAME_HEIGHT;
+  const base64encodedSrc = toBase64(`<body style="${IFRAME_BODY_STYLE}">${svgCode}</body>`);
+  return `<iframe style="width:${IFRAME_WIDTH};height:${height};${IFRAME_STYLES}" src="data:text/html;charset=UTF-8;base64,${base64encodedSrc}" sandbox="${IFRAME_SANDBOX_OPTS}">
+  ${IFRAME_NOT_SUPPORTED_MSG}
+</iframe>`;
+}, "putIntoIFrame");
+var appendDivSvgG = /* @__PURE__ */ __name((parentRoot, id39, enclosingDivId, divStyle, svgXlink) => {
+  const enclosingDiv = parentRoot.append("div");
+  enclosingDiv.attr("id", enclosingDivId);
+  if (divStyle) {
+    enclosingDiv.attr("style", divStyle);
+  }
+  const svgNode = enclosingDiv.append("svg").attr("id", id39).attr("width", "100%").attr("xmlns", XMLNS_SVG_STD);
+  if (svgXlink) {
+    svgNode.attr("xmlns:xlink", svgXlink);
+  }
+  svgNode.append("g");
+  return parentRoot;
+}, "appendDivSvgG");
+function sandboxedIframe(parentNode, iFrameId) {
+  return parentNode.append("iframe").attr("id", iFrameId).attr("style", "width: 100%; height: 100%;").attr("sandbox", "");
+}
+__name(sandboxedIframe, "sandboxedIframe");
+var removeExistingElements = /* @__PURE__ */ __name((doc, id39, divId, iFrameId) => {
+  var _a2, _b, _c;
+  (_a2 = doc.getElementById(id39)) == null ? void 0 : _a2.remove();
+  (_b = doc.getElementById(divId)) == null ? void 0 : _b.remove();
+  (_c = doc.getElementById(iFrameId)) == null ? void 0 : _c.remove();
+}, "removeExistingElements");
+var render = /* @__PURE__ */ __name(async function(id39, text, svgContainingElement) {
+  var _a2, _b, _c, _d, _e, _f;
+  addDiagrams();
+  const processed = processAndSetConfigs(text);
+  text = processed.code;
+  const config = getConfig();
+  log.debug(config);
+  if (text.length > ((config == null ? void 0 : config.maxTextSize) ?? MAX_TEXTLENGTH)) {
+    text = MAX_TEXTLENGTH_EXCEEDED_MSG;
+  }
+  const idSelector = `#${id39}`;
+  const iFrameID = "i" + id39;
+  const iFrameID_selector = "#" + iFrameID;
+  const enclosingDivID = "d" + id39;
+  const enclosingDivID_selector = "#" + enclosingDivID;
+  const removeTempElements = /* @__PURE__ */ __name(() => {
+    const tmpElementSelector = isSandboxed ? iFrameID_selector : enclosingDivID_selector;
+    const node = select(tmpElementSelector).node();
+    if (node && "remove" in node) {
+      node.remove();
+    }
+  }, "removeTempElements");
+  let root = select(document.body);
+  const isSandboxed = config.securityLevel === SECURITY_LVL_SANDBOX;
+  const isLooseSecurityLevel = config.securityLevel === SECURITY_LVL_LOOSE;
+  const fontFamily = config.fontFamily;
+  if (svgContainingElement !== void 0) {
+    if (svgContainingElement) {
+      svgContainingElement.innerHTML = "";
+    }
+    if (isSandboxed) {
+      const iframe = sandboxedIframe(select(svgContainingElement), iFrameID);
+      root = select(iframe.nodes()[0].contentDocument.body);
+      root.node().style.margin = "0";
+    } else {
+      root = select(svgContainingElement);
+    }
+    appendDivSvgG(root, id39, enclosingDivID, `font-family: ${fontFamily}`, XMLNS_XLINK_STD);
+  } else {
+    removeExistingElements(document, id39, enclosingDivID, iFrameID);
+    if (isSandboxed) {
+      const iframe = sandboxedIframe(select(document.body), iFrameID);
+      root = select(iframe.nodes()[0].contentDocument.body);
+      root.node().style.margin = "0";
+    } else {
+      root = select("body");
+    }
+    appendDivSvgG(root, id39, enclosingDivID);
+  }
+  let diag;
+  let parseEncounteredException;
+  try {
+    diag = await Diagram.fromText(text, { title: processed.title });
+  } catch (error) {
+    if (config.suppressErrorRendering) {
+      removeTempElements();
+      throw error;
+    }
+    diag = await Diagram.fromText("error");
+    parseEncounteredException = error;
+  }
+  const element = root.select(enclosingDivID_selector).node();
+  const diagramType = diag.type;
+  const svg = element.firstChild;
+  const firstChild = svg.firstChild;
+  const diagramClassDefs = (_b = (_a2 = diag.renderer).getClasses) == null ? void 0 : _b.call(_a2, text, diag);
+  const rules = createUserStyles(config, diagramType, diagramClassDefs, idSelector);
+  const style1 = document.createElement("style");
+  style1.innerHTML = rules;
+  svg.insertBefore(style1, firstChild);
+  try {
+    await diag.renderer.draw(text, id39, "11.16.0", diag);
+  } catch (e) {
+    if (config.suppressErrorRendering) {
+      removeTempElements();
+    } else {
+      errorRenderer_default.draw(text, id39, "11.16.0");
+    }
+    throw e;
+  }
+  const svgNode = root.select(`${enclosingDivID_selector} svg`);
+  const a11yTitle = (_d = (_c = diag.db).getAccTitle) == null ? void 0 : _d.call(_c);
+  const a11yDescr = (_f = (_e = diag.db).getAccDescription) == null ? void 0 : _f.call(_e);
+  addA11yInfo(diagramType, svgNode, a11yTitle, a11yDescr);
+  root.select(`[id="${id39}"]`).selectAll("foreignobject > *").attr("xmlns", XMLNS_XHTML_STD);
+  let svgCode = root.select(enclosingDivID_selector).node().innerHTML;
+  log.debug("config.arrowMarkerAbsolute", config.arrowMarkerAbsolute);
+  svgCode = cleanUpSvgCode(svgCode, isSandboxed, evaluate(config.arrowMarkerAbsolute));
+  if (isSandboxed) {
+    const svgEl = root.select(enclosingDivID_selector + " svg").node();
+    svgCode = putIntoIFrame(svgCode, svgEl);
+  } else if (!isLooseSecurityLevel) {
+    svgCode = purify.sanitize(svgCode, {
+      ADD_TAGS: DOMPURIFY_TAGS,
+      ADD_ATTR: DOMPURIFY_ATTR,
+      HTML_INTEGRATION_POINTS: { foreignobject: true }
+    });
+  }
+  attachFunctions();
+  if (parseEncounteredException) {
+    throw parseEncounteredException;
+  }
+  removeTempElements();
+  return {
+    diagramType,
+    svg: svgCode,
+    bindFunctions: diag.db.bindFunctions
+  };
+}, "render");
+function initialize(userOptions = {}) {
+  var _a2;
+  const options = assignWithDepth_default({}, userOptions);
+  if ((options == null ? void 0 : options.fontFamily) && !((_a2 = options.themeVariables) == null ? void 0 : _a2.fontFamily)) {
+    if (!options.themeVariables) {
+      options.themeVariables = {};
+    }
+    options.themeVariables.fontFamily = options.fontFamily;
+  }
+  saveConfigFromInitialize(options);
+  if ((options == null ? void 0 : options.theme) && options.theme in themes_default) {
+    options.themeVariables = themes_default[options.theme].getThemeVariables(
+      options.themeVariables
+    );
+  } else if (options) {
+    options.themeVariables = themes_default.default.getThemeVariables(options.themeVariables);
+  }
+  const config = typeof options === "object" ? setSiteConfig(options) : getSiteConfig();
+  setLogLevel(config.logLevel);
+  addDiagrams();
+}
+__name(initialize, "initialize");
+var getDiagramFromText = /* @__PURE__ */ __name((text, metadata = {}) => {
+  const { code } = preprocessDiagram(text);
+  return Diagram.fromText(code, metadata);
+}, "getDiagramFromText");
+function addA11yInfo(diagramType, svgNode, a11yTitle, a11yDescr) {
+  setA11yDiagramInfo(svgNode, diagramType);
+  addSVGa11yTitleDescription(svgNode, a11yTitle, a11yDescr, svgNode.attr("id"));
+}
+__name(addA11yInfo, "addA11yInfo");
+var mermaidAPI = Object.freeze({
+  render,
+  parse,
+  getDiagramFromText,
+  initialize,
+  getConfig,
+  setConfig,
+  getSiteConfig,
+  updateSiteConfig,
+  reset: /* @__PURE__ */ __name(() => {
+    reset();
+  }, "reset"),
+  globalReset: /* @__PURE__ */ __name(() => {
+    reset(defaultConfig);
+  }, "globalReset"),
+  defaultConfig
+});
+setLogLevel(getConfig().logLevel);
+reset(getConfig());
+var handleError = /* @__PURE__ */ __name((error, errors, parseError) => {
+  log.warn(error);
+  if (isDetailedError(error)) {
+    if (parseError) {
+      parseError(error.str, error.hash);
+    }
+    errors.push({ ...error, message: error.str, error });
+  } else {
+    if (parseError) {
+      parseError(error);
+    }
+    if (error instanceof Error) {
+      errors.push({
+        str: error.message,
+        message: error.message,
+        hash: error.name,
+        error
+      });
+    }
+  }
+}, "handleError");
+var run = /* @__PURE__ */ __name(async function(options = {
+  querySelector: ".mermaid"
+}) {
+  try {
+    await runThrowsErrors(options);
+  } catch (e) {
+    if (isDetailedError(e)) {
+      log.error(e.str);
+    }
+    if (mermaid.parseError) {
+      mermaid.parseError(e);
+    }
+    if (!options.suppressErrors) {
+      log.error("Use the suppressErrors option to suppress these errors");
+      throw e;
+    }
+  }
+}, "run");
+var runThrowsErrors = /* @__PURE__ */ __name(async function({ postRenderCallback, querySelector, nodes } = {
+  querySelector: ".mermaid"
+}) {
+  const conf = mermaidAPI.getConfig();
+  log.debug(`${!postRenderCallback ? "No " : ""}Callback function found`);
+  let nodesToProcess;
+  if (nodes) {
+    nodesToProcess = nodes;
+  } else if (querySelector) {
+    nodesToProcess = document.querySelectorAll(querySelector);
+  } else {
+    throw new Error("Nodes and querySelector are both undefined");
+  }
+  log.debug(`Found ${nodesToProcess.length} diagrams`);
+  if ((conf == null ? void 0 : conf.startOnLoad) !== void 0) {
+    log.debug("Start On Load: " + (conf == null ? void 0 : conf.startOnLoad));
+    mermaidAPI.updateSiteConfig({ startOnLoad: conf == null ? void 0 : conf.startOnLoad });
+  }
+  const idGenerator = new utils_default.InitIDGenerator(conf.deterministicIds, conf.deterministicIDSeed);
+  let txt;
+  const errors = [];
+  for (const element of Array.from(nodesToProcess)) {
+    log.info("Rendering diagram: " + element.id);
+    if (element.getAttribute("data-processed")) {
+      continue;
+    }
+    element.setAttribute("data-processed", "true");
+    const id39 = `mermaid-${idGenerator.next()}`;
+    txt = element.innerHTML;
+    txt = dedent(utils_default.entityDecode(txt)).trim().replace(/<br\s*\/?>/gi, "<br/>");
+    const init2 = utils_default.detectInit(txt);
+    if (init2) {
+      log.debug("Detected early reinit: ", init2);
+    }
+    try {
+      const { svg, bindFunctions } = await render2(id39, txt, element);
+      element.innerHTML = svg;
+      if (postRenderCallback) {
+        await postRenderCallback(id39);
+      }
+      if (bindFunctions) {
+        bindFunctions(element);
+      }
+    } catch (error) {
+      handleError(error, errors, mermaid.parseError);
+    }
+  }
+  if (errors.length > 0) {
+    throw errors[0];
+  }
+}, "runThrowsErrors");
+var initialize2 = /* @__PURE__ */ __name(function(config) {
+  mermaidAPI.initialize(config);
+}, "initialize");
+var init = /* @__PURE__ */ __name(async function(config, nodes, callback) {
+  log.warn("mermaid.init is deprecated. Please use run instead.");
+  if (config) {
+    initialize2(config);
+  }
+  const runOptions = { postRenderCallback: callback, querySelector: ".mermaid" };
+  if (typeof nodes === "string") {
+    runOptions.querySelector = nodes;
+  } else if (nodes) {
+    if (nodes instanceof HTMLElement) {
+      runOptions.nodes = [nodes];
+    } else {
+      runOptions.nodes = nodes;
+    }
+  }
+  await run(runOptions);
+}, "init");
+var registerExternalDiagrams = /* @__PURE__ */ __name(async (diagrams, {
+  lazyLoad = true
+} = {}) => {
+  addDiagrams();
+  registerLazyLoadedDiagrams(...diagrams);
+  if (lazyLoad === false) {
+    await loadRegisteredDiagrams();
+  }
+}, "registerExternalDiagrams");
+var contentLoaded = /* @__PURE__ */ __name(function() {
+  if (mermaid.startOnLoad) {
+    const { startOnLoad } = mermaidAPI.getConfig();
+    if (startOnLoad) {
+      mermaid.run().catch((err) => log.error("Mermaid failed to initialize", err));
+    }
+  }
+}, "contentLoaded");
+if (typeof document !== "undefined") {
+  window.addEventListener("load", contentLoaded, false);
+}
+var setParseErrorHandler = /* @__PURE__ */ __name(function(parseErrorHandler) {
+  mermaid.parseError = parseErrorHandler;
+}, "setParseErrorHandler");
+var executionQueue = [];
+var executionQueueRunning = false;
+var executeQueue = /* @__PURE__ */ __name(async () => {
+  if (executionQueueRunning) {
+    return;
+  }
+  executionQueueRunning = true;
+  while (executionQueue.length > 0) {
+    const f = executionQueue.shift();
+    if (f) {
+      try {
+        await f();
+      } catch (e) {
+        log.error("Error executing queue", e);
+      }
+    }
+  }
+  executionQueueRunning = false;
+}, "executeQueue");
+var parse2 = /* @__PURE__ */ __name(async (text, parseOptions) => {
+  return new Promise((resolve, reject) => {
+    const performCall = /* @__PURE__ */ __name(() => new Promise((res, rej) => {
+      mermaidAPI.parse(text, parseOptions).then(
+        (r) => {
+          res(r);
+          resolve(r);
+        },
+        (e) => {
+          var _a2;
+          log.error("Error parsing", e);
+          (_a2 = mermaid.parseError) == null ? void 0 : _a2.call(mermaid, e);
+          rej(e);
+          reject(e);
+        }
+      );
+    }), "performCall");
+    executionQueue.push(performCall);
+    executeQueue().catch(reject);
+  });
+}, "parse");
+var render2 = /* @__PURE__ */ __name((id39, text, container) => {
+  return new Promise((resolve, reject) => {
+    const performCall = /* @__PURE__ */ __name(() => new Promise((res, rej) => {
+      mermaidAPI.render(id39, text, container).then(
+        (r) => {
+          res(r);
+          resolve(r);
+        },
+        (e) => {
+          var _a2;
+          log.error("Error parsing", e);
+          (_a2 = mermaid.parseError) == null ? void 0 : _a2.call(mermaid, e);
+          rej(e);
+          reject(e);
+        }
+      );
+    }), "performCall");
+    executionQueue.push(performCall);
+    executeQueue().catch(reject);
+  });
+}, "render");
+var getRegisteredDiagramsMetadata = /* @__PURE__ */ __name(() => {
+  return Object.keys(detectors).map((id39) => ({
+    id: id39
+  }));
+}, "getRegisteredDiagramsMetadata");
+var mermaid = {
+  startOnLoad: true,
+  mermaidAPI,
+  parse: parse2,
+  render: render2,
+  init,
+  run,
+  registerExternalDiagrams,
+  registerLayoutLoaders,
+  initialize: initialize2,
+  parseError: void 0,
+  contentLoaded,
+  setParseErrorHandler,
+  detectType,
+  registerIconPacks,
+  getRegisteredDiagramsMetadata
+};
+var mermaid_default = mermaid;
+/*! Check if previously processed */
+/*!
+ * Wait for document loaded before starting the execution
+ */
+export {
+  mermaid_default as default
+};