@draftably/runtime 0.2.0 → 0.3.0

package/dist/graph.js

@@ -0,0 +1,669 @@
+import { c as se, a as re, b as S, q as F, p as ae, d as de, e as le, f as ce, v as ue, g as N, r as pe } from "./compile-Csfz4rk4.js";
+const _ = /^[A-Za-z_][A-Za-z0-9_.-]*$/;
+function H(e, t) {
+  const n = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = new Set(e.filter((r) => _.test(r)));
+  let d = 0;
+  for (const r of e) {
+    if (typeof r != "string" || !r) throw Error(`Every ${t} needs a string id.`);
+    if (n.has(r)) throw Error(`Duplicate ${t} id "${r}".`);
+    let p = r;
+    if (!_.test(r)) {
+      do
+        p = `_${d++}`;
+      while (s.has(p));
+      s.add(p);
+    }
+    n.set(r, p), o.set(p, r);
+  }
+  return {
+    of: (r, p) => {
+      const c = n.get(r);
+      if (!c) throw Error(`${p} refers to unknown id "${r}".`);
+      return c;
+    },
+    back: (r) => o.get(r) ?? r
+  };
+}
+function G(e) {
+  const t = new Set(e.flatMap((o) => o.id ? [o.id] : []));
+  let n = 0;
+  return e.map((o) => {
+    if (o.id) return o.id;
+    let s;
+    do
+      s = `e${++n}`;
+    while (t.has(s));
+    return s;
+  });
+}
+const he = (e) => e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
+function M(e, t, n = {}) {
+  return {
+    kind: "statement",
+    command: e,
+    args: t,
+    attrs: Object.entries(n).filter(([, o]) => o !== void 0 && o !== "").map(([o, s]) => [
+      o,
+      typeof s == "string" && !/^[\w.-]+$/.test(s) ? F(s) : S(String(s))
+    ]),
+    line: 0
+  };
+}
+function A(e, t, n) {
+  const o = t.startsWith("engine:") ? t.slice(7) : void 0;
+  return M("layout", o ? [S(e)] : [S(e), S(t)], {
+    ...o ? { engine: o } : {},
+    ...n
+  });
+}
+function U(e) {
+  if (!e.length) return { x: 0, y: 0, width: 0, height: 0 };
+  const t = Math.min(...e.map((o) => o.x)), n = Math.min(...e.map((o) => o.y));
+  return {
+    x: t,
+    y: n,
+    width: Math.max(...e.map((o) => o.x + o.width)) - t,
+    height: Math.max(...e.map((o) => o.y + o.height)) - n
+  };
+}
+const ge = 1200;
+function fe(e, t, n, o = "auto") {
+  if (o === "full")
+    return { ...N(e, t, n, { previous: [] }), quality: "full" };
+  const s = N(e, t, n, { previous: [], quick: !0 }), { edges: d, crossings: r, lanePairs: p, shared: c } = s.result.report, y = d * (1 + r + p + (c ? 1 : 0));
+  return o === "quick" || y > ge ? { ...s, quality: "quick" } : { ...N(e, t, n, { previous: [] }), quality: "full" };
+}
+function K(e, t, n, o) {
+  const { vg: s, rects: d } = ue(e), r = fe(e, s, d, t), p = new Map([...e.graph.nodes, ...e.graph.groups].map((u) => [u.id, u.parentId])), c = new Map(e.graph.edges.map((u) => [u.id, u])), y = (u) => {
+    const w = d.get(u), m = p.get(u);
+    return { x: w.x, y: w.y, width: w.w, height: w.h, ...m ? { parent: n(m) } : {} };
+  }, f = Object.fromEntries(s.nodes.map((u) => [n(u.id), y(u.id)])), i = Object.fromEntries(s.groups.map((u) => [n(u.id), y(u.id)])), l = Object.fromEntries(
+    r.routes.map((u) => [
+      o(u.id),
+      {
+        source: n(c.get(u.id)?.from ?? u.from),
+        target: n(c.get(u.id)?.to ?? u.to),
+        sourceSide: u.fromSide,
+        targetSide: u.toSide,
+        points: u.points,
+        path: u.path,
+        label: u.label ? {
+          x: u.label.x - u.label.w / 2,
+          y: u.label.y - u.label.h / 2,
+          width: u.label.w,
+          height: u.label.h
+        } : null,
+        blocked: u.blocked
+      }
+    ])
+  ), a = [...Object.values(f), ...Object.values(i)];
+  for (const u of Object.values(l))
+    u.label && a.push(u.label), a.push(U(u.points.map((w) => ({ ...w, width: 0, height: 0 }))));
+  const g = Object.values(l).filter((u) => u.blocked).length;
+  return {
+    nodes: f,
+    groups: i,
+    edges: l,
+    bounds: U(a),
+    quality: r.quality,
+    warnings: g ? [`${g} line${g > 1 ? "s" : ""} found no clear way.`] : []
+  };
+}
+function ye(e, t, n) {
+  let o = e;
+  for (const s of t)
+    n(s) !== s && (o = o.replace(new RegExp(`\\b${s}\\b`, "g"), `"${n(s)}"`));
+  return o;
+}
+function be(e, t) {
+  const n = (o, s, d, r) => {
+    if (o === void 0 || !Number.isFinite(o)) return;
+    const p = Math.round(Math.min(d, Math.max(s, o)));
+    return p !== Math.round(o) && t.push(`Node "${e.id}" ${r} ${o} is outside ${s}–${d}; drawn at ${p}.`), p;
+  };
+  return { width: n(e.width, 40, 1200, "width"), height: n(e.height, 24, 1200, "height") };
+}
+function Z(e) {
+  const t = e.groups ?? [], n = e.nodes ?? [], o = e.edges ?? [], s = G(o), d = H([...t.map((a) => a.id), ...n.map((a) => a.id)], "node or group"), r = H(s, "edge"), p = d.of, { quality: c, ...y } = e.routing ?? {}, f = [], i = [
+    ...t.map(
+      (a) => M("group", [S(p(a.id, "group")), F(a.label ?? a.id)], {
+        in: a.parent && p(a.parent, `Group "${a.id}"`),
+        fold: e.fold === "never" ? "never" : void 0
+      })
+    ),
+    ...n.map(
+      (a) => M("node", [S(p(a.id, "node")), F(a.label ?? a.id)], {
+        in: a.parent && p(a.parent, `Node "${a.id}"`),
+        shape: a.shape
+      })
+    ),
+    ...o.map(
+      (a, g) => M(
+        "edge",
+        [
+          S(r.of(s[g], "edge")),
+          S(p(a.source, `Edge "${s[g]}"`)),
+          S("->"),
+          S(p(a.target, `Edge "${s[g]}"`)),
+          ...a.label ? [F(a.label)] : []
+        ],
+        { kind: a.dashed ? "async" : void 0, from: a.sourceSide, to: a.targetSide }
+      )
+    ),
+    // A file with no layout line spaces its root flow 48px apart; a layout line without `gap=`
+    // only 28px, too tight for a line into a group below its title band.
+    A("root", e.arrange ?? "flow", {
+      gap: e.gap ?? ((e.arrange ?? "flow") === "flow" ? 48 : void 0),
+      direction: e.direction,
+      fit: e.fit,
+      fold: e.fold === "never" ? "never" : void 0
+    }),
+    ...t.filter((a) => a.arrange || a.direction || a.gap).map(
+      (a) => A(p(a.id, "group"), a.arrange ?? "column", {
+        gap: a.gap,
+        direction: a.direction
+      })
+    ),
+    ...n.flatMap((a) => {
+      const { width: g, height: u } = be(a, f);
+      return g || u ? [
+        M("size", [S(p(a.id, "node"))], {
+          width: g ?? 176,
+          height: u ?? "auto"
+        })
+      ] : [];
+    }),
+    ...Object.keys(y).length ? [
+      M(
+        "routing",
+        [],
+        Object.fromEntries(Object.entries(y).map(([a, g]) => [he(a), g]))
+      )
+    ] : []
+  ];
+  return { draft: ae({ lines: i }), model: de({ lines: i }), quality: c, objects: d, lines: r, warnings: f };
+}
+function J({ draft: e, model: t, quality: n, objects: o, lines: s, warnings: d }, r) {
+  const p = K(le(r), n, o.back, s.back);
+  return {
+    ...p,
+    draft: e,
+    warnings: [
+      ...d,
+      ...t.warnings.map((c) => c.message),
+      // A caller's size is the host's to fill: whether draftably's text fits it says nothing.
+      ...r.diagnostics.filter((c) => c.level !== "info" && c.code !== "text-overflow").map((c) => ye(c.message, c.ids, o.back)),
+      ...p.warnings
+    ]
+  };
+}
+async function T(e) {
+  const t = Z(e);
+  return J(t, await re(t.draft));
+}
+function Q(e) {
+  const t = Z(e);
+  if (t.model.layouts.some((n) => n.engine || n.fit))
+    throw Error("layoutSync cannot run layout engines or fit; use layout().");
+  return J(t, se(t.draft));
+}
+function W(e) {
+  const t = ce(), n = e.groups ?? [], o = /* @__PURE__ */ new Set(), { quality: s, ...d } = e.routing ?? {}, r = G(e.edges);
+  t.settings.routing = { ...t.settings.routing, ...d };
+  for (const i of [...n, ...e.nodes]) {
+    if (o.has(i.id)) throw Error(`Duplicate node or group id "${i.id}".`);
+    o.add(i.id);
+  }
+  const p = (i, l) => {
+    if (i !== void 0 && !o.has(i)) throw Error(`${l} refers to unknown id "${i}".`);
+  };
+  for (const i of n)
+    p(i.parent, `Group "${i.id}"`), t.graph.groups.push({
+      id: i.id,
+      title: i.label ?? "",
+      ...i.parent ? { parentId: i.parent } : {}
+    }), t.layout.containers[i.id] = { direction: "inherit", padding: 0, manualSize: !0 };
+  for (const i of e.nodes)
+    p(i.parent, `Node "${i.id}"`), t.graph.nodes.push({ id: i.id, title: "", ...i.parent ? { parentId: i.parent } : {} }), t.styles[i.id] = { shape: i.shape ?? "box", color: "auto", icon: "" };
+  for (const i of [...n, ...e.nodes])
+    t.layout.nodes[i.id] = { x: i.x, y: i.y, w: i.width, h: i.height };
+  e.edges.forEach((i, l) => {
+    const a = r[l];
+    p(i.source, `Edge "${a}"`), p(i.target, `Edge "${a}"`), t.graph.edges.push({
+      id: a,
+      from: i.source,
+      to: i.target,
+      label: i.label ?? "",
+      directed: !0,
+      emphasis: !1,
+      dashed: !!i.dashed
+    }), t.layout.edges[a] = {
+      ...i.sourceSide ? { fromSide: i.sourceSide } : {},
+      ...i.targetSide ? { toSide: i.targetSide } : {}
+    };
+  });
+  const {
+    edges: c,
+    quality: y,
+    warnings: f
+  } = K(
+    t,
+    s,
+    (i) => i,
+    (i) => i
+  );
+  return { edges: c, quality: y, warnings: f };
+}
+const we = /* @__PURE__ */ new Set(["left", "right", "top", "bottom"]), B = (e) => e && we.has(e) ? e : void 0, E = (e) => typeof e == "number" && e > 0 ? e : void 0, k = (e) => e.parentId ?? e.parentNode, R = (e) => typeof e.data?.label == "string" ? e.data.label : e.id, V = (e) => {
+  const t = typeof e.style == "object" ? e.style : void 0;
+  return {
+    width: E(e.measured?.width) ?? E(e.width) ?? E(t?.width),
+    height: E(e.measured?.height) ?? E(e.height) ?? E(t?.height)
+  };
+}, X = (e) => /* @__PURE__ */ new Set([
+  ...e.flatMap((t) => k(t) ? [k(t)] : []),
+  ...e.filter((t) => t.type === "group").map((t) => t.id)
+]);
+function Y({ nodes: e, edges: t }, n = {}) {
+  const o = X(e);
+  return {
+    groups: e.filter((s) => o.has(s.id)).map((s) => ({ id: s.id, label: R(s), parent: k(s) })),
+    nodes: e.filter((s) => !o.has(s.id)).map((s) => {
+      const { width: d, height: r } = V(s);
+      return {
+        id: s.id,
+        label: R(s),
+        parent: k(s),
+        shape: n.shape?.(s),
+        ...d ? { width: d } : {},
+        ...r ? { height: r } : {}
+      };
+    }),
+    edges: t.map((s) => ({
+      id: s.id,
+      source: s.source,
+      target: s.target,
+      label: typeof s.label == "string" ? s.label : void 0,
+      dashed: s.animated,
+      sourceSide: B(s.sourceHandle),
+      targetSide: B(s.targetHandle)
+    }))
+  };
+}
+function ee(e, t) {
+  return e.map((n) => {
+    const o = t[n.id], s = o ? {
+      path: o.path,
+      points: o.points,
+      label: o.label,
+      sourceSide: o.sourceSide,
+      targetSide: o.targetSide,
+      blocked: o.blocked
+    } : {
+      path: "",
+      points: [],
+      label: null,
+      sourceSide: "right",
+      targetSide: "left",
+      blocked: !0
+    };
+    return { ...n, type: n.type ?? "draftably", data: { ...n.data, draftably: s } };
+  });
+}
+function me({ nodes: e, edges: t }, n, o = !1) {
+  const s = (d) => n.nodes[d] ?? n.groups[d];
+  return {
+    nodes: e.map((d) => {
+      const r = s(d.id), p = k(d) ? s(k(d)) : void 0;
+      if (!r) return d;
+      const c = { width: r.width, height: r.height };
+      return {
+        ...d,
+        position: { x: r.x - (p?.x ?? 0), y: r.y - (p?.y ?? 0) },
+        ...c,
+        ...o || typeof d.style == "string" ? {} : { style: { ...d.style, ...c } }
+      };
+    }),
+    edges: ee(t, n.edges)
+  };
+}
+function xe({ nodes: e, edges: t }, n = {}) {
+  const o = new Map(e.map((c) => [c.id, c])), s = X(e), d = (c) => {
+    const y = k(c) ? o.get(k(c)) : void 0, f = y ? d(y) : { x: 0, y: 0 };
+    return { x: f.x + (c.position?.x ?? 0), y: f.y + (c.position?.y ?? 0) };
+  }, r = e.flatMap((c) => {
+    const { width: y, height: f } = V(c);
+    return y && f ? [{ n: c, box: { ...d(c), width: y, height: f } }] : [];
+  }), p = new Set(r.map((c) => c.n.id));
+  return {
+    groups: r.filter(({ n: c }) => s.has(c.id)).map(({ n: c, box: y }) => ({ id: c.id, label: R(c), parent: k(c), ...y })),
+    nodes: r.filter(({ n: c }) => !s.has(c.id)).map(({ n: c, box: y }) => ({
+      id: c.id,
+      parent: k(c),
+      shape: n.shape?.(c),
+      ...y
+    })),
+    edges: Y({ nodes: [], edges: t }).edges.filter(
+      (c) => p.has(c.source) && p.has(c.target)
+    )
+  };
+}
+function Se(e, t) {
+  return ee(e, t.edges).map(
+    (n, o) => t.edges[n.id] || !e[o].data?.draftably ? n : e[o]
+  );
+}
+const P = (e, t) => Object.fromEntries(Object.entries(e).map(([n, o]) => [n, t(o)]));
+function te(e, t, n, o, s = e.bounds) {
+  return {
+    ...e,
+    bounds: s,
+    nodes: P(e.nodes, t),
+    groups: P(e.groups, t),
+    edges: P(e.edges, (d) => {
+      const r = d.points.map(n);
+      return {
+        ...d,
+        points: r,
+        path: pe(r, 6),
+        label: d.label && t(d.label),
+        sourceSide: o(d.sourceSide),
+        targetSide: o(d.targetSide)
+      };
+    })
+  };
+}
+function oe(e) {
+  const t = -e.bounds.x, n = -e.bounds.y;
+  return !t && !n ? e : te(
+    e,
+    (o) => ({ ...o, x: o.x + t, y: o.y + n }),
+    (o) => ({ x: o.x + t, y: o.y + n }),
+    (o) => o,
+    { ...e.bounds, x: 0, y: 0 }
+  );
+}
+const ke = { left: "right", right: "left", top: "bottom", bottom: "top" };
+function D(e, t) {
+  const n = t === "x" ? "width" : "height", o = 2 * e.bounds[t] + e.bounds[n], s = t === "x" ? ["left", "right"] : ["top", "bottom"];
+  return te(
+    e,
+    (d) => ({ ...d, [t]: o - d[t] - d[n] }),
+    (d) => ({ ...d, [t]: o - d[t] }),
+    (d) => s.includes(d) ? ke[d] : d
+  );
+}
+function j(e, t) {
+  return e?.[`elk.${t}`] ?? e?.[`org.eclipse.elk.${t}`] ?? e?.[t];
+}
+const C = (e) => e.replace(/^(org\.eclipse\.)?elk\./, ""), $e = /* @__PURE__ */ new Set([
+  "algorithm",
+  "direction",
+  "spacing.nodeNode",
+  "layered.spacing.nodeNodeBetweenLayers",
+  "port.side",
+  "hierarchyHandling",
+  "edgeRouting",
+  "portConstraints",
+  "nodeSize.constraints",
+  "nodeLabels.placement"
+]), Oe = {
+  NORTH: "top",
+  SOUTH: "bottom",
+  EAST: "right",
+  WEST: "left"
+};
+function Ee(e, t) {
+  const n = [], o = [], s = [], d = [], r = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), y = { ...t, ...e.layoutOptions }, f = (h) => {
+    for (const b of Object.keys(h ?? {})) $e.has(C(b)) || r.add(C(b));
+  };
+  f(y);
+  const i = { nodes: n, groups: o, edges: s, fold: "never" }, l = j(y, "direction");
+  let a;
+  l === "DOWN" || l === "UP" ? i.direction = "down" : (l === "RIGHT" || l === "LEFT") && (i.direction = "right"), l === "LEFT" && (a = "x"), l === "UP" && (a = "y");
+  const g = Number(
+    j(y, "layered.spacing.nodeNodeBetweenLayers") ?? j(y, "spacing.nodeNode")
+  );
+  g > 0 && (i.gap = Math.min(300, Math.max(8, g)));
+  const u = j(y, "algorithm");
+  u && /force|stress/.test(u) ? i.arrange = "engine:stress" : u && /mrtree/.test(u) ? i.arrange = "engine:tree" : u && /rectpacking|box/.test(u) && (i.arrange = "engine:grid");
+  const w = (h, b) => {
+    for (const x of h.ports ?? [])
+      f(x.layoutOptions), p.set(x.id, { node: h.id, side: Oe[j(x.layoutOptions, "port.side") ?? ""] });
+    if (h !== e) {
+      f(h.layoutOptions);
+      const x = h.labels?.[0]?.text ?? h.id;
+      h.children?.length ? o.push({ id: h.id, label: x, parent: b, arrange: "flow" }) : n.push({
+        id: h.id,
+        label: x,
+        parent: b,
+        ...h.width ? { width: h.width } : {},
+        ...h.height ? { height: h.height } : {}
+      });
+    }
+    for (const x of h.children ?? []) w(x, h === e ? void 0 : h.id);
+  };
+  w(e);
+  const m = (h) => p.get(h) ?? { node: h, side: void 0 }, $ = (h) => {
+    for (const b of h.edges ?? []) {
+      f(b.layoutOptions);
+      const x = b.sources.flatMap((L) => b.targets.map((O) => [m(L), m(O)])), I = x.map((L, O) => x.length > 1 ? `${b.id}#${O}` : b.id);
+      c.set(b.id, I), x.forEach(
+        ([L, O], ne) => s.push({
+          id: I[ne],
+          source: L.node,
+          target: O.node,
+          label: b.labels?.[0]?.text,
+          sourceSide: L.side,
+          targetSide: O.side
+        })
+      );
+    }
+    for (const b of h.children ?? []) $(b);
+  };
+  return $(e), r.size && d.push(`These ELK options are not used: ${[...r].sort().join(", ")}.`), { graph: i, warnings: d, pieces: c, mirror: a };
+}
+function ve(e, t, { pieces: n }) {
+  const o = /* @__PURE__ */ new Map([[e.id, { x: 0, y: 0 }]]), s = /* @__PURE__ */ new Map(), d = (l, a) => {
+    const g = l === e ? void 0 : t.nodes[l.id] ?? t.groups[l.id], u = g ? { x: g.x, y: g.y } : a;
+    o.set(l.id, u);
+    for (const m of l.children ?? []) s.set(m.id, l.id);
+    const w = l.children?.map((m) => d(m, u));
+    return {
+      ...l,
+      ...l === e ? {
+        x: 0,
+        y: 0,
+        width: t.bounds.x + t.bounds.width,
+        height: t.bounds.y + t.bounds.height
+      } : { x: u.x - a.x, y: u.y - a.y, width: g?.width, height: g?.height },
+      ...w ? { children: w } : {}
+    };
+  }, r = d(e, { x: 0, y: 0 }), p = /* @__PURE__ */ new Map(), c = (l) => {
+    for (const a of l.ports ?? []) p.set(a.id, l.id);
+    l.children?.forEach(c);
+  };
+  c(e);
+  const y = (l) => {
+    const a = [];
+    for (let g = s.get(p.get(l) ?? l); g; g = s.get(g)) a.push(g);
+    return a;
+  }, f = (l) => {
+    const a = y(l.sources[0]), g = new Set(y(l.targets[0]));
+    return a.find((u) => g.has(u)) ?? e.id;
+  }, i = (l) => ({
+    ...l,
+    ...l.edges ? {
+      edges: l.edges.map((a) => {
+        const g = f(a), u = o.get(g) ?? { x: 0, y: 0 }, w = (h) => ({ x: h.x - u.x, y: h.y - u.y }), m = (n.get(a.id) ?? [a.id]).map((h) => t.edges[h]).filter(Boolean), $ = m[0]?.label;
+        return {
+          ...a,
+          container: g,
+          sections: m.map((h, b) => ({
+            id: `${a.id}_s${b}`,
+            startPoint: w(h.points[0]),
+            endPoint: w(h.points.at(-1)),
+            bendPoints: h.points.slice(1, -1).map(w),
+            incomingShape: h.source,
+            outgoingShape: h.target
+          })),
+          ...a.labels?.length && $ ? {
+            labels: a.labels.map(
+              (h, b) => b ? h : { ...h, ...w($), width: $.width, height: $.height }
+            )
+          } : {}
+        };
+      })
+    } : {},
+    ...l.children ? { children: l.children.map(i) } : {}
+  });
+  return i(r);
+}
+async function ie(e, t, n) {
+  const o = Ee(e, t), s = await T({ ...o.graph, ...n }), d = oe(o.mirror ? D(s, o.mirror) : s);
+  return d.warnings.unshift(...o.warnings), { elk: ve(e, d, o), result: d };
+}
+class Le {
+  constructor(t = {}) {
+    this.options = t;
+  }
+  /** Warnings from the last `layout` call, such as ELK options that were not used. */
+  warnings = [];
+  async layout(t, n = {}) {
+    const { elk: o, result: s } = await ie(t, {
+      ...this.options.defaultLayoutOptions,
+      ...n.layoutOptions
+    });
+    return this.warnings = s.warnings, o;
+  }
+  knownLayoutAlgorithms() {
+    return Promise.resolve([{ id: "draftably.flow", name: "Draftably flow" }]);
+  }
+  terminateWorker() {
+  }
+}
+const v = (e) => typeof e == "number" && e > 0 ? e : void 0, q = (e) => typeof e == "string" ? e : void 0;
+function je(e, t = {}) {
+  const n = e.nodes(), o = (i) => e.parent?.(i) || void 0, s = new Set(n.filter((i) => e.children?.(i)?.length)), d = e.graph() ?? {}, r = q(d.rankdir)?.toUpperCase() ?? "TB", p = e.edges(), c = (i) => `${i.v}->${i.w}${i.name ? `:${i.name}` : ""}`, y = {
+    // dagre never folds a long drawing into rows, and its clusters flow like the rest.
+    fold: "never",
+    direction: r === "LR" || r === "RL" ? "right" : "down",
+    ...v(d.ranksep) ? { gap: Math.min(300, Math.max(8, v(d.ranksep))) } : {},
+    groups: n.filter((i) => s.has(i)).map((i) => ({
+      id: i,
+      label: q(e.node(i)?.label) ?? i,
+      parent: o(i),
+      arrange: "flow"
+    })),
+    nodes: n.filter((i) => !s.has(i)).map((i) => {
+      const l = e.node(i) ?? {};
+      return {
+        id: i,
+        label: q(l.label) ?? i,
+        parent: o(i),
+        ...v(l.width) ? { width: v(l.width) } : {},
+        ...v(l.height) ? { height: v(l.height) } : {}
+      };
+    }),
+    edges: p.map((i) => ({
+      id: c(i),
+      source: i.v,
+      target: i.w,
+      label: q(e.edge(i)?.label)
+    })),
+    routing: t.routing
+  };
+  let f = Q(y);
+  r === "BT" && (f = D(f, "y")), r === "RL" && (f = D(f, "x")), f = oe(f);
+  for (const i of n) {
+    const l = f.nodes[i] ?? f.groups[i], a = e.node(i);
+    !l || !a || Object.assign(a, {
+      x: l.x + l.width / 2,
+      y: l.y + l.height / 2,
+      width: l.width,
+      height: l.height
+    });
+  }
+  for (const i of p) {
+    const l = f.edges[c(i)], a = e.edge(i);
+    !l || !a || Object.assign(a, {
+      points: l.points.map((g) => ({ x: g.x, y: g.y })),
+      ...l.label ? { x: l.label.x + l.label.width / 2, y: l.label.y + l.label.height / 2 } : {}
+    });
+  }
+  return Object.assign(d, { width: f.bounds.width, height: f.bounds.height }), f;
+}
+function z(e) {
+  this.options = e;
+}
+z.prototype.run = function() {
+  const e = this.options, t = e.eles.nodes(), n = (r) => {
+    const p = r.data("label");
+    return typeof p == "string" ? p : r.id();
+  }, o = (r) => r.parent().length ? r.parent().id() : void 0, s = {
+    direction: e.direction,
+    gap: e.gap,
+    routing: e.routing,
+    groups: t.filter((r) => r.isParent()).map((r) => ({ id: r.id(), label: n(r), parent: o(r) })),
+    nodes: t.filter((r) => !r.isParent()).map((r) => ({
+      id: r.id(),
+      label: n(r),
+      parent: o(r),
+      width: r.outerWidth(),
+      height: r.outerHeight()
+    })),
+    edges: e.eles.edges().map((r) => ({
+      id: r.id(),
+      source: r.source().id(),
+      target: r.target().id(),
+      label: typeof r.data("label") == "string" ? r.data("label") : void 0
+    }))
+  }, d = Q(s);
+  return this.result = d, t.layoutPositions(this, { fit: !0, padding: 30, animate: !1, ...e }, (r) => {
+    const p = d.nodes[r.id()] ?? d.groups[r.id()];
+    return p ? { x: p.x + p.width / 2, y: p.y + p.height / 2 } : { x: 0, y: 0 };
+  }), this;
+};
+z.prototype.stop = function() {
+  return this;
+};
+function qe(e) {
+  e("layout", "draftably", z);
+}
+async function Fe(e) {
+  if ("elk" in e) {
+    const { elk: t, ...n } = e;
+    return ie(t, void 0, n);
+  }
+  for (const t of ["reactFlow", "svelteFlow"])
+    if (t in e) {
+      const {
+        [t]: n,
+        shape: o,
+        ...s
+      } = e, d = await T({ ...Y(n, { shape: o }), ...s });
+      return { [t]: me(n, d, t === "svelteFlow"), result: d };
+    }
+  return T(e);
+}
+function Ne(e) {
+  for (const t of ["reactFlow", "svelteFlow"])
+    if (t in e) {
+      const {
+        [t]: n,
+        shape: o,
+        routing: s
+      } = e, d = W({ ...xe(n, { shape: o }), routing: s });
+      return { [t]: { nodes: n.nodes, edges: Se(n.edges, d) }, result: d };
+    }
+  return W(e);
+}
+export {
+  ge as AUTO_FULL_LIMIT,
+  Le as DraftablyELK,
+  je as dagreLayout,
+  qe as draftablyLayout,
+  Fe as layout,
+  Q as layoutSync,
+  Ne as route
+};

package/dist/index.js

@@ -1,9 +1,10 @@
-import { r, v as e } from "./render-ZzhO-2H6.js";
-import { f as i, a as v } from "./render-ZzhO-2H6.js";
+import { r, v as e } from "./render-Dgo42PR4.js";
+import { a as i } from "./render-Dgo42PR4.js";
+import { h as v } from "./compile-Csfz4rk4.js";
 const t = r, a = e;
 export {
-  i as fontMetricsVersion,
+  v as fontMetricsVersion,
   t as renderSvg,
-  v as runtimeVersion,
+  i as runtimeVersion,
   a as validate
 };