@draftably/mermaid 0.0.0-stage → 0.1.0

package/dist/cdn/mermaid-facade-BoLWBerE.mjs

@@ -0,0 +1,289 @@
+const E = "12.2.0";
+const l = (t) => {
+  if (!t || typeof t != "object" || Array.isArray(t))
+    throw new Error("Expected a Mermaid data object.");
+  return t;
+}, a = (t, s) => {
+  if (typeof t == "string") return t;
+  if (t == null && s !== void 0) return s;
+  throw new Error("Expected a Mermaid string.");
+}, m = (t) => {
+  if (t == null) return [];
+  if (!Array.isArray(t) || t.some((s) => typeof s != "string"))
+    throw new Error("Expected a Mermaid string array.");
+  return [...t];
+}, i = (t) => t == null ? void 0 : a(t), y = (t) => {
+  if (!Array.isArray(t)) throw new Error("Expected a Mermaid array.");
+  return t;
+}, x = (t) => {
+  if (!(t instanceof Map)) throw new Error("Expected a Mermaid Map.");
+  return [...t.values()];
+}, b = (t) => {
+  if (t != null) {
+    if (typeof t != "number" || !Number.isFinite(t))
+      throw new Error("Expected finite number.");
+    return t;
+  }
+};
+function w(t) {
+  return t.replace(/fl°°(\d+)¶ß/g, "&#$1;").replace(/fl°([A-Za-z]\w*)¶ß/g, "&$1;");
+}
+function P(t) {
+  return (s) => {
+    const g = t.createElement("template");
+    return g.innerHTML = w(s).replace(/<br\s*\/?>/gi, `
+`), g.content.textContent ?? "";
+  };
+}
+function R(t) {
+  if (new TextEncoder().encode(t).length > 1e5)
+    return [
+      {
+        code: "IMPORT_INPUT_LIMIT",
+        severity: "error",
+        message: "Mermaid input exceeds 100000 UTF-8 bytes."
+      }
+    ];
+  const s = t.replace(/^\uFEFF/, "").replace(/\r\n?/g, `
+`);
+  if (/^\s*---(?:\n|$)/.test(s) || /%%\s*\{/.test(s))
+    return [
+      {
+        code: "MERMAID_CONFIGURATION_UNSUPPORTED",
+        severity: "error",
+        message: "This importer does not apply Mermaid frontmatter or directives. Remove the configuration block and import the diagram text."
+      }
+    ];
+  if ([...s].some((o) => {
+    const d = o.charCodeAt(0);
+    return d < 32 && ![9, 10, 13].includes(d);
+  }))
+    return [
+      {
+        code: "IMPORT_CONTROL_CHARACTER",
+        severity: "error",
+        message: "Input contains unsupported control characters."
+      }
+    ];
+  const g = s.split(`
+`).find((o) => o.trim() && !o.trimStart().startsWith("%%")) ?? "";
+  if (!/^\s*(?:flowchart|graph|sequenceDiagram)\b/.test(g))
+    return [
+      {
+        code: "MERMAID_FAMILY_UNSUPPORTED",
+        severity: "error",
+        message: "This adapter supports Mermaid flowcharts and sequence diagrams only. Class, ER, state, chart and other families require separate semantic adapters."
+      }
+    ];
+  const f = [];
+  for (const [o, d] of s.split(`
+`).entries())
+    /(?:^|;)\s*click\s/.test(d) && f.push({
+      code: "MERMAID_INTERACTION_IGNORED",
+      severity: "warning",
+      message: "Mermaid click links and callbacks are data only; no interactions are installed.",
+      line: o + 1,
+      locationKind: "source"
+    });
+  return f;
+}
+function S(t, s) {
+  const g = new Map(
+    Object.entries(l(t.LINETYPE)).map(([n, r]) => [r, n])
+  ), f = new Map(
+    Object.entries(l(t.PLACEMENT)).map(([n, r]) => [r, n])
+  ), o = y(s("getBoxes")), d = s("getActors");
+  if (!(d instanceof Map)) throw new Error("Expected a Mermaid Map.");
+  const p = (n) => new Set(s(n) instanceof Map ? s(n).keys() : []);
+  return {
+    format: "mermaid",
+    family: "sequence",
+    parserVersion: E,
+    title: i(s("getDiagramTitle")) || void 0,
+    actors: m(s("getActorKeys")).map((n) => {
+      const r = l(d.get(n));
+      return {
+        id: n,
+        name: a(r.description, a(r.name, n)),
+        type: a(r.type, "participant"),
+        box: r.box ? o.indexOf(r.box) : void 0,
+        links: Object.keys(l(r.links ?? {}))
+      };
+    }),
+    boxes: o.map((n) => {
+      const r = l(n);
+      return { name: i(r.name), fill: i(r.fill) };
+    }),
+    events: y(s("getMessages")).map((n) => {
+      const r = l(n), u = f.get(r.placement);
+      return {
+        kind: g.get(r.type) ?? "UNKNOWN",
+        from: i(r.from),
+        to: i(r.to),
+        // `autonumber` stores its numbering object here.
+        text: typeof r.message == "string" ? r.message : "",
+        ...r.placement == null ? {} : {
+          placement: u === "LEFTOF" ? "left" : u === "RIGHTOF" ? "right" : "over"
+        },
+        central: !!r.centralConnection
+      };
+    }),
+    created: [...p("getCreatedActors")].map(String),
+    destroyed: [...p("getDestroyedActors")].map(String)
+  };
+}
+function D(t) {
+  let s = Promise.resolve();
+  return (g) => {
+    const f = s.then(async () => {
+      const o = R(g);
+      if (o.some((p) => p.severity === "error")) return { ok: !1, diagnostics: o };
+      let d = "load";
+      try {
+        const p = await t();
+        p.initialize({
+          startOnLoad: !1,
+          securityLevel: "strict",
+          htmlLabels: !1,
+          maxTextSize: 1e5,
+          maxEdges: 3e3,
+          suppressErrorRendering: !0
+        }), d = "parse";
+        const n = await p.mermaidAPI.getDiagramFromText(g.replace(/^\uFEFF/, ""));
+        if (!["flowchart", "flowchart-v2", "sequence"].includes(n.type))
+          return {
+            ok: !1,
+            diagnostics: [
+              ...o,
+              {
+                code: "MERMAID_FAMILY_UNSUPPORTED",
+                severity: "error",
+                message: `Parser selected unsupported diagram family ${n.type}.`
+              }
+            ]
+          };
+        d = "snapshot";
+        const r = l(n.db), u = (c) => {
+          if (typeof r[c] != "function")
+            throw new Error(`Mermaid ${E} boundary missing ${c}().`);
+          return r[c].call(r);
+        };
+        if (n.type === "sequence") {
+          const c = S(r, u);
+          return c.actors.length > 1e3 || c.events.length > 3e3 ? {
+            ok: !1,
+            diagnostics: [
+              ...o,
+              {
+                code: "IMPORT_GRAPH_LIMIT",
+                severity: "error",
+                message: "Parsed sequence exceeds the import entity or event limit."
+              }
+            ]
+          } : { ok: !0, diagnostics: o, snapshot: c };
+        }
+        const M = u("getEdges"), h = x(u("getVertices")).map((c) => {
+          const e = l(c);
+          return {
+            id: a(e.id),
+            text: a(e.text, a(e.id)),
+            type: i(e.type),
+            labelType: a(e.labelType, "text"),
+            classes: m(e.classes),
+            styles: m(e.styles),
+            link: i(e.link),
+            icon: i(e.icon),
+            img: i(e.img),
+            props: e.props == null ? void 0 : structuredClone(l(e.props))
+          };
+        }), T = y(M).map((c) => {
+          const e = l(c);
+          return {
+            start: a(e.start),
+            end: a(e.end),
+            text: a(e.text, ""),
+            type: i(e.type),
+            stroke: i(e.stroke),
+            id: i(e.id),
+            isUserDefinedId: e.isUserDefinedId === !0,
+            labelType: a(e.labelType, "text"),
+            classes: m(e.classes),
+            style: m(e.style),
+            length: b(e.length),
+            interpolate: i(e.interpolate),
+            animate: e.animate === !0,
+            animation: i(e.animation)
+          };
+        }), A = y(u("getSubGraphs")).map((c) => {
+          const e = l(c);
+          return {
+            id: a(e.id),
+            title: a(e.title, ""),
+            nodes: m(e.nodes),
+            dir: i(e.dir),
+            labelType: a(e.labelType, "text"),
+            classes: m(e.classes),
+            metadata: e.metadata == null ? void 0 : structuredClone(l(e.metadata))
+          };
+        }), _ = x(u("getClasses")).map((c) => {
+          const e = l(c);
+          return { id: a(e.id), styles: m(e.styles), textStyles: m(e.textStyles) };
+        });
+        if (h.length + A.length > 1e3 || T.length > 3e3)
+          return {
+            ok: !1,
+            diagnostics: [
+              ...o,
+              {
+                code: "IMPORT_GRAPH_LIMIT",
+                severity: "error",
+                message: "Parsed graph exceeds the import entity or edge limit."
+              }
+            ]
+          };
+        const I = M;
+        return {
+          ok: !0,
+          diagnostics: o,
+          snapshot: {
+            format: "mermaid",
+            family: "flowchart",
+            parserVersion: E,
+            direction: a(u("getDirection"), "TB"),
+            vertices: h,
+            edges: T,
+            groups: A,
+            classes: _,
+            defaultEdgeStyle: m(I.defaultStyle),
+            defaultEdgeInterpolate: i(I.defaultInterpolate)
+          }
+        };
+      } catch (p) {
+        const n = p, r = n.hash?.loc;
+        return {
+          ok: !1,
+          diagnostics: [
+            ...o,
+            {
+              code: d === "parse" ? "MERMAID_PARSE_ERROR" : "MERMAID_ADAPTER_MISMATCH",
+              severity: "error",
+              message: n.message ?? String(p),
+              line: r?.first_line,
+              column: r?.first_column == null ? void 0 : r.first_column + 1,
+              locationKind: r ? "parser-relative" : void 0
+            }
+          ]
+        };
+      }
+    });
+    return s = f.catch(() => {
+    }), f;
+  };
+}
+export {
+  E as MERMAID_VERSION,
+  D as createMermaidFlowParser,
+  P as makePlainLabel,
+  R as preflightMermaidFlow,
+  w as restoreEntitySpelling
+};