@layers-app/editor 2.2.45 → 2.3.2

package/dist/layers.BCIkvjT3.js

@@ -0,0 +1,1157 @@
+import { J as N } from "./layers.h_l-O4Ya.js";
+import { m as U } from "./layers.B1zVsm3v.js";
+import "./layers.Bg7BQcmt.js";
+import "lodash-es/memoize.js";
+import "lodash-es/merge.js";
+import "lodash-es/isEmpty.js";
+const G = 20, ct = {
+  rect: "rectangle",
+  circle: "ellipse"
+}, Z = {
+  startOnLoad: !1,
+  flowchart: { curve: "linear" },
+  themeVariables: {
+    // Multiplying by 1.25 to increase the font size by 25% and render correctly in Excalidraw
+    fontSize: `${G * 1.25}px`
+  },
+  maxEdges: 500,
+  maxTextSize: 5e4
+};
+class F {
+  constructor({ converter: e }) {
+    this.convert = (s, r) => this.converter(s, {
+      ...r,
+      fontSize: r.fontSize || G
+    }), this.converter = e;
+  }
+}
+var v;
+(function(t) {
+  t.ROUND = "round", t.STADIUM = "stadium", t.DOUBLECIRCLE = "doublecircle", t.CIRCLE = "circle", t.DIAMOND = "diamond";
+})(v || (v = {}));
+var W;
+(function(t) {
+  t.COLOR = "color";
+})(W || (W = {}));
+var X;
+(function(t) {
+  t.FILL = "fill", t.STROKE = "stroke", t.STROKE_WIDTH = "stroke-width", t.STROKE_DASHARRAY = "stroke-dasharray";
+})(X || (X = {}));
+var $ = {}, J;
+function it() {
+  if (J) return $;
+  J = 1, Object.defineProperty($, "__esModule", { value: !0 }), $.removeMarkdown = void 0;
+  var t = function(e, s) {
+    s === void 0 && (s = {
+      listUnicodeChar: ""
+    }), s = s || {}, s.listUnicodeChar = s.hasOwnProperty("listUnicodeChar") ? s.listUnicodeChar : !1, s.stripListLeaders = s.hasOwnProperty("stripListLeaders") ? s.stripListLeaders : !0, s.gfm = s.hasOwnProperty("gfm") ? s.gfm : !0, s.useImgAltText = s.hasOwnProperty("useImgAltText") ? s.useImgAltText : !0, s.preserveLinks = s.hasOwnProperty("preserveLinks") ? s.preserveLinks : !1;
+    var r = e || "";
+    r = r.replace(/^(-\s*?|\*\s*?|_\s*?){3,}\s*$/gm, "");
+    try {
+      s.stripListLeaders && (s.listUnicodeChar ? r = r.replace(/^([\s\t]*)([\*\-\+]|\d+\.)\s+/gm, s.listUnicodeChar + " $1") : r = r.replace(/^([\s\t]*)([\*\-\+]|\d+\.)\s+/gm, "$1")), s.gfm && (r = r.replace(/\n={2,}/g, `
+`).replace(/~{3}.*\n/g, "").replace(/~~/g, "").replace(/`{3}.*\n/g, "")), s.preserveLinks && (r = r.replace(/\[(.*?)\][\[\(](.*?)[\]\)]/g, "$1 ($2)")), r = r.replace(/<[^>]*>/g, "").replace(/^[=\-]{2,}\s*$/g, "").replace(/\[\^.+?\](\: .*?$)?/g, "").replace(/\s{0,2}\[.*?\]: .*?$/g, "").replace(/\!\[(.*?)\][\[\(].*?[\]\)]/g, s.useImgAltText ? "$1" : "").replace(/\[(.*?)\][\[\(].*?[\]\)]/g, "$1").replace(/^\s{0,3}>\s?/g, "").replace(/(^|\n)\s{0,3}>\s?/g, `
+
+`).replace(/^\s{1,2}\[(.*?)\]: (\S+)( ".*?")?\s*$/g, "").replace(/^(\n)?\s{0,}#{1,6}\s+| {0,}(\n)?\s{0,}#{0,} {0,}(\n)?\s{0,}$/gm, "$1$2$3").replace(/([\*_]{1,3})(\S.*?\S{0,1})\1/g, "$2").replace(/([\*_]{1,3})(\S.*?\S{0,1})\1/g, "$2").replace(/(`{3,})(.*?)\1/gm, "$2").replace(/`(.+?)`/g, "$1").replace(/\n{2,}/g, `
+
+`);
+    } catch (o) {
+      return console.error(o), e;
+    }
+    return r;
+  };
+  return $.removeMarkdown = t, $;
+}
+var dt = it();
+const lt = {
+  arrow_circle: {
+    endArrowhead: "dot"
+  },
+  arrow_cross: {
+    endArrowhead: "bar"
+  },
+  arrow_open: {
+    endArrowhead: null,
+    startArrowhead: null
+  },
+  double_arrow_circle: {
+    endArrowhead: "dot",
+    startArrowhead: "dot"
+  },
+  double_arrow_cross: {
+    endArrowhead: "bar",
+    startArrowhead: "bar"
+  },
+  double_arrow_point: {
+    endArrowhead: "arrow",
+    startArrowhead: "arrow"
+  }
+}, ut = (t) => lt[t], B = (t) => {
+  let e = t.text;
+  return t.labelType === "markdown" && (e = dt.removeMarkdown(t.text)), ht(e);
+}, ht = (t) => {
+  const e = /\s?(fa|fab):[a-zA-Z0-9-]+/g;
+  return t.replace(e, "");
+}, ft = (t) => {
+  const e = {};
+  return Object.keys(t).forEach((s) => {
+    var r;
+    switch (s) {
+      case X.FILL: {
+        e.backgroundColor = t[s], e.fillStyle = "solid";
+        break;
+      }
+      case X.STROKE: {
+        e.strokeColor = t[s];
+        break;
+      }
+      case X.STROKE_WIDTH: {
+        e.strokeWidth = Number((r = t[s]) == null ? void 0 : r.split("px")[0]);
+        break;
+      }
+      case X.STROKE_DASHARRAY: {
+        e.strokeStyle = "dashed";
+        break;
+      }
+    }
+  }), e;
+}, gt = (t) => {
+  const e = {};
+  return Object.keys(t).forEach((s) => {
+    switch (s) {
+      case W.COLOR: {
+        e.strokeColor = t[s];
+        break;
+      }
+    }
+  }), e;
+}, bt = (t) => {
+  const e = {};
+  t.subGraphs.map((r) => {
+    r.nodeIds.forEach((o) => {
+      e[r.id] = {
+        id: r.id,
+        parent: null,
+        isLeaf: !1
+      }, e[o] = {
+        id: o,
+        parent: r.id,
+        isLeaf: t.vertices[o] !== void 0
+      };
+    });
+  });
+  const s = {};
+  return [...Object.keys(t.vertices), ...t.subGraphs.map((r) => r.id)].forEach((r) => {
+    if (!e[r])
+      return;
+    let o = e[r];
+    const a = [];
+    for (o.isLeaf || a.push(`subgraph_group_${o.id}`); o.parent; )
+      a.push(`subgraph_group_${o.parent}`), o = e[o.parent];
+    s[r] = a;
+  }), {
+    getGroupIds: (r) => s[r] || [],
+    getParentId: (r) => e[r] ? e[r].parent : null
+  };
+}, pt = new F({
+  converter: (t, e) => {
+    const s = [], r = e.fontSize, { getGroupIds: o, getParentId: a } = bt(t);
+    return t.subGraphs.reverse().forEach((n) => {
+      const c = o(n.id), i = {
+        id: n.id,
+        type: "rectangle",
+        groupIds: c,
+        x: n.x,
+        y: n.y,
+        width: n.width,
+        height: n.height,
+        label: {
+          groupIds: c,
+          text: B(n),
+          fontSize: r,
+          verticalAlign: "top"
+        }
+      };
+      s.push(i);
+    }), Object.values(t.vertices).forEach((n) => {
+      if (!n)
+        return;
+      const c = o(n.id), i = ft(n.containerStyle), d = gt(n.labelStyle);
+      let l = {
+        id: n.id,
+        type: "rectangle",
+        groupIds: c,
+        x: n.x,
+        y: n.y,
+        width: n.width,
+        height: n.height,
+        strokeWidth: 2,
+        label: {
+          groupIds: c,
+          text: B(n),
+          fontSize: r,
+          ...d
+        },
+        link: n.link || null,
+        ...i
+      };
+      switch (n.type) {
+        case v.STADIUM: {
+          l = { ...l, roundness: { type: 3 } };
+          break;
+        }
+        case v.ROUND: {
+          l = { ...l, roundness: { type: 3 } };
+          break;
+        }
+        case v.DOUBLECIRCLE: {
+          c.push(`doublecircle_${n.id}}`);
+          const u = {
+            type: "ellipse",
+            groupIds: c,
+            x: n.x + 5,
+            y: n.y + 5,
+            width: n.width - 10,
+            height: n.height - 10,
+            strokeWidth: 2,
+            roundness: { type: 3 },
+            label: {
+              groupIds: c,
+              text: B(n),
+              fontSize: r
+            }
+          };
+          l = { ...l, groupIds: c, type: "ellipse" }, s.push(u);
+          break;
+        }
+        case v.CIRCLE: {
+          l.type = "ellipse";
+          break;
+        }
+        case v.DIAMOND: {
+          l.type = "diamond";
+          break;
+        }
+      }
+      s.push(l);
+    }), t.edges.forEach((n) => {
+      let c = [];
+      const i = a(n.start), d = a(n.end);
+      i && i === d && (c = o(i));
+      const { startX: l, startY: b, reflectionPoints: u } = n, p = u.map((x) => [
+        x.x - u[0].x,
+        x.y - u[0].y
+      ]), g = ut(n.type), y = {
+        id: `${n.start}_${n.end}`,
+        type: "arrow",
+        groupIds: c,
+        x: l,
+        y: b,
+        // 4 and 2 are the Excalidraw's stroke width of thick and thin respectively
+        // TODO: use constant exported from Excalidraw package
+        strokeWidth: n.stroke === "thick" ? 4 : 2,
+        strokeStyle: n.stroke === "dotted" ? "dashed" : void 0,
+        points: p,
+        ...n.text ? { label: { text: B(n), fontSize: r, groupIds: c } } : {},
+        roundness: {
+          type: 2
+        },
+        ...g
+      }, S = s.find((x) => x.id === n.start), E = s.find((x) => x.id === n.end);
+      !S || !E || (y.start = {
+        id: S.id || ""
+      }, y.end = {
+        id: E.id || ""
+      }, s.push(y));
+    }), {
+      elements: s
+    };
+  }
+}), mt = new F({
+  converter: (t) => {
+    const e = N(), { width: s, height: r } = t, o = {
+      type: "image",
+      x: 0,
+      y: 0,
+      width: s,
+      height: r,
+      status: "saved",
+      fileId: e
+    };
+    return { files: {
+      [e]: {
+        id: e,
+        mimeType: t.mimeType,
+        dataURL: t.dataURL
+      }
+    }, elements: [o] };
+  }
+}), V = (t) => t.replace(/\\n/g, `
+`), M = (t) => {
+  const e = {
+    type: "line",
+    x: t.startX,
+    y: t.startY,
+    points: [
+      [0, 0],
+      [t.endX - t.startX, t.endY - t.startY]
+    ],
+    width: t.endX - t.startX,
+    height: t.endY - t.startY,
+    strokeStyle: t.strokeStyle || "solid",
+    strokeColor: t.strokeColor || "#000",
+    strokeWidth: t.strokeWidth || 1
+  };
+  return t.groupId && Object.assign(e, { groupIds: [t.groupId] }), t.id && Object.assign(e, { id: t.id }), e;
+}, z = (t) => {
+  const e = {
+    type: "text",
+    x: t.x,
+    y: t.y,
+    width: t.width,
+    height: t.height,
+    text: V(t.text) || "",
+    fontSize: t.fontSize,
+    verticalAlign: "middle"
+  };
+  return t.groupId && Object.assign(e, { groupIds: [t.groupId] }), t.id && Object.assign(e, { id: t.id }), e;
+}, P = (t) => {
+  var r, o, a, n;
+  let e = {};
+  t.type === "rectangle" && t.subtype === "activation" && (e = {
+    backgroundColor: "#e9ecef",
+    fillStyle: "solid"
+  });
+  const s = {
+    id: t.id,
+    type: t.type,
+    x: t.x,
+    y: t.y,
+    width: t.width,
+    height: t.height,
+    label: {
+      text: V(((r = t == null ? void 0 : t.label) == null ? void 0 : r.text) || ""),
+      fontSize: (o = t == null ? void 0 : t.label) == null ? void 0 : o.fontSize,
+      verticalAlign: ((a = t.label) == null ? void 0 : a.verticalAlign) || "middle",
+      strokeColor: ((n = t.label) == null ? void 0 : n.color) || "#000",
+      groupIds: t.groupId ? [t.groupId] : []
+    },
+    strokeStyle: t == null ? void 0 : t.strokeStyle,
+    strokeWidth: t == null ? void 0 : t.strokeWidth,
+    strokeColor: t == null ? void 0 : t.strokeColor,
+    backgroundColor: t == null ? void 0 : t.bgColor,
+    fillStyle: "solid",
+    ...e
+  };
+  return t.groupId && Object.assign(s, { groupIds: [t.groupId] }), s;
+}, st = (t) => {
+  var s;
+  const e = {
+    type: "arrow",
+    x: t.startX,
+    y: t.startY,
+    points: t.points || [
+      [0, 0],
+      [t.endX - t.startX, t.endY - t.startY]
+    ],
+    width: t.endX - t.startX,
+    height: t.endY - t.startY,
+    strokeStyle: (t == null ? void 0 : t.strokeStyle) || "solid",
+    endArrowhead: (t == null ? void 0 : t.endArrowhead) || null,
+    startArrowhead: (t == null ? void 0 : t.startArrowhead) || null,
+    label: {
+      text: V(((s = t == null ? void 0 : t.label) == null ? void 0 : s.text) || ""),
+      fontSize: 16
+    },
+    roundness: {
+      type: 2
+    },
+    start: t.start,
+    end: t.end
+  };
+  return t.groupId && Object.assign(e, { groupIds: [t.groupId] }), e;
+}, yt = new F({
+  converter: (t) => {
+    const e = [], s = [];
+    if (Object.values(t.nodes).forEach((r) => {
+      !r || !r.length || r.forEach((o) => {
+        let a;
+        switch (o.type) {
+          case "line":
+            a = M(o);
+            break;
+          case "rectangle":
+          case "ellipse":
+            a = P(o);
+            break;
+          case "text":
+            a = z(o);
+            break;
+          default:
+            throw `unknown type ${o.type}`;
+        }
+        o.type === "rectangle" && (o == null ? void 0 : o.subtype) === "activation" ? s.push(a) : e.push(a);
+      });
+    }), Object.values(t.lines).forEach((r) => {
+      r && e.push(M(r));
+    }), Object.values(t.arrows).forEach((r) => {
+      r && (e.push(st(r)), r.sequenceNumber && e.push(P(r.sequenceNumber)));
+    }), e.push(...s), t.loops) {
+      const { lines: r, texts: o, nodes: a } = t.loops;
+      r.forEach((n) => {
+        e.push(M(n));
+      }), o.forEach((n) => {
+        e.push(z(n));
+      }), a.forEach((n) => {
+        e.push(P(n));
+      });
+    }
+    return t.groups && t.groups.forEach((r) => {
+      const { actorKeys: o, name: a } = r;
+      let n = 1 / 0, c = 1 / 0, i = 0, d = 0;
+      if (!o.length)
+        return;
+      e.filter((f) => {
+        if (f.id) {
+          const C = f.id.indexOf("-"), I = f.id.substring(0, C);
+          return o.includes(I);
+        }
+      }).forEach((f) => {
+        if (f.x === void 0 || f.y === void 0 || f.width === void 0 || f.height === void 0)
+          throw new Error(`Actor attributes missing ${f}`);
+        n = Math.min(n, f.x), c = Math.min(c, f.y), i = Math.max(i, f.x + f.width), d = Math.max(d, f.y + f.height);
+      });
+      const b = 10, u = n - b, p = c - b, g = i - n + b * 2, m = d - c + b * 2, y = N(), S = P({
+        type: "rectangle",
+        x: u,
+        y: p,
+        width: g,
+        height: m,
+        bgColor: r.fill,
+        id: y
+      });
+      e.unshift(S);
+      const E = N(), x = [y];
+      e.forEach((f) => {
+        if (f.type !== "frame") {
+          if (f.x === void 0 || f.y === void 0 || f.width === void 0 || f.height === void 0)
+            throw new Error(`Element attributes missing ${f}`);
+          if (f.x >= n && f.x + f.width <= i && f.y >= c && f.y + f.height <= d) {
+            const C = f.id || N();
+            f.id || Object.assign(f, { id: C }), x.push(C);
+          }
+        }
+      });
+      const h = {
+        type: "frame",
+        id: E,
+        name: a,
+        children: x
+      };
+      e.push(h);
+    }), { elements: e };
+  }
+}), xt = new F({
+  converter: (t) => {
+    const e = [];
+    return Object.values(t.nodes).forEach((s) => {
+      !s || !s.length || s.forEach((r) => {
+        let o;
+        switch (r.type) {
+          case "line":
+            o = M(r);
+            break;
+          case "rectangle":
+          case "ellipse":
+            o = P(r);
+            break;
+          case "text":
+            o = z(r);
+            break;
+          default:
+            throw `unknown type ${r.type}`;
+        }
+        e.push(o);
+      });
+    }), Object.values(t.lines).forEach((s) => {
+      s && e.push(M(s));
+    }), Object.values(t.arrows).forEach((s) => {
+      if (!s)
+        return;
+      const r = st(s);
+      e.push(r);
+    }), Object.values(t.text).forEach((s) => {
+      const r = z(s);
+      e.push(r);
+    }), Object.values(t.namespaces).forEach((s) => {
+      const r = Object.keys(s.classes), o = [...r], a = [...t.lines, ...t.arrows, ...t.text];
+      r.forEach((c) => {
+        const i = a.filter((d) => d.metadata && d.metadata.classId === c).map((d) => d.id);
+        i.length && o.push(...i);
+      });
+      const n = {
+        type: "frame",
+        id: N(),
+        name: s.id,
+        children: o
+      };
+      e.push(n);
+    }), { elements: e };
+  }
+}), Et = (t, e = {}) => {
+  switch (t.type) {
+    case "graphImage":
+      return mt.convert(t, e);
+    case "flowchart":
+      return pt.convert(t, e);
+    case "sequence":
+      return yt.convert(t, e);
+    case "class":
+      return xt.convert(t, e);
+    default:
+      throw new Error(`graphToExcalidraw: unknown graph type "${t.type}, only flowcharts are supported!"`);
+  }
+}, R = (t) => {
+  t = wt(t);
+  const e = t.replace(/#(\d+);/g, "&#$1;").replace(/#([a-z]+);/g, "&$1;"), s = document.createElement("textarea");
+  return s.innerHTML = e, s.value;
+}, _ = (t) => {
+  const e = t.getAttribute("transform"), s = e == null ? void 0 : e.match(/translate\(([ \d.-]+),\s*([\d.-]+)\)/);
+  let r = 0, o = 0;
+  return s && (r = Number(s[1]), o = Number(s[2])), { transformX: r, transformY: o };
+}, St = (t) => {
+  let e = t;
+  return e = e.replace(/style.*:\S*#.*;/g, (s) => s.substring(0, s.length - 1)), e = e.replace(/classDef.*:\S*#.*;/g, (s) => s.substring(0, s.length - 1)), e = e.replace(/#\w+;/g, (s) => {
+    const r = s.substring(1, s.length - 1);
+    return /^\+?\d+$/.test(r) ? `fl°°${r}¶ß` : `fl°${r}¶ß`;
+  }), e;
+}, wt = function(t) {
+  return t.replace(/fl°°/g, "#").replace(/fl°/g, "&").replace(/¶ß/g, ";");
+}, nt = (t, e = { x: 0, y: 0 }) => {
+  if (t.tagName.toLowerCase() !== "path")
+    throw new Error(`Invalid input: Expected an HTMLElement of tag "path", got ${t.tagName}`);
+  const s = t.getAttribute("d");
+  if (!s)
+    throw new Error('Path element does not contain a "d" attribute');
+  const r = s.split(/(?=[LM])/), o = r[0].substring(1).split(",").map((c) => parseFloat(c)), a = r[r.length - 1].substring(1).split(",").map((c) => parseFloat(c)), n = r.map((c) => {
+    const i = c.substring(1).split(",").map((d) => parseFloat(d));
+    return { x: i[0], y: i[1] };
+  }).filter((c, i, d) => {
+    if (i === 0 || i === d.length - 1)
+      return !0;
+    if (c.x === d[i - 1].x && c.y === d[i - 1].y)
+      return !1;
+    if (i === d.length - 2 && (d[i - 1].x === c.x || d[i - 1].y === c.y)) {
+      const l = d[d.length - 1];
+      return Math.hypot(l.x - c.x, l.y - c.y) > 20;
+    }
+    return c.x !== d[i - 1].x || c.y !== d[i - 1].y;
+  }).map((c) => ({
+    x: c.x + e.x,
+    y: c.y + e.y
+  }));
+  return {
+    startX: o[0] + e.x,
+    startY: o[1] + e.y,
+    endX: a[0] + e.x,
+    endY: a[1] + e.y,
+    reflectionPoints: n
+  };
+}, At = (t, e) => {
+  const s = t.nodes.map((c) => c.startsWith("flowchart-") ? c.split("-")[1] : c), r = e.querySelector(`[id='${t.id}']`);
+  if (!r)
+    throw new Error("SubGraph element not found");
+  const o = K(r, e), a = r.getBBox(), n = {
+    width: a.width,
+    height: a.height
+  };
+  return t.classes = void 0, t.dir = void 0, {
+    ...t,
+    nodeIds: s,
+    ...o,
+    ...n,
+    text: R(t.title)
+  };
+}, It = (t, e) => {
+  var b, u, p;
+  const s = e.querySelector(`[id*="flowchart-${t.id}-"]`);
+  if (!s)
+    return;
+  let r;
+  ((b = s.parentElement) == null ? void 0 : b.tagName.toLowerCase()) === "a" && (r = s.parentElement.getAttribute("xlink:href"));
+  const o = K(r ? s.parentElement : s, e), a = s.getBBox(), n = {
+    width: a.width,
+    height: a.height
+  }, c = (u = s.querySelector(".label-container")) == null ? void 0 : u.getAttribute("style"), i = (p = s.querySelector(".label")) == null ? void 0 : p.getAttribute("style"), d = {};
+  c == null || c.split(";").forEach((g) => {
+    if (!g)
+      return;
+    const m = g.split(":")[0].trim(), y = g.split(":")[1].trim();
+    d[m] = y;
+  });
+  const l = {};
+  return i == null || i.split(";").forEach((g) => {
+    if (!g)
+      return;
+    const m = g.split(":")[0].trim(), y = g.split(":")[1].trim();
+    l[m] = y;
+  }), {
+    id: t.id,
+    labelType: t.labelType,
+    text: R(t.text),
+    type: t.type,
+    link: r || void 0,
+    ...o,
+    ...n,
+    containerStyle: d,
+    labelStyle: l
+  };
+}, kt = (t, e, s) => {
+  const r = s.querySelector(`[id*="L-${t.start}-${t.end}-${e}"]`);
+  if (!r)
+    throw new Error("Edge element not found");
+  const o = K(r, s), a = nt(r, o);
+  return t.length = void 0, {
+    ...t,
+    ...a,
+    text: R(t.text)
+  };
+}, K = (t, e) => {
+  var i;
+  if (!t)
+    throw new Error("Element not found");
+  let s = (i = t.parentElement) == null ? void 0 : i.parentElement;
+  const r = t.childNodes[0];
+  let o = { x: 0, y: 0 };
+  if (r) {
+    const { transformX: d, transformY: l } = _(r), b = r.getBBox();
+    o = {
+      x: Number(r.getAttribute("x")) || d + b.x || 0,
+      y: Number(r.getAttribute("y")) || l + b.y || 0
+    };
+  }
+  const { transformX: a, transformY: n } = _(t), c = {
+    x: a + o.x,
+    y: n + o.y
+  };
+  for (; s && s.id !== e.id; ) {
+    if (s.classList.value === "root" && s.hasAttribute("transform")) {
+      const { transformX: d, transformY: l } = _(s);
+      c.x += d, c.y += l;
+    }
+    s = s.parentElement;
+  }
+  return c;
+}, Tt = (t, e) => {
+  t.parse();
+  const s = t.parser.yy, r = s.getVertices();
+  Object.keys(r).forEach((c) => {
+    r[c] = It(r[c], e);
+  });
+  const o = /* @__PURE__ */ new Map(), a = s.getEdges().filter((c) => e.querySelector(`[id*="L-${c.start}-${c.end}"]`)).map((c) => {
+    const i = `${c.start}-${c.end}`, d = o.get(i) || 0;
+    return o.set(i, d + 1), kt(c, d, e);
+  });
+  return {
+    type: "flowchart",
+    subGraphs: s.getSubGraphs().map((c) => At(c, e)),
+    vertices: r,
+    edges: a
+  };
+}, Ot = (t, e) => {
+  const s = {};
+  e != null && e.label && (s.label = { text: R(e.label), fontSize: 16 });
+  const r = t.tagName;
+  if (r === "line")
+    s.startX = Number(t.getAttribute("x1")), s.startY = Number(t.getAttribute("y1")), s.endX = Number(t.getAttribute("x2")), s.endY = Number(t.getAttribute("y2"));
+  else if (r === "path") {
+    const o = t.getAttribute("d");
+    if (!o)
+      throw new Error('Path element does not contain a "d" attribute');
+    const a = o.split(/(?=[LC])/), n = a[0].substring(1).split(",").map((d) => parseFloat(d)), c = [];
+    a.forEach((d) => {
+      const l = d.substring(1).trim().split(" ").map((b) => {
+        const [u, p] = b.split(",");
+        return [
+          parseFloat(u) - n[0],
+          parseFloat(p) - n[1]
+        ];
+      });
+      c.push(...l);
+    });
+    const i = c[c.length - 1];
+    s.startX = n[0], s.startY = n[1], s.endX = i[0], s.endY = i[1], s.points = c;
+  }
+  return e != null && e.label && (s.startY = s.startY - 10, s.endY = s.endY - 10), s.strokeColor = t.getAttribute("stroke"), s.strokeWidth = Number(t.getAttribute("stroke-width")), s.type = "arrow", s.strokeStyle = (e == null ? void 0 : e.strokeStyle) || "solid", s.startArrowhead = (e == null ? void 0 : e.startArrowhead) || null, s.endArrowhead = (e == null ? void 0 : e.endArrowhead) || null, s;
+}, ot = (t, e, s, r, o) => {
+  const a = {};
+  return a.type = "arrow", a.startX = t, a.startY = e, a.endX = s, a.endY = r, Object.assign(a, { ...o }), a;
+}, H = (t, e, s, r) => ({
+  type: "text",
+  x: t,
+  y: e,
+  text: s,
+  width: (r == null ? void 0 : r.width) || 20,
+  height: (r == null ? void 0 : r.height) || 20,
+  fontSize: (r == null ? void 0 : r.fontSize) || G,
+  id: r == null ? void 0 : r.id,
+  groupId: r == null ? void 0 : r.groupId,
+  metadata: r == null ? void 0 : r.metadata
+}), at = (t, e, s) => {
+  const r = {}, o = Number(t.getAttribute("x")), a = Number(t.getAttribute("y"));
+  r.type = "text", r.text = R(e), s != null && s.id && (r.id = s.id), s != null && s.groupId && (r.groupId = s.groupId);
+  const n = t.getBBox();
+  r.width = n.width, r.height = n.height, r.x = o - n.width / 2, r.y = a;
+  const c = parseInt(getComputedStyle(t).fontSize);
+  return r.fontSize = c, r;
+}, O = (t, e, s = {}) => {
+  const r = {};
+  r.type = e;
+  const { label: o, subtype: a, id: n, groupId: c } = s;
+  r.id = n, c && (r.groupId = c), o && (r.label = {
+    text: R(o.text),
+    fontSize: 16,
+    verticalAlign: o == null ? void 0 : o.verticalAlign
+  });
+  const i = t.getBBox();
+  switch (r.x = i.x, r.y = i.y, r.width = i.width, r.height = i.height, r.subtype = a, a) {
+    case "highlight":
+      const d = t.getAttribute("fill");
+      d && (r.bgColor = d);
+      break;
+    case "note":
+      r.strokeStyle = "dashed";
+      break;
+  }
+  return r;
+}, q = (t, e, s, r, o, a) => {
+  const n = {};
+  return n.startX = e, n.startY = s, n.endX = r, a != null && a.groupId && (n.groupId = a.groupId), a != null && a.id && (n.id = a.id), n.endY = o, n.strokeColor = t.getAttribute("stroke"), n.strokeWidth = Number(t.getAttribute("stroke-width")), n.type = "line", n;
+}, Q = {
+  0: "SOLID",
+  1: "DOTTED",
+  3: "SOLID_CROSS",
+  4: "DOTTED_CROSS",
+  5: "SOLID_OPEN",
+  6: "DOTTED_OPEN",
+  24: "SOLID_POINT",
+  25: "DOTTED_POINT"
+}, T = {
+  SOLID: 0,
+  DOTTED: 1,
+  NOTE: 2,
+  SOLID_CROSS: 3,
+  DOTTED_CROSS: 4,
+  SOLID_OPEN: 5,
+  DOTTED_OPEN: 6,
+  SOLID_POINT: 24,
+  DOTTED_POINT: 25,
+  CRITICAL_START: 27
+}, Ct = (t) => {
+  let e;
+  switch (t) {
+    case T.SOLID:
+    case T.SOLID_CROSS:
+    case T.SOLID_OPEN:
+    case T.SOLID_POINT:
+      e = "solid";
+      break;
+    case T.DOTTED:
+    case T.DOTTED_CROSS:
+    case T.DOTTED_OPEN:
+    case T.DOTTED_POINT:
+      e = "dotted";
+      break;
+    default:
+      e = "solid";
+      break;
+  }
+  return e;
+}, Nt = (t, e) => {
+  var r, o;
+  if (!!((r = t.nextElementSibling) != null && r.classList.contains("sequenceNumber"))) {
+    const a = (o = t.nextElementSibling) == null ? void 0 : o.textContent;
+    if (!a)
+      throw new Error("sequence number not present");
+    const n = 30, c = n / 2, d = {
+      type: "rectangle",
+      x: e.startX - 10,
+      y: e.startY - c,
+      label: { text: a, fontSize: 14 },
+      bgColor: "#e9ecef",
+      height: n,
+      subtype: "sequence"
+    };
+    Object.assign(e, { sequenceNumber: d });
+  }
+}, tt = (t, e, s) => {
+  if (!t)
+    throw "root node not found";
+  const r = N(), o = Array.from(t.children), a = [];
+  return o.forEach((n, c) => {
+    const i = `${s == null ? void 0 : s.id}-${c}`;
+    let d;
+    switch (n.tagName) {
+      case "line":
+        const l = Number(n.getAttribute("x1")), b = Number(n.getAttribute("y1")), u = Number(n.getAttribute("x2")), p = Number(n.getAttribute("y2"));
+        d = q(n, l, b, u, p, { groupId: r, id: i });
+        break;
+      case "text":
+        d = at(n, e, {
+          groupId: r,
+          id: i
+        });
+        break;
+      case "circle":
+        d = O(n, "ellipse", {
+          label: n.textContent ? { text: n.textContent } : void 0,
+          groupId: r,
+          id: i
+        });
+      default:
+        d = O(n, ct[n.tagName], {
+          label: n.textContent ? { text: n.textContent } : void 0,
+          groupId: r,
+          id: i
+        });
+    }
+    a.push(d);
+  }), a;
+}, Lt = (t, e) => {
+  const s = Array.from(e.querySelectorAll(".actor-top")), r = Array.from(e.querySelectorAll(".actor-bottom")), o = [], a = [];
+  return Object.values(t).forEach((n, c) => {
+    var b;
+    const i = s.find((u) => u.getAttribute("name") === n.name), d = r.find((u) => u.getAttribute("name") === n.name);
+    if (!i || !d)
+      throw "root not found";
+    const l = n.description;
+    if (n.type === "participant") {
+      const u = O(i, "rectangle", { id: `${n.name}-top`, label: { text: l }, subtype: "actor" });
+      if (!u)
+        throw "Top Node element not found!";
+      o.push([u]);
+      const p = O(d, "rectangle", { id: `${n.name}-bottom`, label: { text: l }, subtype: "actor" });
+      o.push([p]);
+      const g = (b = i == null ? void 0 : i.parentElement) == null ? void 0 : b.previousElementSibling;
+      if ((g == null ? void 0 : g.tagName) !== "line")
+        throw "Line not found";
+      const m = Number(g.getAttribute("x1"));
+      if (!u.height)
+        throw "Top node element height is null";
+      const y = u.y + u.height, S = p.y, E = Number(g.getAttribute("x2")), x = q(g, m, y, E, S);
+      a.push(x);
+    } else if (n.type === "actor") {
+      const u = tt(i, l, {
+        id: `${n.name}-top`
+      });
+      o.push(u);
+      const p = tt(d, l, {
+        id: `${n.name}-bottom`
+      });
+      o.push(p);
+      const g = i.previousElementSibling;
+      if ((g == null ? void 0 : g.tagName) !== "line")
+        throw "Line not found";
+      const m = Number(g.getAttribute("x1")), y = Number(g.getAttribute("y1")), S = Number(g.getAttribute("x2")), E = p.find((x) => x.type === "ellipse");
+      if (E) {
+        const x = E.y, h = q(g, m, y, S, x);
+        a.push(h);
+      }
+    }
+  }), { nodes: o, lines: a };
+}, Dt = (t, e) => {
+  const s = [], r = Array.from(e.querySelectorAll('[class*="messageLine"]')), o = Object.keys(Q), a = t.filter((n) => o.includes(n.type.toString()));
+  return r.forEach((n, c) => {
+    const i = a[c], d = Q[i.type], l = Ot(n, {
+      label: i == null ? void 0 : i.message,
+      strokeStyle: Ct(i.type),
+      endArrowhead: d === "SOLID_OPEN" || d === "DOTTED_OPEN" ? null : "arrow"
+    });
+    Nt(n, l), s.push(l);
+  }), s;
+}, Yt = (t, e) => {
+  const s = Array.from(e.querySelectorAll(".note")).map((a) => a.parentElement), r = t.filter((a) => a.type === T.NOTE), o = [];
+  return s.forEach((a, n) => {
+    if (!a)
+      return;
+    const c = a.firstChild, i = r[n].message, d = O(c, "rectangle", {
+      label: { text: i },
+      subtype: "note"
+    });
+    o.push(d);
+  }), o;
+}, vt = (t) => {
+  const e = Array.from(t.querySelectorAll("[class*=activation]")), s = [];
+  return e.forEach((r) => {
+    const o = O(r, "rectangle", {
+      label: { text: "" },
+      subtype: "activation"
+    });
+    s.push(o);
+  }), s;
+}, Xt = (t, e) => {
+  const s = Array.from(e.querySelectorAll(".loopLine")), r = [], o = [], a = [];
+  s.forEach((l) => {
+    const b = Number(l.getAttribute("x1")), u = Number(l.getAttribute("y1")), p = Number(l.getAttribute("x2")), g = Number(l.getAttribute("y2")), m = q(l, b, u, p, g);
+    m.strokeStyle = "dotted", m.strokeColor = "#adb5bd", m.strokeWidth = 2, r.push(m);
+  });
+  const n = Array.from(e.querySelectorAll(".loopText")), c = t.filter((l) => l.type === T.CRITICAL_START).map((l) => l.message);
+  n.forEach((l) => {
+    var m;
+    const b = l.textContent || "", u = at(l, b), p = ((m = b.match(/\[(.*?)\]/)) == null ? void 0 : m[1]) || "";
+    c.includes(p) && (u.x += 16), o.push(u);
+  });
+  const i = Array.from(e == null ? void 0 : e.querySelectorAll(".labelBox")), d = Array.from(e == null ? void 0 : e.querySelectorAll(".labelText"));
+  return i.forEach((l, b) => {
+    var g;
+    const u = ((g = d[b]) == null ? void 0 : g.textContent) || "", p = O(l, "rectangle", {
+      label: { text: u }
+    });
+    p.strokeColor = "#adb5bd", p.bgColor = "#e9ecef", p.width = void 0, a.push(p);
+  }), { lines: r, texts: o, nodes: a };
+}, _t = (t) => {
+  const e = Array.from(t.querySelectorAll(".rect")).filter((r) => {
+    var o;
+    return ((o = r.parentElement) == null ? void 0 : o.tagName) !== "g";
+  }), s = [];
+  return e.forEach((r) => {
+    const o = O(r, "rectangle", {
+      label: { text: "" },
+      subtype: "highlight"
+    });
+    s.push(o);
+  }), s;
+}, Rt = (t, e) => {
+  t.parse();
+  const s = t.parser.yy, r = [], o = s.getBoxes(), a = _t(e), n = s.getActors(), { nodes: c, lines: i } = Lt(n, e), d = s.getMessages(), l = Dt(d, e), b = Yt(d, e), u = vt(e), p = Xt(d, e);
+  return r.push(a), r.push(...c), r.push(b), r.push(u), { type: "sequence", lines: i, arrows: l, nodes: r, loops: p, groups: o };
+}, j = {
+  AGGREGATION: 0,
+  EXTENSION: 1,
+  COMPOSITION: 2,
+  DEPENDENCY: 3
+}, et = {
+  LINE: 0,
+  DOTTED_LINE: 1
+}, D = 16, $t = (t) => {
+  let e;
+  switch (t) {
+    case et.LINE:
+      e = "solid";
+      break;
+    case et.DOTTED_LINE:
+      e = "dotted";
+      break;
+    default:
+      e = "solid";
+  }
+  return e;
+}, rt = (t) => {
+  let e;
+  switch (t) {
+    case j.AGGREGATION:
+      e = "diamond_outline";
+      break;
+    case j.COMPOSITION:
+      e = "diamond";
+      break;
+    case j.EXTENSION:
+      e = "triangle_outline";
+      break;
+    case "none":
+      e = null;
+      break;
+    case j.DEPENDENCY:
+    default:
+      e = "arrow";
+      break;
+  }
+  return e;
+}, Pt = (t, e) => {
+  const s = [], r = [], o = [];
+  return Object.values(t).forEach((a) => {
+    var m;
+    const { domId: n, id: c } = a, i = N(), d = e.querySelector(`[data-id=${c}]`);
+    if (!d)
+      throw Error(`DOM Node with id ${n} not found`);
+    const { transformX: l, transformY: b } = _(d), u = O(d.firstChild, "rectangle", { id: c, groupId: i });
+    u.x += l, u.y += b, u.metadata = { classId: c }, s.push(u), Array.from(d.querySelectorAll(".divider")).forEach((y) => {
+      const S = Number(y.getAttribute("x1")), E = Number(y.getAttribute("y1")), x = Number(y.getAttribute("x2")), h = Number(y.getAttribute("y2")), f = q(y, S, E, x, h, {
+        groupId: i,
+        id: N()
+      });
+      f.startX += l, f.startY += b, f.endX += l, f.endY += b, f.metadata = { classId: c }, r.push(f);
+    });
+    const g = (m = d.querySelector(".label")) == null ? void 0 : m.children;
+    if (!g)
+      throw "label nodes not found";
+    Array.from(g).forEach((y) => {
+      const S = y.textContent;
+      if (!S)
+        return;
+      const E = N(), { transformX: x, transformY: h } = _(y), f = y.getBBox(), I = H(l + x, b + h + 10, S, {
+        width: f.width,
+        height: f.height,
+        id: E,
+        groupId: i,
+        metadata: { classId: c }
+      });
+      o.push(I);
+    });
+  }), { nodes: s, lines: r, text: o };
+}, Mt = (t, e) => {
+  const s = ["triangle_outline", "diamond", "diamond_outline"], r = e.startArrowhead && s.includes(e.startArrowhead), o = e.endArrowhead && s.includes(e.endArrowhead);
+  return !o && !r || (r && (t === "LR" ? e.startX -= D : t === "RL" ? e.startX += D : t === "TB" ? e.startY -= D : t === "BT" && (e.startY += D)), o && (t === "LR" ? e.endX += D : t === "RL" ? e.endX -= D : t === "TB" ? e.endY += D : t === "BT" && (e.endY -= D))), e;
+}, qt = (t, e, s, r) => {
+  var c;
+  const o = (c = s.querySelector(".edgePaths")) == null ? void 0 : c.children;
+  if (!o)
+    throw new Error("No Edges found!");
+  const a = [], n = [];
+  return t.forEach((i, d) => {
+    const { id1: l, id2: b, relation: u } = i, p = e.find((Y) => Y.id === l), g = e.find((Y) => Y.id === b), m = $t(u.lineType), y = rt(u.type1), S = rt(u.type2), E = nt(o[d]), x = ot(E.startX, E.startY, E.endX, E.endY, {
+      strokeStyle: m,
+      startArrowhead: y,
+      endArrowhead: S,
+      label: i.title ? { text: i.title } : void 0,
+      start: { type: "rectangle", id: p.id },
+      end: { type: "rectangle", id: g.id }
+    }), h = Mt(r, x);
+    a.push(h);
+    const { relationTitle1: f, relationTitle2: C } = i, I = 20, k = 15, L = 15;
+    let w, A;
+    if (f && f !== "none") {
+      switch (r) {
+        case "TB":
+          w = h.startX - I, h.endX < h.startX && (w -= L), A = h.startY + k;
+          break;
+        case "BT":
+          w = h.startX + I, h.endX > h.startX && (w += L), A = h.startY - k;
+          break;
+        case "LR":
+          w = h.startX + I, A = h.startY + k, h.endY > h.startY && (A += L);
+          break;
+        case "RL":
+          w = h.startX - I, A = h.startY - k, h.startY > h.endY && (A -= L);
+          break;
+        default:
+          w = h.startX - I, A = h.startY + k;
+      }
+      const Y = H(w, A, f, {
+        fontSize: 16
+      });
+      n.push(Y);
+    }
+    if (C && C !== "none") {
+      switch (r) {
+        case "TB":
+          w = h.endX + I, h.endX < h.startX && (w += L), A = h.endY - k;
+          break;
+        case "BT":
+          w = h.endX - I, h.endX > h.startX && (w -= L), A = h.endY + k;
+          break;
+        case "LR":
+          w = h.endX - I, A = h.endY - k, h.endY > h.startY && (A -= L);
+          break;
+        case "RL":
+          w = h.endX + I, A = h.endY + k, h.startY > h.endY && (A += L);
+          break;
+        default:
+          w = h.endX + I, A = h.endY - k;
+      }
+      const Y = H(w, A, C, {
+        fontSize: 16
+      });
+      n.push(Y);
+    }
+  }), { arrows: a, text: n };
+}, Bt = (t, e, s) => {
+  const r = [], o = [];
+  return t.forEach((a) => {
+    const { id: n, text: c, class: i } = a, d = e.querySelector(`#${n}`);
+    if (!d)
+      throw new Error(`Node with id ${n} not found!`);
+    const { transformX: l, transformY: b } = _(d), u = d.firstChild, p = O(u, "rectangle", {
+      id: n,
+      subtype: "note",
+      label: { text: c }
+    });
+    if (Object.assign(p, {
+      x: p.x + l,
+      y: p.y + b
+    }), r.push(p), i) {
+      const g = s.find((h) => h.id === i);
+      if (!g)
+        throw new Error(`class node with id ${i} not found!`);
+      const m = p.x + (p.width || 0) / 2, y = p.y + (p.height || 0), S = m, E = g.y, x = ot(m, y, S, E, {
+        strokeStyle: "dotted",
+        startArrowhead: null,
+        endArrowhead: null,
+        start: { id: p.id, type: "rectangle" },
+        end: { id: g.id, type: "rectangle" }
+      });
+      o.push(x);
+    }
+  }), { notes: r, connectors: o };
+}, jt = (t, e) => {
+  t.parse();
+  const s = t.parser.yy, r = s.getDirection(), o = [], a = [], n = [], c = [], i = s.getNamespaces(), d = s.getClasses();
+  if (Object.keys(d).length) {
+    const m = Pt(d, e);
+    o.push(m.nodes), a.push(...m.lines), n.push(...m.text), c.push(...m.nodes);
+  }
+  const l = s.getRelations(), { arrows: b, text: u } = qt(l, c, e, r), { notes: p, connectors: g } = Bt(s.getNotes(), e, c);
+  return o.push(p), b.push(...g), n.push(...u), { type: "class", nodes: o, lines: a, arrows: b, text: n, namespaces: i };
+}, zt = (t) => {
+  const e = t.querySelector("svg");
+  if (!e)
+    throw new Error("SVG element not found");
+  const s = e.getBoundingClientRect(), r = s.width, o = s.height;
+  e.setAttribute("width", `${r}`), e.setAttribute("height", `${o}`);
+  const a = "image/svg+xml", n = unescape(encodeURIComponent(e.outerHTML)), i = `data:image/svg+xml;base64,${btoa(n)}`;
+  return {
+    type: "graphImage",
+    mimeType: a,
+    dataURL: i,
+    width: r,
+    height: o
+  };
+}, Gt = async (t, e = Z) => {
+  U.initialize({ ...Z, ...e });
+  const s = await U.mermaidAPI.getDiagramFromText(St(t)), { svg: r } = await U.render("mermaid-to-excalidraw", t), o = document.createElement("div");
+  o.setAttribute("style", "opacity: 0; position: relative; z-index: -1;"), o.innerHTML = r, o.id = "mermaid-diagram", document.body.appendChild(o);
+  let a;
+  switch (s.type) {
+    case "flowchart-v2": {
+      a = Tt(s, o);
+      break;
+    }
+    case "sequence": {
+      a = Rt(s, o);
+      break;
+    }
+    case "classDiagram": {
+      a = jt(s, o);
+      break;
+    }
+    // fallback to image if diagram type not-supported
+    default:
+      a = zt(o);
+  }
+  return o.remove(), a;
+}, Zt = async (t, e) => {
+  var n;
+  const s = e || {}, r = parseInt(((n = s.themeVariables) == null ? void 0 : n.fontSize) ?? "") || G, o = await Gt(t, {
+    ...s,
+    themeVariables: {
+      ...s.themeVariables,
+      // Multiplying by 1.25 to increase the font size by 25% and render correctly in Excalidraw
+      fontSize: `${r * 1.25}px`
+    }
+  });
+  return Et(o, {
+    fontSize: r
+  });
+};
+export {
+  Zt as parseMermaidToExcalidraw
+};