@draftably/runtime 0.2.0 → 0.4.0

package/dist/graph.js

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

package/dist/host.css

@@ -0,0 +1,37 @@
+/*
+ * @draftably/runtime/host.css: import it once in every page that uses <draft-diagram> or
+ * <draft-editor>. These rules must work before the elements are defined.
+ */
+
+/* Slot content waits for its element, so nothing flashes before the drawing. */
+draft-diagram:not(:defined) > [data-draft-slot],
+draft-editor:not(:defined) > [data-draft-slot] {
+  display: none;
+}
+
+/* The elements' own heights, held before they define, so the page does not shift. */
+draft-diagram:not(:defined) {
+  display: block;
+  height: 26rem;
+}
+draft-editor:not(:defined) {
+  display: block;
+  height: 28rem;
+}
+
+/* Slot content takes no pointer input, so a click reaches the drawing. Marked content does. */
+draft-diagram [data-draft-input],
+draft-editor [data-draft-input] {
+  pointer-events: auto;
+}
+
+/* An editor that could not load says why. */
+draft-editor[status='error']::before {
+  content: attr(data-error);
+  display: block;
+  margin: 0.35rem;
+  color: #9a3412;
+  font:
+    14px/1.45 system-ui,
+    sans-serif;
+}

package/dist/host.js

@@ -0,0 +1,16 @@
+const e = [
+  "anchors",
+  "update",
+  "render",
+  "diagnostics",
+  "camera",
+  "itemactivate",
+  "link",
+  "contextmenu",
+  "select",
+  "change"
+], t = ["link", "contextmenu"];
+export {
+  t as CANCELABLE_EVENTS,
+  e as HOST_EVENTS
+};

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 { renderSvg as r, validate as e } from "./render-CFWEEKPT.js";
+import { r as i } from "./version-CKs2Vl8m.js";
+import { f as v } from "./geometry-DfUVE8b2.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
 };