@draftably/runtime 0.3.0 → 0.5.0

package/dist/graph.js

@@ -1,153 +1,116 @@
-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";
+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-BAIrdu-8.js";
+import { p as pe } from "./geometry-DfUVE8b2.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)) {
+  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
-        p = `_${d++}`;
-      while (s.has(p));
-      s.add(p);
+        u = `_${a++}`;
+      while (n.has(u));
+      n.add(u);
     }
-    n.set(r, p), o.set(p, r);
+    r.set(s, u), o.set(u, s);
   }
   return {
-    of: (r, p) => {
-      const c = n.get(r);
-      if (!c) throw Error(`${p} refers to unknown id "${r}".`);
-      return c;
+    of: (s, u) => {
+      const l = r.get(s);
+      if (!l) throw Error(`${u} refers to unknown id "${s}".`);
+      return l;
     },
-    back: (r) => o.get(r) ?? r
+    back: (s) => o.get(s) ?? s
   };
 }
-function G(e) {
+function C(e) {
   const t = new Set(e.flatMap((o) => o.id ? [o.id] : []));
-  let n = 0;
+  let r = 0;
   return e.map((o) => {
     if (o.id) return o.id;
-    let s;
+    let n;
     do
-      s = `e${++n}`;
-    while (t.has(s));
-    return s;
+      n = `e${++r}`;
+    while (t.has(n));
+    return n;
   });
 }
 const he = (e) => e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
-function M(e, t, n = {}) {
+function M(e, t, r = {}) {
   return {
     kind: "statement",
     command: e,
     args: t,
-    attrs: Object.entries(n).filter(([, o]) => o !== void 0 && o !== "").map(([o, s]) => [
+    attrs: Object.entries(r).filter(([, o]) => o !== void 0 && o !== "").map(([o, n]) => [
       o,
-      typeof s == "string" && !/^[\w.-]+$/.test(s) ? F(s) : S(String(s))
+      typeof n == "string" && !/^[\w.-]+$/.test(n) ? F(n) : m(String(n))
     ]),
     line: 0
   };
 }
-function A(e, t, n) {
+function A(e, t, r) {
   const o = t.startsWith("engine:") ? t.slice(7) : void 0;
-  return M("layout", o ? [S(e)] : [S(e), S(t)], {
+  return M("layout", o ? [m(e)] : [m(e), m(t)], {
     ...o ? { engine: o } : {},
-    ...n
+    ...r
   });
 }
-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") {
+function fe(e, t, r, 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" };
+    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 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;
+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 {
-    nodes: f,
-    groups: i,
-    edges: l,
-    bounds: U(a),
-    quality: r.quality,
-    warnings: g ? [`${g} line${g > 1 ? "s" : ""} found no clear way.`] : []
+    ...u,
+    quality: s.quality,
+    warnings: l ? [`${l} line${l > 1 ? "s" : ""} found no clear way.`] : []
   };
 }
-function ye(e, t, n) {
+function ye(e, t, r) {
   let o = e;
-  for (const s of t)
-    n(s) !== s && (o = o.replace(new RegExp(`\\b${s}\\b`, "g"), `"${n(s)}"`));
+  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 n = (o, s, d, r) => {
+  const r = (o, n, a, s) => {
     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;
+    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: n(e.width, 40, 1200, "width"), height: n(e.height, 24, 1200, "height") };
+  return { width: r(e.width, 40, 1200, "width"), height: r(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 = [
+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(
-      (a) => M("group", [S(p(a.id, "group")), F(a.label ?? a.id)], {
-        in: a.parent && p(a.parent, `Group "${a.id}"`),
+      (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
       })
     ),
-    ...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
+    ...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(
-      (a, g) => M(
+      (d, 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)] : []
+          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: a.dashed ? "async" : void 0, from: a.sourceSide, to: a.targetSide }
+        { 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=`
@@ -158,141 +121,141 @@ function Z(e) {
       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
+    ...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
       })
     ),
-    ...n.flatMap((a) => {
-      const { width: g, height: u } = be(a, f);
-      return g || u ? [
-        M("size", [S(p(a.id, "node"))], {
+    ...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: u ?? "auto"
+          height: y ?? "auto"
         })
       ] : [];
     }),
-    ...Object.keys(y).length ? [
+    ...Object.keys(f).length ? [
       M(
         "routing",
         [],
-        Object.fromEntries(Object.entries(y).map(([a, g]) => [he(a), g]))
+        Object.fromEntries(Object.entries(f).map(([d, g]) => [he(d), g]))
       )
     ] : []
   ];
-  return { draft: ae({ lines: i }), model: de({ lines: i }), quality: c, objects: d, lines: r, warnings: f };
+  return { draft: se({ lines: i }), model: ae({ lines: i }), quality: l, objects: a, lines: s, warnings: h };
 }
-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);
+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 {
-    ...p,
+    ...u,
     draft: e,
     warnings: [
-      ...d,
-      ...t.warnings.map((c) => c.message),
+      ...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.
-      ...r.diagnostics.filter((c) => c.level !== "info" && c.code !== "text-overflow").map((c) => ye(c.message, c.ids, o.back)),
-      ...p.warnings
+      ...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 = Z(e);
-  return J(t, await re(t.draft));
+  const t = K(e);
+  return Z(t, await re(t.draft));
 }
-function Q(e) {
-  const t = Z(e);
-  if (t.model.layouts.some((n) => n.engine || n.fit))
+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 J(t, se(t.draft));
+  return Z(t, ne(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]) {
+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 p = (i, l) => {
-    if (i !== void 0 && !o.has(i)) throw Error(`${l} refers to unknown id "${i}".`);
+  const u = (i, c) => {
+    if (i !== void 0 && !o.has(i)) throw Error(`${c} refers to unknown id "${i}".`);
   };
-  for (const i of n)
-    p(i.parent, `Group "${i.id}"`), t.graph.groups.push({
+  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)
-    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])
+    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, l) => {
-    const a = r[l];
-    p(i.source, `Edge "${a}"`), p(i.target, `Edge "${a}"`), t.graph.edges.push({
-      id: a,
+  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[a] = {
+    }), t.layout.edges[d] = {
       ...i.sourceSide ? { fromSide: i.sourceSide } : {},
       ...i.targetSide ? { toSide: i.targetSide } : {}
     };
   });
   const {
-    edges: c,
-    quality: y,
-    warnings: f
-  } = K(
+    edges: l,
+    quality: f,
+    warnings: h
+  } = G(
     t,
-    s,
+    n,
     (i) => i,
     (i) => i
   );
-  return { edges: c, quality: y, warnings: f };
+  return { edges: l, quality: f, warnings: h };
 }
-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 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)
   };
-}, X = (e) => /* @__PURE__ */ new Set([
+}, V = (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);
+function X({ nodes: e, edges: t }, r = {}) {
+  const o = V(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);
+    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: s.id,
-        label: R(s),
-        parent: k(s),
-        shape: n.shape?.(s),
-        ...d ? { width: d } : {},
-        ...r ? { height: r } : {}
+        id: n.id,
+        label: I(n),
+        parent: k(n),
+        shape: r.shape?.(n),
+        ...a ? { width: a } : {},
+        ...s ? { height: s } : {}
       };
     }),
-    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)
+    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 ee(e, t) {
-  return e.map((n) => {
-    const o = t[n.id], s = o ? {
+function Y(e, t) {
+  return e.map((r) => {
+    const o = t[r.id], n = o ? {
       path: o.path,
       points: o.points,
       label: o.label,
@@ -307,96 +270,96 @@ function ee(e, t) {
       targetSide: "left",
       blocked: !0
     };
-    return { ...n, type: n.type ?? "draftably", data: { ...n.data, draftably: s } };
+    return { ...r, type: r.type ?? "draftably", data: { ...r.data, draftably: n } };
   });
 }
-function me({ nodes: e, edges: t }, n, o = !1) {
-  const s = (d) => n.nodes[d] ?? n.groups[d];
+function me({ nodes: e, edges: t }, r, o = !1) {
+  const n = (a) => r.nodes[a] ?? r.groups[a];
   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 };
+    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 {
-        ...d,
-        position: { x: r.x - (p?.x ?? 0), y: r.y - (p?.y ?? 0) },
-        ...c,
-        ...o || typeof d.style == "string" ? {} : { style: { ...d.style, ...c } }
+        ...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: ee(t, n.edges)
+    edges: Y(t, r.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));
+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: 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
+    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: Y({ nodes: [], edges: t }).edges.filter(
-      (c) => p.has(c.source) && p.has(c.target)
+    edges: X({ nodes: [], edges: t }).edges.filter(
+      (l) => u.has(l.source) && u.has(l.target)
     )
   };
 }
-function Se(e, t) {
-  return ee(e, t.edges).map(
-    (n, o) => t.edges[n.id] || !e[o].data?.draftably ? n : e[o]
+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(([n, o]) => [n, t(o)]));
-function te(e, t, n, o, s = e.bounds) {
+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: s,
+    bounds: n,
     nodes: P(e.nodes, t),
     groups: P(e.groups, t),
-    edges: P(e.edges, (d) => {
-      const r = d.points.map(n);
+    edges: P(e.edges, (a) => {
+      const s = a.points.map(r);
       return {
-        ...d,
-        points: r,
-        path: pe(r, 6),
-        label: d.label && t(d.label),
-        sourceSide: o(d.sourceSide),
-        targetSide: o(d.targetSide)
+        ...a,
+        points: s,
+        path: ue(s, 6),
+        label: a.label && t(a.label),
+        sourceSide: o(a.sourceSide),
+        targetSide: o(a.targetSide)
       };
     })
   };
 }
-function oe(e) {
-  const t = -e.bounds.x, n = -e.bounds.y;
-  return !t && !n ? e : te(
+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 + n }),
-    (o) => ({ x: o.x + t, y: o.y + n }),
+    (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 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(
+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,
-    (d) => ({ ...d, [t]: o - d[t] - d[n] }),
-    (d) => ({ ...d, [t]: o - d[t] }),
-    (d) => s.includes(d) ? ke[d] : d
+    (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 C = (e) => e.replace(/^(org\.eclipse\.)?elk\./, ""), $e = /* @__PURE__ */ new Set([
+const B = (e) => e.replace(/^(org\.eclipse\.)?elk\./, ""), $e = /* @__PURE__ */ new Set([
   "algorithm",
   "direction",
   "spacing.nodeNode",
@@ -414,43 +377,43 @@ const C = (e) => e.replace(/^(org\.eclipse\.)?elk\./, ""), $e = /* @__PURE__ */
   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));
+  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));
   };
-  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");
+  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(y, "layered.spacing.nodeNodeBetweenLayers") ?? j(y, "spacing.nodeNode")
+    j(f, "layered.spacing.nodeNodeBetweenLayers") ?? j(f, "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,
+  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,
-        ...h.width ? { width: h.width } : {},
-        ...h.height ? { height: h.height } : {}
+        ...p.width ? { width: p.width } : {},
+        ...p.height ? { height: p.height } : {}
       });
     }
-    for (const x of h.children ?? []) w(x, h === e ? void 0 : h.id);
+    for (const w of p.children ?? []) S(w, p === e ? void 0 : p.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],
+  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,
@@ -459,82 +422,82 @@ function Ee(e, t) {
         })
       );
     }
-    for (const b of h.children ?? []) $(b);
+    for (const b of p.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 $(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 {
-      ...l,
-      ...l === e ? {
+      ...c,
+      ...c === 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 } : {}
+      } : { x: y.x - d.x, y: y.y - d.y, width: g?.width, height: g?.height },
+      ...S ? { children: S } : {}
     };
-  }, 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);
+  }, 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);
   };
-  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;
+  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 {
-          ...a,
+          ...d,
           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
+          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
           })),
-          ...a.labels?.length && $ ? {
-            labels: a.labels.map(
-              (h, b) => b ? h : { ...h, ...w($), width: $.width, height: $.height }
+          ...d.labels?.length && $ ? {
+            labels: d.labels.map(
+              (p, b) => b ? p : { ...p, ...S($), width: $.width, height: $.height }
             )
           } : {}
         };
       })
     } : {},
-    ...l.children ? { children: l.children.map(i) } : {}
+    ...c.children ? { children: c.children.map(i) } : {}
   });
-  return i(r);
+  return i(s);
 }
-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 };
+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 Le {
+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, n = {}) {
-    const { elk: o, result: s } = await ie(t, {
+  async layout(t, r = {}) {
+    const { elk: o, result: n } = await oe(t, {
       ...this.options.defaultLayoutOptions,
-      ...n.layoutOptions
+      ...r.layoutOptions
     });
-    return this.warnings = s.warnings, o;
+    return this.warnings = n.warnings, o;
   }
   knownLayoutAlgorithms() {
     return Promise.resolve([{ id: "draftably.flow", name: "Draftably flow" }]);
@@ -543,127 +506,127 @@ class Le {
   }
 }
 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 = {
+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: 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) => ({
+    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: n.filter((i) => !s.has(i)).map((i) => {
-      const l = e.node(i) ?? {};
+    nodes: r.filter((i) => !n.has(i)).map((i) => {
+      const c = e.node(i) ?? {};
       return {
         id: i,
-        label: q(l.label) ?? i,
+        label: q(c.label) ?? i,
         parent: o(i),
-        ...v(l.width) ? { width: v(l.width) } : {},
-        ...v(l.height) ? { height: v(l.height) } : {}
+        ...v(c.width) ? { width: v(c.width) } : {},
+        ...v(c.height) ? { height: v(c.height) } : {}
       };
     }),
-    edges: p.map((i) => ({
-      id: c(i),
+    edges: u.map((i) => ({
+      id: l(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
+  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 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 } : {}
+  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(d, { width: f.bounds.width, height: f.bounds.height }), f;
+  return Object.assign(a, { width: h.bounds.width, height: h.bounds.height }), h;
 }
-function z(e) {
+function D(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 = {
+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((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()
+    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((r) => ({
-      id: r.id(),
-      source: r.source().id(),
-      target: r.target().id(),
-      label: typeof r.data("label") == "string" ? r.data("label") : void 0
+    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
     }))
-  }, 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 };
+  }, 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;
 };
-z.prototype.stop = function() {
+D.prototype.stop = function() {
   return this;
 };
-function qe(e) {
-  e("layout", "draftably", z);
+function Fe(e) {
+  e("layout", "draftably", D);
 }
-async function Fe(e) {
+async function Ne(e) {
   if ("elk" in e) {
-    const { elk: t, ...n } = e;
-    return ie(t, void 0, n);
+    const { elk: t, ...r } = e;
+    return oe(t, void 0, r);
   }
   for (const t of ["reactFlow", "svelteFlow"])
     if (t in e) {
       const {
-        [t]: n,
+        [t]: r,
         shape: o,
-        ...s
-      } = e, d = await T({ ...Y(n, { shape: o }), ...s });
-      return { [t]: me(n, d, t === "svelteFlow"), result: d };
+        ...n
+      } = e, a = await T({ ...X(r, { shape: o }), ...n });
+      return { [t]: me(r, a, t === "svelteFlow"), result: a };
     }
   return T(e);
 }
-function Ne(e) {
+function Pe(e) {
   for (const t of ["reactFlow", "svelteFlow"])
     if (t in e) {
       const {
-        [t]: n,
+        [t]: r,
         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 };
+        routing: n
+      } = e, a = U({ ...Se(r, { shape: o }), routing: n });
+      return { [t]: { nodes: r.nodes, edges: ke(r.edges, a) }, result: a };
     }
-  return W(e);
+  return U(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
+  je as DraftablyELK,
+  qe as dagreLayout,
+  Fe as draftablyLayout,
+  Ne as layout,
+  J as layoutSync,
+  Pe as route
 };