@draftably/editor 0.4.0 → 0.5.0

package/dist/assets/{engine.worker-C6o2x40z.js → engine.worker-BDrPGHQt.js}

@@ -207,8 +207,8 @@ function Vn(t, e, o = {}) {
     if (m.has(g)) continue;
     const y = [], P = [g];
     m.add(g);
-    for (let A = 0; A < P.length; A++) {
-      const w = P[A];
+    for (let O = 0; O < P.length; O++) {
+      const w = P[O];
       y.push(w);
       for (const k of d.get(w))
         m.has(k) || (m.add(k), P.push(k));
@@ -288,49 +288,49 @@ function ds(t, e, o, n) {
   if (o.mode === "rebuild" || o.ordering === "crossings") {
     const m = o.mode === "rebuild" ? e.declared : null, g = m ? c.map(
       (y) => y.slice().sort(
-        (P, A) => (m.get(P) ?? 1 / 0) - (m.get(A) ?? 1 / 0) || ke(P, A)
+        (P, O) => (m.get(P) ?? 1 / 0) - (m.get(O) ?? 1 / 0) || ke(P, O)
       )
     ) : null;
     for (let y = 0; y < 10; y++) {
-      const P = y % 2 === 0, A = P ? [...c.keys()] : [...c.keys()].reverse();
-      for (const w of A) {
-        const k = P ? e.inc : e.out, T = (F) => {
-          const j = k.get(F).filter(($) => P ? e.rank.get($) < w : e.rank.get($) > w);
-          return j.length ? j.reduce(($, v) => $ + u.get(v), 0) / j.length : u.get(F);
+      const P = y % 2 === 0, O = P ? [...c.keys()] : [...c.keys()].reverse();
+      for (const w of O) {
+        const k = P ? e.inc : e.out, F = (T) => {
+          const j = k.get(T).filter(($) => P ? e.rank.get($) < w : e.rank.get($) > w);
+          return j.length ? j.reduce(($, v) => $ + u.get(v), 0) / j.length : u.get(T);
         };
-        c[w].sort((F, j) => T(F) - T(j) || u.get(F) - u.get(j) || ke(F, j)), i();
+        c[w].sort((T, j) => F(T) - F(j) || u.get(T) - u.get(j) || ke(T, j)), i();
       }
     }
     if (g) {
       const y = fs(e, l(c.length).map), P = c.map((w) => w.slice());
       g.forEach((w, k) => c[k] = w);
-      const A = fs(e, l(c.length).map);
-      A - y >= Ei(A) && P.forEach((w, k) => c[k] = w), i();
+      const O = fs(e, l(c.length).map);
+      O - y >= Ei(O) && P.forEach((w, k) => c[k] = w), i();
     }
   }
   function l(m) {
     const g = /* @__PURE__ */ new Map();
     let y = 0;
     for (let w = 0; w < c.length; w += m) {
-      const k = Math.min(c.length, w + m), T = Math.max(...h.slice(w, k));
-      let F = 0;
+      const k = Math.min(c.length, w + m), F = Math.max(...h.slice(w, k));
+      let T = 0;
       for (let j = w; j < k; j++) {
-        let $ = y + (T - h[j]) / 2;
+        let $ = y + (F - h[j]) / 2;
         for (const v of c[j]) {
-          const S = a.get(v), M = F + f[j] / 2, x = $ + d(S) / 2;
+          const S = a.get(v), M = T + f[j] / 2, x = $ + d(S) / 2;
           g.set(v, s ? { x, y: M } : { x: M, y: x }), $ += d(S) + o.nodeGap;
         }
-        F += f[j] + o.rankGap;
+        T += f[j] + o.rankGap;
       }
-      y += T + Math.max(o.rankGap + 40, 84);
+      y += F + Math.max(o.rankGap + 40, 84);
     }
     const P = Ie(
       t.map((w) => {
         const k = g.get(w.id);
         return { ...w, x: k.x - w.w / 2, y: k.y - w.h / 2 };
       })
-    ), A = Math.abs(Math.log(P.w / P.h / n)) * 1.8 + Math.log(P.w * P.h) * 0.17 + (Math.ceil(c.length / m) - 1) * 0.16;
-    return { map: g, score: A };
+    ), O = Math.abs(Math.log(P.w / P.h / n)) * 1.8 + Math.log(P.w * P.h) * 0.17 + (Math.ceil(c.length / m) - 1) * 0.16;
+    return { map: g, score: O };
   }
   let p = l(c.length);
   if (o.fold === "auto")
@@ -361,7 +361,7 @@ function $a(t, e, o, n) {
   function u(m) {
     const g = a.kids.get(m), y = Math.max(
       c(m),
-      g.reduce((P, A) => P + u(A), 0) + Math.max(0, g.length - 1) * o.nodeGap
+      g.reduce((P, O) => P + u(O), 0) + Math.max(0, g.length - 1) * o.nodeGap
     );
     return d.set(m, y), y;
   }
@@ -379,10 +379,10 @@ function $a(t, e, o, n) {
   function l(m, g) {
     const y = g + d.get(m) / 2, P = f[a.depth.get(m)];
     h.set(m, r ? { x: y, y: P } : { x: P, y });
-    const A = a.kids.get(m), w = A.reduce((T, F) => T + d.get(F), 0) + Math.max(0, A.length - 1) * o.nodeGap;
+    const O = a.kids.get(m), w = O.reduce((F, T) => F + d.get(T), 0) + Math.max(0, O.length - 1) * o.nodeGap;
     let k = g + (d.get(m) - w) / 2;
-    for (const T of A)
-      l(T, k), k += d.get(T) + o.nodeGap;
+    for (const F of O)
+      l(F, k), k += d.get(F) + o.nodeGap;
   }
   let p = 0;
   for (const m of a.roots)
@@ -414,13 +414,13 @@ function Ii(t, e, o, n) {
   let f = 0;
   for (const l of a.roots) {
     let m = function(g, y, P) {
-      const A = (y + P) / 2 + (o.direction === "RIGHT" ? 0 : Math.PI / 2), w = c[a.depth.get(g)];
-      i.set(g, { x: p + Math.cos(A) * w, y: Math.sin(A) * w });
+      const O = (y + P) / 2 + (o.direction === "RIGHT" ? 0 : Math.PI / 2), w = c[a.depth.get(g)];
+      i.set(g, { x: p + Math.cos(O) * w, y: Math.sin(O) * w });
       const k = a.kids.get(g);
-      let T = y;
-      for (const F of k) {
-        const j = T + (P - y) * s.get(F) / s.get(g);
-        m(F, T, j), T = j;
+      let F = y;
+      for (const T of k) {
+        const j = F + (P - y) * s.get(T) / s.get(g);
+        m(T, F, j), F = j;
       }
     };
     var h = m;
@@ -429,7 +429,7 @@ function Ii(t, e, o, n) {
   }
   return i;
 }
-function Oi(t, e, o) {
+function Ai(t, e, o) {
   const n = So(t, e, o);
   if (e.mode === "rebuild") return n;
   const a = Ie(t), s = _t(a), r = Ie(
@@ -458,7 +458,7 @@ function Oi(t, e, o) {
   }
   return u;
 }
-function Tn(t, e, o, n, a = !1) {
+function Fn(t, e, o, n, a = !1) {
   const s = Ie(e), r = Ie(
     e.map((h) => {
       const l = t.get(h.id);
@@ -515,17 +515,17 @@ function hs(t, e, o) {
   if (!e.index.has(n)) return null;
   const a = Yo(t, e, { ...o, rootId: n }), s = new Map(t.map((w) => [w.id, w])), r = o.direction === "DOWN", d = (w) => r ? s.get(w).w : s.get(w).h, c = (w) => r ? s.get(w).h : s.get(w).w, u = /* @__PURE__ */ new Map();
   function i(w) {
-    const k = a.kids.get(w), T = Math.max(
+    const k = a.kids.get(w), F = Math.max(
       d(w),
-      k.reduce((F, j) => F + i(j), 0) + Math.max(0, k.length - 1) * o.nodeGap
+      k.reduce((T, j) => T + i(j), 0) + Math.max(0, k.length - 1) * o.nodeGap
     );
-    return u.set(w, T), T;
+    return u.set(w, F), F;
   }
   a.roots.forEach(i);
   const f = /* @__PURE__ */ new Map([[n, 0]]), h = { 1: [], "-1": [] }, l = { 1: 0, "-1": 0 };
   function p(w, k) {
     f.set(w, k);
-    for (const T of a.kids.get(w)) p(T, k);
+    for (const F of a.kids.get(w)) p(F, k);
   }
   for (const w of a.kids.get(n)) {
     const k = l[1] <= l[-1] ? 1 : -1;
@@ -539,27 +539,27 @@ function hs(t, e, o) {
   const y = [0];
   for (let w = 1; w < g.length; w++)
     y[w] = y[w - 1] + g[w - 1] / 2 + o.rankGap + g[w] / 2;
-  function P(w, k, T) {
-    const F = T * y[a.depth.get(w)], j = k + u.get(w) / 2;
-    m.set(w, r ? { x: j, y: F } : { x: F, y: j });
+  function P(w, k, F) {
+    const T = F * y[a.depth.get(w)], j = k + u.get(w) / 2;
+    m.set(w, r ? { x: j, y: T } : { x: T, y: j });
     const $ = a.kids.get(w), v = $.reduce((M, x) => M + u.get(x), 0) + Math.max(0, $.length - 1) * o.nodeGap;
     let S = k + (u.get(w) - v) / 2;
     for (const M of $)
-      P(M, S, T), S += u.get(M) + o.nodeGap;
+      P(M, S, F), S += u.get(M) + o.nodeGap;
   }
   for (const w of [1, -1]) {
     let k = -(l[w] - o.nodeGap) / 2;
-    for (const T of h[w])
-      P(T, k, w), k += u.get(T) + o.nodeGap;
+    for (const F of h[w])
+      P(F, k, w), k += u.get(F) + o.nodeGap;
   }
-  const A = t.filter((w) => !m.has(w.id));
-  if (A.length) {
-    const w = $a(A, Vn(A, e.edges), { ...o, rootId: "" }), k = Ie(
-      t.filter((T) => m.has(T.id)).map((T) => ({ ...T, x: m.get(T.id).x - T.w / 2, y: m.get(T.id).y - T.h / 2 }))
+  const O = t.filter((w) => !m.has(w.id));
+  if (O.length) {
+    const w = $a(O, Vn(O, e.edges), { ...o, rootId: "" }), k = Ie(
+      t.filter((F) => m.has(F.id)).map((F) => ({ ...F, x: m.get(F.id).x - F.w / 2, y: m.get(F.id).y - F.h / 2 }))
     );
-    for (const T of A) {
-      const F = w.get(T.id);
-      m.set(T.id, { x: F.x, y: F.y + k.y + k.h + o.rankGap });
+    for (const F of O) {
+      const T = w.get(F.id);
+      m.set(F.id, { x: T.x, y: T.y + k.y + k.h + o.rankGap });
     }
   }
   return e.branchSides = f, m;
@@ -618,7 +618,7 @@ function us(t, e, o, n, a, s) {
     }
   return c;
 }
-async function Ai(t, e = {}) {
+async function Oi(t, e = {}) {
   const o = Date.now(), n = Pn(t), a = Pn(t.layout.nodes), s = La({ ...t.settings, ...e });
   n.layout.intent = Ga(
     n.layout.intent || {},
@@ -635,26 +635,26 @@ async function Ai(t, e = {}) {
   }, p = (E) => f(E).flatMap((L) => [L.id, ...c.has(L.id) ? p(L.id) : []]), m = new Map(n.graph.nodes.map((E, L) => [E.id, L])), g = new Set(e.fixedIds || []), y = (E) => g.has(E) || !!i[E]?.pinned || s.respectManual && !!i[E]?.manual, P = (E) => {
     for (let L = E; L; L = h(L)) if (y(L)) return !0;
     return !1;
-  }, A = (E) => P(E) || c.has(E) && p(E).some(y), w = (E) => {
+  }, O = (E) => P(E) || c.has(E) && p(E).some(y), w = (E) => {
     for (let L = h(E); L; L = h(L)) if (n.collapsed.includes(L)) return !1;
     return !0;
   }, k = (E) => {
     const L = i[E];
     return n.collapsed.includes(E) ? { ...L, w: Math.min(L.w, 210), h: 58 } : L;
-  }, T = /* @__PURE__ */ new Set();
-  let F = 0, j = 0;
+  }, F = /* @__PURE__ */ new Set();
+  let T = 0, j = 0;
   const $ = [], v = s.aspect === "canvas" ? Me((e.viewport?.w || 1200) / (e.viewport?.h || 760), 0.5, 3) : Number(s.aspect), S = e.scope || "all", M = (e.selected || []).filter((E) => u.has(E));
   if (!["all", "selection", "container", "neighbourhood"].includes(S))
     throw Error("Invalid layout scope.");
   function x(E, L, R) {
-    if (A(E) || !Number.isFinite(L) || !Number.isFinite(R)) return;
+    if (O(E) || !Number.isFinite(L) || !Number.isFinite(R)) return;
     const Z = [E, ...c.has(E) ? p(E) : []];
     let V = 1;
     if (s.mode === "pass") {
       const G = L * L + R * R;
       if (G < 1e-16) return;
       for (const X of Z) {
-        const D = i[X], ct = a[X], B = D.x - ct.x, rt = D.y - ct.y, lt = 2 * (B * L + rt * R), kt = B * B + rt * rt - s.maxMove * s.maxMove, vt = lt * lt - 4 * G * kt;
+        const D = i[X], ct = a[X], q = D.x - ct.x, rt = D.y - ct.y, lt = 2 * (q * L + rt * R), kt = q * q + rt * rt - s.maxMove * s.maxMove, vt = lt * lt - 4 * G * kt;
         V = Math.min(V, Me((-lt + Math.sqrt(Math.max(0, vt))) / (2 * G), 0, 1));
       }
     }
@@ -662,7 +662,7 @@ async function Ai(t, e = {}) {
       i[G].x += L * V, i[G].y += R * V;
   }
   function N(E) {
-    if (!s.growContainers || A(E) || !f(E).length) return;
+    if (!s.growContainers || O(E) || !f(E).length) return;
     const L = Ie(f(E).map((X) => i[X.id])), R = i[E], Z = n.layout.containers[E]?.padding || 24, V = Math.max(R.x + R.w, L.x + L.w + Z), G = Math.max(R.y + R.h, L.y + L.h + Z);
     R.w = V - R.x, R.h = G - R.y;
   }
@@ -674,8 +674,8 @@ async function Ai(t, e = {}) {
       const X = f(G).filter((D) => w(D.id));
       for (let D = 0; D < X.length; D++)
         for (let ct = D + 1; ct < X.length; ct++) {
-          const B = yn(k(X[D].id), k(X[ct].id));
-          B && (E++, L += B.area);
+          const q = yn(k(X[D].id), k(X[ct].id));
+          q && (E++, L += q.area);
         }
     }
     const Z = Ie(R.map((G) => k(G.id)));
@@ -683,8 +683,8 @@ async function Ai(t, e = {}) {
     for (const G of n.graph.edges) {
       const X = i[G.from], D = i[G.to];
       if (X && D) {
-        const ct = _t(X), B = _t(D);
-        V += ge(ct.x - B.x, ct.y - B.y);
+        const ct = _t(X), q = _t(D);
+        V += ge(ct.x - q.x, ct.y - q.y);
       }
     }
     return {
@@ -706,8 +706,8 @@ async function Ai(t, e = {}) {
     if (!L) {
       for (const G of u.values())
         if (h(G.id) && w(G.id)) {
-          const X = i[G.id], D = i[h(G.id)], ct = n.layout.containers[h(G.id)]?.padding || 24, B = a[G.id], rt = a[h(G.id)], lt = (kt, vt) => Math.max(0, vt.x + ct - kt.x) + Math.max(0, vt.y + ct + 28 - kt.y) + Math.max(0, kt.x + kt.w - (vt.x + vt.w - ct)) + Math.max(0, kt.y + kt.h - (vt.y + vt.h - ct));
-          if (lt(X, D) > lt(B, rt) + 0.01) return;
+          const X = i[G.id], D = i[h(G.id)], ct = n.layout.containers[h(G.id)]?.padding || 24, q = a[G.id], rt = a[h(G.id)], lt = (kt, vt) => Math.max(0, vt.x + ct - kt.x) + Math.max(0, vt.y + ct + 28 - kt.y) + Math.max(0, kt.x + kt.w - (vt.x + vt.w - ct)) + Math.max(0, kt.y + kt.h - (vt.y + vt.h - ct));
+          if (lt(X, D) > lt(q, rt) + 0.01) return;
         }
     }
     const Z = it.at(-1), V = Z ? Math.max(
@@ -735,7 +735,7 @@ async function Ai(t, e = {}) {
     n.graph.nodes.map((E) => ({ ...E, ...i[E.id] })),
     C,
     s
-  ), C.feedback.size && T.add(
+  ), C.feedback.size && F.add(
     C.feedback.size + " feedback edge(s) remain visible; cyclic edges cannot all follow one direction."
   );
   let _ = 0;
@@ -743,17 +743,17 @@ async function Ai(t, e = {}) {
   function b(E, L) {
     if (E && P(E)) return;
     n.layout.containers[E]?.direction;
-    const R = f(E).filter((B) => w(B.id)).map((B) => ({ id: B.id, ...k(B.id), fixed: A(B.id) }));
+    const R = f(E).filter((q) => w(q.id)).map((q) => ({ id: q.id, ...k(q.id), fixed: O(q.id) }));
     if (!R.length) return;
-    const Z = E ? i[E] : null, V = n.layout.containers[E]?.padding || 24, G = Z ? { x: Z.x + V, y: Z.y + V + 28, w: Z.w - 2 * V, h: Z.h - 2 * V - 28 } : null, X = { ...s, fold: s.respectDirection ? "never" : s.fold }, D = G ? Math.max(0.3, G.w / Math.max(1, G.h)) : v, ct = Tn(So(R, X, D), R, G, X, !0);
-    for (const B of R) {
-      if (B.fixed) continue;
-      const rt = ct.get(B.id);
-      let lt = rt.x - B.w / 2, kt = rt.y - B.h / 2;
-      G && !s.growContainers && (B.w <= G.w && (lt = Me(lt, G.x, G.x + G.w - B.w)), B.h <= G.h && (kt = Me(kt, G.y, G.y + G.h - B.h))), x(B.id, lt - i[B.id].x, kt - i[B.id].y);
+    const Z = E ? i[E] : null, V = n.layout.containers[E]?.padding || 24, G = Z ? { x: Z.x + V, y: Z.y + V + 28, w: Z.w - 2 * V, h: Z.h - 2 * V - 28 } : null, X = { ...s, fold: s.respectDirection ? "never" : s.fold }, D = G ? Math.max(0.3, G.w / Math.max(1, G.h)) : v, ct = Fn(So(R, X, D), R, G, X, !0);
+    for (const q of R) {
+      if (q.fixed) continue;
+      const rt = ct.get(q.id);
+      let lt = rt.x - q.w / 2, kt = rt.y - q.h / 2;
+      G && !s.growContainers && (q.w <= G.w && (lt = Me(lt, G.x, G.x + G.w - q.w)), q.h <= G.h && (kt = Me(kt, G.y, G.y + G.h - q.h))), x(q.id, lt - i[q.id].x, kt - i[q.id].y);
     }
-    for (const B of R)
-      c.has(B.id) && !n.collapsed.includes(B.id) && b(B.id);
+    for (const q of R)
+      c.has(q.id) && !n.collapsed.includes(q.id) && b(q.id);
   }
   if (J && s.mode === "rebuild" && !e.warmStart) {
     if (S === "all") b(null, s.direction);
@@ -764,61 +764,61 @@ async function Ai(t, e = {}) {
   }
   async function Y(E, L, R) {
     if (!E.length) return;
-    F++;
-    const Z = f(L).filter((q) => w(q.id)), V = new Set(E), G = new Set(Z.map((q) => q.id)), X = (q) => {
-      for (let st = q; st; st = h(st)) if (G.has(st)) return st;
+    T++;
+    const Z = f(L).filter((B) => w(B.id)), V = new Set(E), G = new Set(Z.map((B) => B.id)), X = (B) => {
+      for (let st = B; st; st = h(st)) if (G.has(st)) return st;
       return null;
-    }, D = Z.map((q) => ({
-      id: q.id,
-      ...k(q.id),
-      fixed: !V.has(q.id) || A(q.id)
+    }, D = Z.map((B) => ({
+      id: B.id,
+      ...k(B.id),
+      fixed: !V.has(B.id) || O(B.id)
     }));
-    if (D.every((q) => q.fixed)) return;
+    if (D.every((B) => B.fixed)) return;
     const ct = {};
-    for (const [q, st] of Object.entries(r)) {
+    for (const [B, st] of Object.entries(r)) {
       const dt = X(st.id);
-      dt && (ct[q] = { ...st, id: dt });
+      dt && (ct[B] = { ...st, id: dt });
     }
     ct.start?.id === ct.end?.id && delete ct.end;
-    const B = {
+    const q = {
       ...s,
       direction: R,
       rootId: ct.start?.id || X(s.rootId) || "",
       fold: s.respectDirection ? "never" : s.fold
-    }, rt = n.graph.edges.map((q) => ({ from: X(q.from), to: X(q.to), directed: q.directed !== !1 })).filter((q) => q.from && q.to && q.from !== q.to), lt = Vn(D, rt, ct);
-    e.orderPrior !== !1 && s.algorithm === "layered" && !L && !D.some((q) => c.has(q.id)) && (lt.declared = new Map(D.map((q) => [q.id, m.get(q.id) ?? 1 / 0])));
-    const kt = J ? n.graph.edges.map((q) => ({ ...q, a: X(q.from), b: X(q.to) })).filter((q) => (q.a || q.b) && q.a !== q.b) : [], vt = (q) => {
-      const st = c.has(q) ? p(q).filter((dt) => !c.has(dt)) : [q];
+    }, rt = n.graph.edges.map((B) => ({ from: X(B.from), to: X(B.to), directed: B.directed !== !1 })).filter((B) => B.from && B.to && B.from !== B.to), lt = Vn(D, rt, ct);
+    e.orderPrior !== !1 && s.algorithm === "layered" && !L && !D.some((B) => c.has(B.id)) && (lt.declared = new Map(D.map((B) => [B.id, m.get(B.id) ?? 1 / 0])));
+    const kt = J ? n.graph.edges.map((B) => ({ ...B, a: X(B.from), b: X(B.to) })).filter((B) => (B.a || B.b) && B.a !== B.b) : [], vt = (B) => {
+      const st = c.has(B) ? p(B).filter((dt) => !c.has(dt)) : [B];
       return st.length ? Math.min(...st.map((dt) => C.rank.get(dt) || 0)) : 0;
     };
     if (s.algorithm === "compound-flow") {
-      const q = [...new Set(D.map((dt) => vt(dt.id)))].sort((dt, gt) => dt - gt);
+      const B = [...new Set(D.map((dt) => vt(dt.id)))].sort((dt, gt) => dt - gt);
       for (const dt of D)
-        lt.rank.set(dt.id, Math.max(lt.rank.get(dt.id) || 0, q.indexOf(vt(dt.id))));
+        lt.rank.set(dt.id, Math.max(lt.rank.get(dt.id) || 0, B.indexOf(vt(dt.id))));
       const st = [...new Set(lt.rank.values())].sort((dt, gt) => dt - gt);
       for (const [dt, gt] of lt.rank) lt.rank.set(dt, st.indexOf(gt));
-      B.rankGap = Math.max(s.rankGap, D.some((dt) => c.has(dt.id)) ? s.groupGap : 0);
+      q.rankGap = Math.max(s.rankGap, D.some((dt) => c.has(dt.id)) ? s.groupGap : 0);
     }
-    const Ot = (q, st) => J && (c.has(q.id) || c.has(st.id)) ? s.groupGap : s.nodeGap;
-    J && (B._compoundEnergy = () => {
-      let q = 0;
+    const At = (B, st) => J && (c.has(B.id) || c.has(st.id)) ? s.groupGap : s.nodeGap;
+    J && (q._compoundEnergy = () => {
+      let B = 0;
       const st = R === "DOWN";
       for (const dt of kt) {
         const gt = i[dt.from], bt = i[dt.to];
         if (!gt || !bt) continue;
-        const It = _t(gt), Ct = _t(bt), ut = Ct.x - It.x, tt = Ct.y - It.y, yt = st ? ut : tt, At = ge(ut, tt), Lt = h(dt.from) !== h(dt.to) || !dt.a || !dt.b ? s.boundaryPull / 100 : 0.35, Pt = s.edgeLength + (Math.hypot(gt.w, gt.h) + Math.hypot(bt.w, bt.h)) / 4;
-        s.algorithm === "boundary-align" ? q += yt * yt * (0.025 + s.alignment / 100 * 0.06) * Lt + (At - Pt) ** 2 * 1e-3 * Lt : q += (At - Pt) ** 2 * 8e-3 * Lt, s.algorithm === "compound-flow" && (q += yt * yt * 0.01 * Lt);
+        const It = _t(gt), Ct = _t(bt), ut = Ct.x - It.x, tt = Ct.y - It.y, yt = st ? ut : tt, Ot = ge(ut, tt), Lt = h(dt.from) !== h(dt.to) || !dt.a || !dt.b ? s.boundaryPull / 100 : 0.35, Pt = s.edgeLength + (Math.hypot(gt.w, gt.h) + Math.hypot(bt.w, bt.h)) / 4;
+        s.algorithm === "boundary-align" ? B += yt * yt * (0.025 + s.alignment / 100 * 0.06) * Lt + (Ot - Pt) ** 2 * 1e-3 * Lt : B += (Ot - Pt) ** 2 * 8e-3 * Lt, s.algorithm === "compound-flow" && (B += yt * yt * 0.01 * Lt);
       }
-      return q;
+      return B;
     });
-    const Et = L ? i[L] : null, Ft = n.layout.containers[L]?.padding || 24, St = Et ? { x: Et.x + Ft, y: Et.y + Ft + 28, w: Et.w - Ft * 2, h: Et.h - Ft * 2 - 28 } : null, Qt = St ? Math.max(0.3, St.w / Math.max(1, St.h)) : v;
+    const Et = L ? i[L] : null, Tt = n.layout.containers[L]?.padding || 24, St = Et ? { x: Et.x + Tt, y: Et.y + Tt + 28, w: Et.w - Tt * 2, h: Et.h - Tt * 2 - 28 } : null, Qt = St ? Math.max(0.3, St.w / Math.max(1, St.h)) : v;
     let Dt = null;
-    (s.algorithm === "layered" || s.algorithm === "compound-flow") && (Dt = ds(D, lt, B, Qt)), s.algorithm === "tree" && (Dt = $a(D, lt, B)), s.algorithm === "radial" && (Dt = Ii(D, lt, B)), s.algorithm === "grid" && (Dt = Oi(D, B, Qt));
-    const ne = ct.start?.placement === "center" && s.algorithm !== "separate" ? hs(D, lt, B) : null;
-    if (ne && ["tree", "layered", "compound-flow"].includes(s.algorithm) && (Dt = ne), Dt && !(s.algorithm === "grid" && s.mode === "pass") && Tn(Dt, D, St, s, s.mode === "rebuild" && !e.warmStart), s.mode === "rebuild" && !e.warmStart && s.algorithm !== "separate" && (!J || !W.has(L))) {
+    (s.algorithm === "layered" || s.algorithm === "compound-flow") && (Dt = ds(D, lt, q, Qt)), s.algorithm === "tree" && (Dt = $a(D, lt, q)), s.algorithm === "radial" && (Dt = Ii(D, lt, q)), s.algorithm === "grid" && (Dt = Ai(D, q, Qt));
+    const ne = ct.start?.placement === "center" && s.algorithm !== "separate" ? hs(D, lt, q) : null;
+    if (ne && ["tree", "layered", "compound-flow"].includes(s.algorithm) && (Dt = ne), Dt && !(s.algorithm === "grid" && s.mode === "pass") && Fn(Dt, D, St, s, s.mode === "rebuild" && !e.warmStart), s.mode === "rebuild" && !e.warmStart && s.algorithm !== "separate" && (!J || !W.has(L))) {
       W.add(L);
-      const q = Dt || (ne ? Tn(ne, D, St, s, !0) : null) || Tn(
-        s.respectDirection && lt.forward.length ? ds(D, lt, { ...B, fold: "never" }, Qt) : So(D, s, Qt),
+      const B = Dt || (ne ? Fn(ne, D, St, s, !0) : null) || Fn(
+        s.respectDirection && lt.forward.length ? ds(D, lt, { ...q, fold: "never" }, Qt) : So(D, s, Qt),
         D,
         St,
         s,
@@ -826,32 +826,32 @@ async function Ai(t, e = {}) {
       );
       for (const st of D)
         if (!st.fixed) {
-          const dt = q.get(st.id);
+          const dt = B.get(st.id);
           let gt = dt.x - st.w / 2, bt = dt.y - st.h / 2;
           St && !s.growContainers && (st.w <= St.w && (gt = Me(gt, St.x, St.x + St.w - st.w)), st.h <= St.h && (bt = Me(bt, St.y, St.y + St.h - st.h))), x(st.id, gt - i[st.id].x, bt - i[st.id].y);
         }
     }
-    const Gt = () => D.forEach((q) => {
-      q.x = i[q.id].x, q.y = i[q.id].y;
+    const Gt = () => D.forEach((B) => {
+      B.x = i[B.id].x, B.y = i[B.id].y;
     });
     Gt();
-    const Yt = new Map(D.map((q) => [q.id, _t(q)])), Kt = new Map(D.map((q) => [q.id, q])), ae = new Map(D.map((q) => [q.id, { x: 0, y: 0 }])), Rt = s.algorithm === "stress" ? Si(lt) : null, Xt = Ie(D), te = _t(Xt), Ht = s.mode === "pass" ? (s.stability / 100) ** 2 * 0.18 : 0, oe = e.settle ? Me(Math.round(e.maxIterations || 640), 80, 1200) : s.mode === "rebuild" ? Math.max(80, s.iterations * 3) : s.iterations;
-    let Bt = 0, le = 0, fe = "iteration limit", de = 0;
-    const he = (q, st, dt) => {
-      q.fixed || (St && !s.growContainers && (q.w <= St.w ? st = Me(q.x + st, St.x, St.x + St.w - q.w) - q.x : (T.add("A child is wider than its container. Resize the frame or allow growth."), st = 0), q.h <= St.h ? dt = Me(q.y + dt, St.y, St.y + St.h - q.h) - q.y : (T.add("A child is taller than its container. Resize the frame or allow growth."), dt = 0)), x(q.id, st, dt), q.x = i[q.id].x, q.y = i[q.id].y);
+    const Yt = new Map(D.map((B) => [B.id, _t(B)])), Kt = new Map(D.map((B) => [B.id, B])), ae = new Map(D.map((B) => [B.id, { x: 0, y: 0 }])), Rt = s.algorithm === "stress" ? Si(lt) : null, Xt = Ie(D), te = _t(Xt), Ht = s.mode === "pass" ? (s.stability / 100) ** 2 * 0.18 : 0, oe = e.settle ? Me(Math.round(e.maxIterations || 640), 80, 1200) : s.mode === "rebuild" ? Math.max(80, s.iterations * 3) : s.iterations;
+    let qt = 0, le = 0, fe = "iteration limit", de = 0;
+    const he = (B, st, dt) => {
+      B.fixed || (St && !s.growContainers && (B.w <= St.w ? st = Me(B.x + st, St.x, St.x + St.w - B.w) - B.x : (F.add("A child is wider than its container. Resize the frame or allow growth."), st = 0), B.h <= St.h ? dt = Me(B.y + dt, St.y, St.y + St.h - B.h) - B.y : (F.add("A child is taller than its container. Resize the frame or allow growth."), dt = 0)), x(B.id, st, dt), B.x = i[B.id].x, B.y = i[B.id].y);
     };
-    function we(q, st, dt) {
-      if (q.fixed) return 0;
+    function we(B, st, dt) {
+      if (B.fixed) return 0;
       let gt = 1 / 0;
       if (St && !s.growContainers) {
         const bt = st === "x" ? "w" : "h";
         gt = Math.max(
           0,
-          dt > 0 ? St[st] + St[bt] - q[st] - q[bt] : q[st] - St[st]
+          dt > 0 ? St[st] + St[bt] - B[st] - B[bt] : B[st] - St[st]
         );
       }
       if (s.mode === "pass")
-        for (const bt of [q.id, ...c.has(q.id) ? p(q.id) : []]) {
+        for (const bt of [B.id, ...c.has(B.id) ? p(B.id) : []]) {
           const It = i[bt], Ct = a[bt], ut = (It[st] - Ct[st]) * dt, tt = st === "x" ? It.y - Ct.y : It.x - Ct.x;
           gt = Math.min(
             gt,
@@ -860,67 +860,67 @@ async function Ai(t, e = {}) {
         }
       return gt;
     }
-    function I(q = 3) {
-      for (let st = 0; st < q; st++)
+    function I(B = 3) {
+      for (let st = 0; st < B; st++)
         for (let dt = 0; dt < D.length; dt++)
           for (let gt = dt + 1; gt < D.length; gt++) {
-            const bt = D[dt], It = D[gt], Ct = Ot(bt, It), ut = yn(bt, It, Ct);
+            const bt = D[dt], It = D[gt], Ct = At(bt, It), ut = yn(bt, It, Ct);
             if (!ut || bt.fixed && It.fixed) continue;
             const tt = [];
-            for (const qt of ["x", "y"])
+            for (const Bt of ["x", "y"])
               for (const zt of [1, -1]) {
-                const Jt = qt === "x" ? (bt.w + It.w) / 2 : (bt.h + It.h) / 2, Vt = qt === "x" ? ut.dx : ut.dy, jt = Jt + Ct - zt * Vt + 0.15, Zt = we(bt, qt, -zt), ee = we(It, qt, zt), se = Zt + ee, Ce = se >= jt - 1e-3, Ke = Math.min(1, se / jt);
-                tt.push({ axis: qt, sign: zt, need: jt, ca: Zt, cb: ee, available: se, feasible: Ce, coverage: Ke });
+                const Jt = Bt === "x" ? (bt.w + It.w) / 2 : (bt.h + It.h) / 2, Vt = Bt === "x" ? ut.dx : ut.dy, jt = Jt + Ct - zt * Vt + 0.15, Zt = we(bt, Bt, -zt), ee = we(It, Bt, zt), se = Zt + ee, Ce = se >= jt - 1e-3, Ke = Math.min(1, se / jt);
+                tt.push({ axis: Bt, sign: zt, need: jt, ca: Zt, cb: ee, available: se, feasible: Ce, coverage: Ke });
               }
             tt.sort(
-              (qt, zt) => Number(zt.feasible) - Number(qt.feasible) || (qt.feasible ? qt.need - zt.need : zt.coverage - qt.coverage) || qt.need - zt.need
+              (Bt, zt) => Number(zt.feasible) - Number(Bt.feasible) || (Bt.feasible ? Bt.need - zt.need : zt.coverage - Bt.coverage) || Bt.need - zt.need
             );
             const yt = tt[0];
             if (yt.available < 1e-3) continue;
-            const At = Math.min(yt.need, yt.available), Tt = Math.min(yt.ca, At / 2), Lt = Math.min(yt.cb, At - Tt), Pt = Math.min(yt.ca - Tt, At - Tt - Lt), $t = (Tt + Pt) * yt.sign, Nt = Lt * yt.sign;
+            const Ot = Math.min(yt.need, yt.available), Ft = Math.min(yt.ca, Ot / 2), Lt = Math.min(yt.cb, Ot - Ft), Pt = Math.min(yt.ca - Ft, Ot - Ft - Lt), $t = (Ft + Pt) * yt.sign, Nt = Lt * yt.sign;
             he(bt, yt.axis === "x" ? -$t : 0, yt.axis === "y" ? -$t : 0), he(It, yt.axis === "x" ? Nt : 0, yt.axis === "y" ? Nt : 0);
           }
     }
     const U = () => {
-      let q = 0, st = 0;
+      let B = 0, st = 0;
       for (let dt = 0; dt < D.length; dt++)
         for (let gt = dt + 1; gt < D.length; gt++) {
           const bt = yn(D[dt], D[gt]);
-          bt && (q++, st += bt.area);
+          bt && (B++, st += bt.area);
         }
-      return { n: q, a: st };
+      return { n: B, a: st };
     };
     let nt = {
-      coords: new Map(D.map((q) => [q.id, { x: q.x, y: q.y }])),
+      coords: new Map(D.map((B) => [B.id, { x: B.x, y: B.y }])),
       collisions: U(),
-      energy: us(D, lt, B, Rt, Dt)
+      energy: us(D, lt, q, Rt, Dt)
     };
-    for (let q = 0; q < oe; q++) {
+    for (let B = 0; B < oe; B++) {
       j++, de++;
-      const st = D.map((ut) => ({ x: ut.x, y: ut.y })), dt = new Map(D.map((ut) => [ut.id, { x: 0, y: 0, degree: 0 }])), gt = (ut, tt, yt, At = 1) => {
-        const Tt = dt.get(ut);
-        Tt.x += tt, Tt.y += yt, Tt.degree += At;
+      const st = D.map((ut) => ({ x: ut.x, y: ut.y })), dt = new Map(D.map((ut) => [ut.id, { x: 0, y: 0, degree: 0 }])), gt = (ut, tt, yt, Ot = 1) => {
+        const Ft = dt.get(ut);
+        Ft.x += tt, Ft.y += yt, Ft.degree += Ot;
       };
       if (s.algorithm === "stress")
         for (let ut = 0; ut < D.length; ut++)
           for (let tt = ut + 1; tt < D.length; tt++) {
-            const yt = D[ut], At = D[tt], Tt = Rt.get(yt.id).get(At.id);
-            if (!Tt) continue;
-            const Lt = _t(yt), Pt = _t(At);
-            let $t = Pt.x - Lt.x, Nt = Pt.y - Lt.y, qt = ge($t, Nt);
-            if (qt < 0.01) {
-              const jt = fo(yt.id + "|" + At.id) * Math.PI * 2;
-              $t = Math.cos(jt), Nt = Math.sin(jt), qt = 1;
+            const yt = D[ut], Ot = D[tt], Ft = Rt.get(yt.id).get(Ot.id);
+            if (!Ft) continue;
+            const Lt = _t(yt), Pt = _t(Ot);
+            let $t = Pt.x - Lt.x, Nt = Pt.y - Lt.y, Bt = ge($t, Nt);
+            if (Bt < 0.01) {
+              const jt = fo(yt.id + "|" + Ot.id) * Math.PI * 2;
+              $t = Math.cos(jt), Nt = Math.sin(jt), Bt = 1;
             }
-            const zt = Tt * (s.edgeLength + (yt.w + At.w + yt.h + At.h) / 8), Jt = 1 / (Tt * Tt), Vt = (qt - zt) / qt * Jt * 0.16;
-            gt(yt.id, $t * Vt, Nt * Vt, Jt), gt(At.id, -$t * Vt, -Nt * Vt, Jt);
+            const zt = Ft * (s.edgeLength + (yt.w + Ot.w + yt.h + Ot.h) / 8), Jt = 1 / (Ft * Ft), Vt = (Bt - zt) / Bt * Jt * 0.16;
+            gt(yt.id, $t * Vt, Nt * Vt, Jt), gt(Ot.id, -$t * Vt, -Nt * Vt, Jt);
           }
       else if (["tidy", "flow", "force"].includes(s.algorithm)) {
         for (const ut of lt.edges) {
-          const tt = Kt.get(ut.from), yt = Kt.get(ut.to), At = _t(tt), Tt = _t(yt);
-          let Lt = Tt.x - At.x, Pt = Tt.y - At.y, $t = ge(Lt, Pt);
+          const tt = Kt.get(ut.from), yt = Kt.get(ut.to), Ot = _t(tt), Ft = _t(yt);
+          let Lt = Ft.x - Ot.x, Pt = Ft.y - Ot.y, $t = ge(Lt, Pt);
           $t < 0.01 && (Lt = 1, Pt = 0.1, $t = 1.005);
-          const Nt = (Math.hypot(tt.w, tt.h) + Math.hypot(yt.w, yt.h)) / 4, qt = Nt + s.edgeLength, zt = s.algorithm === "force" ? $t * $t / qt * 0.022 : ($t - qt) * 0.09;
+          const Nt = (Math.hypot(tt.w, tt.h) + Math.hypot(yt.w, yt.h)) / 4, Bt = Nt + s.edgeLength, zt = s.algorithm === "force" ? $t * $t / Bt * 0.022 : ($t - Bt) * 0.09;
           if (gt(tt.id, Lt / $t * zt, Pt / $t * zt), gt(yt.id, -Lt / $t * zt, -Pt / $t * zt), s.algorithm === "tidy") {
             const Jt = Math.abs(Lt) < Math.abs(Pt), Vt = Jt ? Lt : Pt, jt = Math.max(s.nodeGap * 2, 24);
             if (Math.abs(Vt) < jt) {
@@ -936,32 +936,32 @@ async function Ai(t, e = {}) {
         if (s.algorithm === "force")
           for (let ut = 0; ut < D.length; ut++)
             for (let tt = ut + 1; tt < D.length; tt++) {
-              const yt = D[ut], At = D[tt], Tt = _t(yt), Lt = _t(At);
-              let Pt = Lt.x - Tt.x, $t = Lt.y - Tt.y, Nt = ge(Pt, $t);
+              const yt = D[ut], Ot = D[tt], Ft = _t(yt), Lt = _t(Ot);
+              let Pt = Lt.x - Ft.x, $t = Lt.y - Ft.y, Nt = ge(Pt, $t);
               if (Nt < 0.1) {
-                const Jt = fo(yt.id + At.id) * Math.PI * 2;
+                const Jt = fo(yt.id + Ot.id) * Math.PI * 2;
                 Pt = Math.cos(Jt), $t = Math.sin(Jt), Nt = 1;
               }
-              const qt = s.edgeLength + 80, zt = qt * qt / Math.max(Nt, 18) * s.repulsion / 100 * 0.015;
-              gt(yt.id, -Pt / Nt * zt, -$t / Nt * zt, 0), gt(At.id, Pt / Nt * zt, $t / Nt * zt, 0);
+              const Bt = s.edgeLength + 80, zt = Bt * Bt / Math.max(Nt, 18) * s.repulsion / 100 * 0.015;
+              gt(yt.id, -Pt / Nt * zt, -$t / Nt * zt, 0), gt(Ot.id, Pt / Nt * zt, $t / Nt * zt, 0);
             }
       }
       if (J)
         for (const ut of kt) {
           const tt = i[ut.from], yt = i[ut.to];
           if (!tt || !yt) continue;
-          const At = _t(tt), Tt = _t(yt);
-          let Lt = Tt.x - At.x, Pt = Tt.y - At.y, $t = ge(Lt, Pt);
+          const Ot = _t(tt), Ft = _t(yt);
+          let Lt = Ft.x - Ot.x, Pt = Ft.y - Ot.y, $t = ge(Lt, Pt);
           $t < 0.01 && (Lt = 1, Pt = 0.1, $t = 1);
-          const qt = h(ut.from) !== h(ut.to) || !ut.a || !ut.b ? s.boundaryPull / 100 : 0.35, zt = R === "DOWN", Jt = s.edgeLength + (Math.hypot(tt.w, tt.h) + Math.hypot(yt.w, yt.h)) / 4;
+          const Bt = h(ut.from) !== h(ut.to) || !ut.a || !ut.b ? s.boundaryPull / 100 : 0.35, zt = R === "DOWN", Jt = s.edgeLength + (Math.hypot(tt.w, tt.h) + Math.hypot(yt.w, yt.h)) / 4;
           let Vt = 0, jt = 0;
           if (s.algorithm === "boundary-align") {
-            const Zt = (zt ? Lt : Pt) * (0.04 + s.alignment / 100 * 0.16) * qt;
-            Vt = zt ? Zt : Lt / $t * ($t - Jt) * 8e-3 * qt, jt = zt ? Pt / $t * ($t - Jt) * 8e-3 * qt : Zt;
+            const Zt = (zt ? Lt : Pt) * (0.04 + s.alignment / 100 * 0.16) * Bt;
+            Vt = zt ? Zt : Lt / $t * ($t - Jt) * 8e-3 * Bt, jt = zt ? Pt / $t * ($t - Jt) * 8e-3 * Bt : Zt;
           } else {
-            const Zt = ($t - Jt) * 0.1 * qt;
+            const Zt = ($t - Jt) * 0.1 * Bt;
             if (Vt = Lt / $t * Zt, jt = Pt / $t * Zt, s.algorithm === "compound-flow") {
-              const ee = (zt ? Lt : Pt) * 0.055 * qt;
+              const ee = (zt ? Lt : Pt) * 0.055 * Bt;
               Vt += zt ? ee : 0, jt += zt ? 0 : ee;
             }
           }
@@ -969,25 +969,25 @@ async function Ai(t, e = {}) {
         }
       if (s.respectDirection && s.algorithm !== "separate")
         for (const ut of lt.forward) {
-          const tt = Kt.get(ut.from), yt = Kt.get(ut.to), At = R === "DOWN", Tt = _t(tt), Lt = _t(yt), Pt = (At ? tt.h + yt.h : tt.w + yt.w) / 2 + s.rankGap, $t = Pt - (At ? Lt.y - Tt.y : Lt.x - Tt.x);
+          const tt = Kt.get(ut.from), yt = Kt.get(ut.to), Ot = R === "DOWN", Ft = _t(tt), Lt = _t(yt), Pt = (Ot ? tt.h + yt.h : tt.w + yt.w) / 2 + s.rankGap, $t = Pt - (Ot ? Lt.y - Ft.y : Lt.x - Ft.x);
           if ($t <= 0) continue;
           const Nt = $t * (0.12 + s.flowStrength / 100 * 0.65);
-          gt(tt.id, At ? 0 : -Nt, At ? -Nt : 0, 0), gt(yt.id, At ? 0 : Nt, At ? Nt : 0, 0);
+          gt(tt.id, Ot ? 0 : -Nt, Ot ? -Nt : 0, 0), gt(yt.id, Ot ? 0 : Nt, Ot ? Nt : 0, 0);
         }
       if (Dt)
         for (const ut of D) {
-          const tt = _t(ut), yt = Dt.get(ut.id), At = s.algorithm === "grid" ? 0.018 + s.gridStrength / 100 * 0.16 : 0.18;
-          gt(ut.id, (yt.x - tt.x) * At, (yt.y - tt.y) * At);
+          const tt = _t(ut), yt = Dt.get(ut.id), Ot = s.algorithm === "grid" ? 0.018 + s.gridStrength / 100 * 0.16 : 0.18;
+          gt(ut.id, (yt.x - tt.x) * Ot, (yt.y - tt.y) * Ot);
         }
       if (s.algorithm !== "separate") {
-        const ut = Ie(D), tt = _t(ut), yt = ut.w / ut.h, At = Me(Math.log(yt / Qt), -2, 2);
-        for (const Tt of D) {
-          const Lt = _t(Tt), Pt = Yt.get(Tt.id), $t = dt.get(Tt.id), Nt = Math.max(1, Math.sqrt($t.degree));
+        const ut = Ie(D), tt = _t(ut), yt = ut.w / ut.h, Ot = Me(Math.log(yt / Qt), -2, 2);
+        for (const Ft of D) {
+          const Lt = _t(Ft), Pt = Yt.get(Ft.id), $t = dt.get(Ft.id), Nt = Math.max(1, Math.sqrt($t.degree));
           if ($t.x /= Nt, $t.y /= Nt, $t.x += (Pt.x - Lt.x) * Ht, $t.y += (Pt.y - Lt.y) * Ht, !["flow", "tree", "radial", "layered", "compound-flow", "boundary-align"].includes(
             s.algorithm
           )) {
-            const qt = s.compactness / 100 * 0.016;
-            $t.x += (te.x - Lt.x) * qt - (Lt.x - tt.x) * At * qt, $t.y += (te.y - Lt.y) * qt + (Lt.y - tt.y) * At * qt, ["stress", "force"].includes(s.algorithm) && Math.abs(Lt.y - tt.y) < 0.01 && At > 0.8 && ($t.y += (fo(Tt.id) - 0.5) * s.nodeGap * 0.025);
+            const Bt = s.compactness / 100 * 0.016;
+            $t.x += (te.x - Lt.x) * Bt - (Lt.x - tt.x) * Ot * Bt, $t.y += (te.y - Lt.y) * Bt + (Lt.y - tt.y) * Ot * Bt, ["stress", "force"].includes(s.algorithm) && Math.abs(Lt.y - tt.y) < 0.01 && Ot > 0.8 && ($t.y += (fo(Ft.id) - 0.5) * s.nodeGap * 0.025);
           }
         }
       }
@@ -998,47 +998,47 @@ async function Ai(t, e = {}) {
         }
       for (const ut of D) {
         if (ut.fixed) continue;
-        const tt = dt.get(ut.id), yt = ae.get(ut.id), At = s.mode === "pass" ? Math.max(1, s.maxMove * 0.13) : Math.max(2, 32 * (1 - q / oe));
+        const tt = dt.get(ut.id), yt = ae.get(ut.id), Ot = s.mode === "pass" ? Math.max(1, s.maxMove * 0.13) : Math.max(2, 32 * (1 - B / oe));
         yt.x = yt.x * 0.28 + tt.x * 0.72, yt.y = yt.y * 0.28 + tt.y * 0.72;
-        const Tt = ge(yt.x, yt.y), Lt = Tt > At ? At / Tt : 1;
+        const Ft = ge(yt.x, yt.y), Lt = Ft > Ot ? Ot / Ft : 1;
         he(ut, yt.x * Lt, yt.y * Lt);
       }
       if (I(s.algorithm === "separate" ? 6 : 3), s.respectDirection && s.algorithm !== "separate")
         for (let ut = 0; ut < 2; ut++) {
           const tt = ut ? lt.forward.slice().reverse() : lt.forward;
           for (const yt of tt) {
-            const At = Kt.get(yt.from), Tt = Kt.get(yt.to), Lt = R === "DOWN", Pt = Lt ? "y" : "x", $t = (Lt ? At.h + Tt.h : At.w + Tt.w) / 2 + s.rankGap, Nt = vn(lt, yt);
+            const Ot = Kt.get(yt.from), Ft = Kt.get(yt.to), Lt = R === "DOWN", Pt = Lt ? "y" : "x", $t = (Lt ? Ot.h + Ft.h : Ot.w + Ft.w) / 2 + s.rankGap, Nt = vn(lt, yt);
             if (!Nt) continue;
-            const qt = $t - (_t(Tt)[Pt] - _t(At)[Pt]) * Nt;
-            if (qt <= 0.01) continue;
-            const zt = we(At, Pt, -Nt), Jt = we(Tt, Pt, Nt), Vt = qt * (s.mode === "pass" ? 0.4 : 0.95), jt = Math.min(zt, Jt < Vt / 2 ? Vt - Jt : Vt / 2), Zt = Math.min(Jt, Vt - jt);
-            he(At, Lt ? 0 : -jt * Nt, Lt ? -jt * Nt : 0), he(Tt, Lt ? 0 : Zt * Nt, Lt ? Zt * Nt : 0);
+            const Bt = $t - (_t(Ft)[Pt] - _t(Ot)[Pt]) * Nt;
+            if (Bt <= 0.01) continue;
+            const zt = we(Ot, Pt, -Nt), Jt = we(Ft, Pt, Nt), Vt = Bt * (s.mode === "pass" ? 0.4 : 0.95), jt = Math.min(zt, Jt < Vt / 2 ? Vt - Jt : Vt / 2), Zt = Math.min(Jt, Vt - jt);
+            he(Ot, Lt ? 0 : -jt * Nt, Lt ? -jt * Nt : 0), he(Ft, Lt ? 0 : Zt * Nt, Lt ? Zt * Nt : 0);
           }
         }
       I(2);
-      const bt = U(), It = us(D, lt, B, Rt, Dt);
+      const bt = U(), It = us(D, lt, q, Rt, Dt);
       if (bt.n < nt.collisions.n || bt.n === nt.collisions.n && (bt.a < nt.collisions.a - 0.1 || Math.abs(bt.a - nt.collisions.a) < 0.1 && (It < nt.energy - 1e-3 || s.algorithm === "separate")) ? (nt = {
         coords: new Map(D.map((ut) => [ut.id, { x: ut.x, y: ut.y }])),
         collisions: bt,
         energy: It
-      }, le = 0) : le++, Bt = Math.max(
+      }, le = 0) : le++, qt = Math.max(
         ...D.map((ut, tt) => ge(ut.x - st[tt].x, ut.y - st[tt].y)),
         0
-      ) < (e.tolerance || 0.08) ? Bt + 1 : 0, e.settle && q >= 40 && (Bt >= 12 || le >= 80)) {
-        fe = Bt >= 12 ? "settled" : "objective plateau";
+      ) < (e.tolerance || 0.08) ? qt + 1 : 0, e.settle && B >= 40 && (qt >= 12 || le >= 80)) {
+        fe = qt >= 12 ? "settled" : "objective plateau";
         break;
       }
-      q % 4 === 3 && H(
+      B % 4 === 3 && H(
         "Refining " + (L ? c.get(L)?.title || "container" : "diagram")
-      ), q % 12 === 11 && await ki();
+      ), B % 12 === 11 && await ki();
     }
     $.push({ parentId: L, iterations: de, reason: fe });
-    for (const q of D) {
-      const st = nt.coords.get(q.id);
-      x(q.id, st.x - i[q.id].x, st.y - i[q.id].y);
+    for (const B of D) {
+      const st = nt.coords.get(B.id);
+      x(B.id, st.x - i[B.id].x, st.y - i[B.id].y);
     }
     if (Gt(), s.algorithm !== "separate")
-      for (let q = 0; q < 4; q++)
+      for (let B = 0; B < 4; B++)
         for (const [st, dt] of Un(D, ct)) {
           const gt = Kt.get(st);
           if (!gt || gt.fixed) continue;
@@ -1051,11 +1051,11 @@ async function Ai(t, e = {}) {
           }
         }
     if (nt.collisions.n && s.mode === "rebuild" && St && !s.growContainers && D.length <= 24) {
-      const q = D.filter((bt) => !bt.fixed), st = D.filter((bt) => bt.fixed), dt = [
-        [...q].sort((bt, It) => It.w * It.h - bt.w * bt.h || ke(bt.id, It.id)),
-        [...q].sort((bt, It) => ke(bt.id, It.id)),
-        [...q].sort((bt, It) => It.h - bt.h || It.w - bt.w || ke(bt.id, It.id)),
-        [...q].sort((bt, It) => ke(It.id, bt.id))
+      const B = D.filter((bt) => !bt.fixed), st = D.filter((bt) => bt.fixed), dt = [
+        [...B].sort((bt, It) => It.w * It.h - bt.w * bt.h || ke(bt.id, It.id)),
+        [...B].sort((bt, It) => ke(bt.id, It.id)),
+        [...B].sort((bt, It) => It.h - bt.h || It.w - bt.w || ke(bt.id, It.id)),
+        [...B].sort((bt, It) => ke(It.id, bt.id))
       ];
       let gt = null;
       for (const bt of dt) {
@@ -1066,26 +1066,26 @@ async function Ai(t, e = {}) {
             ut = !0;
             break;
           }
-          const yt = Dt?.get(tt.id) || _t(tt), At = /* @__PURE__ */ new Set([
+          const yt = Dt?.get(tt.id) || _t(tt), Ot = /* @__PURE__ */ new Set([
             St.x,
             St.x + St.w - tt.w,
             Me(yt.x - tt.w / 2, St.x, St.x + St.w - tt.w)
-          ]), Tt = /* @__PURE__ */ new Set([
+          ]), Ft = /* @__PURE__ */ new Set([
             St.y,
             St.y + St.h - tt.h,
             Me(yt.y - tt.h / 2, St.y, St.y + St.h - tt.h)
           ]);
           for (const Pt of It)
-            At.add(Pt.x + Pt.w + s.nodeGap + 0.2), At.add(Pt.x - tt.w - s.nodeGap - 0.2), Tt.add(Pt.y + Pt.h + s.nodeGap + 0.2), Tt.add(Pt.y - tt.h - s.nodeGap - 0.2);
+            Ot.add(Pt.x + Pt.w + s.nodeGap + 0.2), Ot.add(Pt.x - tt.w - s.nodeGap - 0.2), Ft.add(Pt.y + Pt.h + s.nodeGap + 0.2), Ft.add(Pt.y - tt.h - s.nodeGap - 0.2);
           let Lt = null;
-          for (const Pt of [...Tt].sort(($t, Nt) => $t - Nt))
-            for (const $t of [...At].sort((Nt, qt) => Nt - qt)) {
+          for (const Pt of [...Ft].sort(($t, Nt) => $t - Nt))
+            for (const $t of [...Ot].sort((Nt, Bt) => Nt - Bt)) {
               if ($t < St.x - 1e-3 || Pt < St.y - 1e-3 || $t + tt.w > St.x + St.w + 1e-3 || Pt + tt.h > St.y + St.h + 1e-3)
                 continue;
               const Nt = { ...tt, x: $t, y: Pt };
               if (It.some((zt) => yn(Nt, zt, s.nodeGap))) continue;
-              const qt = ($t + tt.w / 2 - yt.x) ** 2 + (Pt + tt.h / 2 - yt.y) ** 2;
-              (!Lt || qt < Lt.cost - 1e-3) && (Lt = { box: Nt, cost: qt });
+              const Bt = ($t + tt.w / 2 - yt.x) ** 2 + (Pt + tt.h / 2 - yt.y) ** 2;
+              (!Lt || Bt < Lt.cost - 1e-3) && (Lt = { box: Nt, cost: Bt });
             }
           if (!Lt) {
             ut = !0;
@@ -1100,12 +1100,12 @@ async function Ai(t, e = {}) {
       }
       if (gt) {
         for (const [bt, It] of gt) x(bt, It.x - i[bt].x, It.y - i[bt].y);
-        Gt(), T.add(
+        Gt(), F.add(
           'Used local packing inside "' + (c.get(L)?.title || L) + '" because the requested arrangement did not fit its fixed frame.'
         );
       }
     }
-    U().n && T.add(
+    U().n && F.add(
       "Some overlaps remain. Pins, fixed frames or the movement limit may prevent this pass from clearing them."
     ), L && N(L), H(
       "Finished " + (L ? c.get(L)?.title || "container" : "diagram"),
@@ -1156,7 +1156,7 @@ async function Ai(t, e = {}) {
   for (const [E, L] of Object.entries(i)) {
     const R = a[E];
     if (!R) continue;
-    if (A(E) || L.x === R.x && L.y === R.y) {
+    if (O(E) || L.x === R.x && L.y === R.y) {
       L.x = R.x, L.y = R.y;
       continue;
     }
@@ -1170,13 +1170,13 @@ async function Ai(t, e = {}) {
   for (const E of u.values())
     if (h(E.id) && w(E.id)) {
       const L = i[E.id], R = i[h(E.id)], Z = n.layout.containers[h(E.id)]?.padding || 24;
-      (L.x < R.x + Z - 0.01 || L.y < R.y + Z + 28 - 0.01 || L.x + L.w > R.x + R.w - Z + 0.01 || L.y + L.h > R.y + R.h - Z + 0.01) && T.add(
+      (L.x < R.x + Z - 0.01 || L.y < R.y + Z + 28 - 0.01 || L.x + L.w > R.x + R.w - Z + 0.01 || L.y + L.h > R.y + R.h - Z + 0.01) && F.add(
         "Some children extend beyond a frame. Enlarge that container or relax its constraints."
       );
     }
   if (z().overlaps > mt.overlaps && s.mode === "pass") {
     for (const E of Object.keys(i)) i[E] = Pn(a[E]);
-    T.add(
+    F.add(
       "This pass was rejected because it introduced overlaps. Try a smaller scope or a different approach."
     ), at = 0, pt = 0, ot = 0;
   }
@@ -1198,7 +1198,7 @@ async function Ai(t, e = {}) {
     const G = l(V) === "DOWN" ? "y" : "x", X = vn(C, E);
     X && (_t(R)[G] - _t(L)[G]) * X <= 0.01 && ft++;
   }
-  s.respectDirection && ft && T.add(
+  s.respectDirection && ft && F.add(
     ft + " forward-order conflict(s) remain; pins, frames, hierarchy directions or the movement budget can constrain placement."
   );
   const xt = Object.entries(r).map(([E, L]) => {
@@ -1208,13 +1208,13 @@ async function Ai(t, e = {}) {
       ...L,
       error: +G.toFixed(1),
       satisfied: G <= Math.max(12, s.nodeGap),
-      pinned: A(L.id)
+      pinned: O(L.id)
     };
   });
-  xt.some((E) => !E.satisfied) && T.add(
+  xt.some((E) => !E.satisfied) && F.add(
     "Some placement preferences remain approximate. They never override pins, fixed frames, collision safety, scope, or a pass movement limit."
   );
-  const O = {
+  const A = {
     intent: xt,
     backwardEdges: ft,
     directedEdges: Mt,
@@ -1228,26 +1228,26 @@ async function Ai(t, e = {}) {
     rmsDisplacement: +Math.sqrt(ot / Math.max(1, at)).toFixed(2),
     movementLimit: s.mode === "pass" ? s.maxMove : null,
     iterations: j,
-    batches: F,
+    batches: T,
     before: mt,
     after: z(),
-    warnings: [...T],
+    warnings: [...F],
     milliseconds: Date.now() - o,
     deterministic: s.mode === "rebuild" && !e.warmStart && s.algorithm !== "separate",
     termination: e.settle ? $.some((E) => E.reason === "iteration limit") ? "iteration limit" : $.some((E) => E.reason === "objective plateau") ? "objective plateau" : "settled" : "bounded pass",
     solverStops: $
   };
-  return H("Computed finish", !0), { document: n, report: O, ...e.trace ? { trace: it } : {} };
+  return H("Computed finish", !0), { document: n, report: A, ...e.trace ? { trace: it } : {} };
 }
 const Li = {
   algorithms: Wo,
   defaults: Uo,
   settings: La,
-  compute: Ai,
+  compute: Oi,
   normalizeIntent: Ga,
   placements: Xo,
   topology: Vn
-}, xe = Li, Fn = ["right", "bottom", "left", "top"], wt = 1e-4, Ut = (t) => Math.round(t * 100) / 100, Qn = (t, e, o) => Math.max(e, Math.min(o, t)), qe = (t) => JSON.parse(JSON.stringify(t)), _n = (t, e) => t < e ? -1 : t > e ? 1 : 0, ie = (t) => ({ x: t.x + t.w / 2, y: t.y + t.h / 2 }), Pe = (t, e) => Math.abs(t.x - e.x) < wt && Math.abs(t.y - e.y) < wt, re = (t, e) => Math.abs(t.x - e.x) + Math.abs(t.y - e.y), ue = {
+}, xe = Li, Tn = ["right", "bottom", "left", "top"], wt = 1e-4, Ut = (t) => Math.round(t * 100) / 100, Qn = (t, e, o) => Math.max(e, Math.min(o, t)), Be = (t) => JSON.parse(JSON.stringify(t)), _n = (t, e) => t < e ? -1 : t > e ? 1 : 0, ie = (t) => ({ x: t.x + t.w / 2, y: t.y + t.h / 2 }), Pe = (t, e) => Math.abs(t.x - e.x) < wt && Math.abs(t.y - e.y) < wt, re = (t, e) => Math.abs(t.x - e.x) + Math.abs(t.y - e.y), ue = {
   left: { x: -1, y: 0 },
   right: { x: 1, y: 0 },
   top: { x: 0, y: -1 },
@@ -1357,7 +1357,7 @@ function Pi(t) {
   return e.forEach((n, a) => o.set([n.x0, n.y0, n.x1, n.y1], a * 4)), un.set(t, { spansOf: e, box: o }), !0;
 }
 const Vo = (t, e, o, n) => o.x0 - n <= t[e * 4 + 2] + wt && t[e * 4] - n <= o.x1 + wt && o.y0 - n <= t[e * 4 + 3] + wt && t[e * 4 + 1] - n <= o.y1 + wt;
-function Ti(t, e, o, n, a) {
+function Fi(t, e, o, n, a) {
   const s = Math.abs(t.y - e.y) < wt, r = Math.abs(o.y - n.y) < wt;
   if (s !== r) return null;
   const d = s ? "x" : "y", c = s ? "y" : "x", u = Math.min(Math.max(t[d], e[d]), Math.max(o[d], n[d])) - Math.max(Math.min(t[d], e[d]), Math.min(o[d], n[d])), i = Math.abs(t[c] - o[c]);
@@ -1385,7 +1385,7 @@ function je(t, e, o) {
     minGap: Number.isFinite(s) ? Ut(s) : null
   };
 }
-function Fi(t, e, o, n) {
+function Ti(t, e, o, n) {
   let a = 0;
   const s = Ne(t), r = n - 0.05, d = un.get(e);
   for (let c = 0; c < e.length; c++) {
@@ -1403,7 +1403,7 @@ function Fi(t, e, o, n) {
   }
   return a;
 }
-let Be = new Float64Array(96);
+let qe = new Float64Array(96);
 function be(t, e, o = 1 / 0, n = Ko) {
   let a = 0, s = 0;
   const r = Ne(t), d = un.get(e), c = t[0], u = t.at(-1);
@@ -1413,8 +1413,8 @@ function be(t, e, o = 1 / 0, n = Ko) {
     if (!Jo(r, h, 0)) continue;
     const l = s;
     for (let p = 0; p < r.n; p++) {
-      const m = r.h[p] === 1, g = m ? r.lo[p] : r.at[p], y = m ? r.hi[p] : r.at[p], P = m ? r.at[p] : r.lo[p], A = m ? r.at[p] : r.hi[p];
-      if (!(y < h.x0 - 2 * wt || g > h.x1 + 2 * wt || A < h.y0 - 2 * wt || P > h.y1 + 2 * wt))
+      const m = r.h[p] === 1, g = m ? r.lo[p] : r.at[p], y = m ? r.hi[p] : r.at[p], P = m ? r.at[p] : r.lo[p], O = m ? r.at[p] : r.hi[p];
+      if (!(y < h.x0 - 2 * wt || g > h.x1 + 2 * wt || O < h.y0 - 2 * wt || P > h.y1 + 2 * wt))
         for (let w = 0; w < h.n; w++) {
           if (r.h[p] === h.h[w]) {
             if (Math.abs(r.at[p] - h.at[w]) > wt) continue;
@@ -1423,22 +1423,22 @@ function be(t, e, o = 1 / 0, n = Ko) {
               return { crossings: s, shared: a };
             continue;
           }
-          const k = r.h[p] === 1, T = k ? r : h, F = k ? p : w, j = k ? h : r, $ = k ? w : p, v = j.at[$], S = T.at[F];
-          if (v < T.lo[F] - wt || v > T.hi[F] + wt || S < j.lo[$] - wt || S > j.hi[$] + wt)
+          const k = r.h[p] === 1, F = k ? r : h, T = k ? p : w, j = k ? h : r, $ = k ? w : p, v = j.at[$], S = F.at[T];
+          if (v < F.lo[T] - wt || v > F.hi[T] + wt || S < j.lo[$] - wt || S > j.hi[$] + wt)
             continue;
           const M = { x: v, y: S };
           if ((Pe(M, c) || Pe(M, u)) && (Pe(M, f.points[0]) || Pe(M, f.points.at(-1))))
             continue;
           const x = Ut(v), N = Ut(S);
           let z = l;
-          for (; z < s && !(Be[z * 3] === i && Be[z * 3 + 1] === x && Be[z * 3 + 2] === N); )
+          for (; z < s && !(qe[z * 3] === i && qe[z * 3 + 1] === x && qe[z * 3 + 2] === N); )
             z++;
           if (!(z < s)) {
-            if (s * 3 + 3 > Be.length) {
-              const mt = new Float64Array(Be.length * 2);
-              mt.set(Be), Be = mt;
+            if (s * 3 + 3 > qe.length) {
+              const mt = new Float64Array(qe.length * 2);
+              mt.set(qe), qe = mt;
             }
-            if (Be.set([i, x, N], s++ * 3), o < 1 / 0 && s * n.crossingPenalty + a * n.sharedPenalty >= o)
+            if (qe.set([i, x, N], s++ * 3), o < 1 / 0 && s * n.crossingPenalty + a * n.sharedPenalty >= o)
               return { crossings: s, shared: a };
           }
         }
@@ -1487,7 +1487,7 @@ function ji(t, e, o) {
   }
   return n * Yn;
 }
-function Ta(t, e, o) {
+function Fa(t, e, o) {
   for (const n of t) {
     const a = n.border ? [-n.band, n.band] : [-n.band];
     for (const s of a)
@@ -1495,9 +1495,9 @@ function Ta(t, e, o) {
   }
 }
 function ms(t, e) {
-  return Qo(t) + Math.max(0, t.length - 2) * e.bendPenalty + Fa(t);
+  return Qo(t) + Math.max(0, t.length - 2) * e.bendPenalty + Ta(t);
 }
-function Fa(t) {
+function Ta(t) {
   let e = 0;
   for (let o = 2; o < t.length - 1; o++) e += Math.max(0, 8 - re(t[o - 1], t[o])) * 4;
   return e;
@@ -1512,7 +1512,7 @@ function jn(t, e, o, n = []) {
   );
 }
 function _a(t, e, o, n, a) {
-  return o + Qo(t) + Math.max(0, t.length - 2) * e.bendPenalty + n.crossings * e.crossingPenalty + n.shared * e.sharedPenalty + a * e.parallelPenalty + Fa(t);
+  return o + Qo(t) + Math.max(0, t.length - 2) * e.bendPenalty + n.crossings * e.crossingPenalty + n.shared * e.sharedPenalty + a * e.parallelPenalty + Ta(t);
 }
 class Di {
   constructor() {
@@ -1560,7 +1560,7 @@ function Ci(t, e, o, n, a, s = [], r = 16e3, d = null) {
       [u, C.y + C.h]
     ])
       Math.abs(W) < Ni && _.push(W);
-  Ta(s, c, u);
+  Fa(s, c, u);
   for (const C of [t, e])
     c.push(C.x - a.edgeGap, C.x + a.edgeGap), u.push(C.y - a.edgeGap, C.y + a.edgeGap);
   for (const C of n)
@@ -1569,12 +1569,12 @@ function Ci(t, e, o, n, a, s = [], r = 16e3, d = null) {
   c.push(Math.min(...c) - 32, Math.max(...c) + 32), u.push(Math.min(...u) - 32, Math.max(...u) + 32);
   const i = (C) => !d || C >= d.x0 && C <= d.x1, f = (C) => !d || C >= d.y0 && C <= d.y1;
   d && (c.push(d.x0, d.x1), u.push(d.y0, d.y1));
-  const h = [...new Set(c.filter(i).map(Ut))].sort((C, _) => C - _), l = [...new Set(u.filter(f).map(Ut))].sort((C, _) => C - _), p = h.length, m = l.length, g = l.indexOf(Ut(t.y)) * p + h.indexOf(Ut(t.x)), y = l.indexOf(Ut(e.y)) * p + h.indexOf(Ut(e.x)), P = new Di(), A = new Float64Array(p * m * 2).fill(1 / 0), w = new Int32Array(p * m * 2).fill(-1), k = new Float64Array(p * m * 2).fill(NaN), T = Math.max(a.edgeGap, wt) + 1, F = h[0], j = h[p - 1], $ = l[0], v = l[m - 1], S = o.filter((C) => C.x < j && C.x + C.w > F && C.y < v && C.y + C.h > $), M = s.filter(
-    (C) => C.x - C.band < j && C.x + C.w + C.band > F && C.y - C.band < v && C.y + C.h + C.band > $
+  const h = [...new Set(c.filter(i).map(Ut))].sort((C, _) => C - _), l = [...new Set(u.filter(f).map(Ut))].sort((C, _) => C - _), p = h.length, m = l.length, g = l.indexOf(Ut(t.y)) * p + h.indexOf(Ut(t.x)), y = l.indexOf(Ut(e.y)) * p + h.indexOf(Ut(e.x)), P = new Di(), O = new Float64Array(p * m * 2).fill(1 / 0), w = new Int32Array(p * m * 2).fill(-1), k = new Float64Array(p * m * 2).fill(NaN), F = Math.max(a.edgeGap, wt) + 1, T = h[0], j = h[p - 1], $ = l[0], v = l[m - 1], S = o.filter((C) => C.x < j && C.x + C.w > T && C.y < v && C.y + C.h > $), M = s.filter(
+    (C) => C.x - C.band < j && C.x + C.w + C.band > T && C.y - C.band < v && C.y + C.h + C.band > $
   ), x = [];
   for (const C of n) {
     const _ = Ne(C.points);
-    if (!(_.x1 < F - T || _.x0 > j + T || _.y1 < $ - T || _.y0 > v + T))
+    if (!(_.x1 < T - F || _.x0 > j + F || _.y1 < $ - F || _.y0 > v + F))
       for (const [W, b] of Se(C.points))
         x.push({
           a: W,
@@ -1603,7 +1603,7 @@ function Ci(t, e, o, n, a, s = [], r = 16e3, d = null) {
     };
     const ot = /* @__PURE__ */ new Set();
     for (const K of x) {
-      if (K[pt] < _ - T || K[at] > _ + T) continue;
+      if (K[pt] < _ - F || K[at] > _ + F) continue;
       if (C === K.h) {
         b.parallel.push(K);
         continue;
@@ -1629,13 +1629,13 @@ function Ci(t, e, o, n, a, s = [], r = 16e3, d = null) {
   }
   for (const C of [0, 1]) {
     const _ = g * 2 + C;
-    A[_] = 0, P.push(_, 0, re(t, e));
+    O[_] = 0, P.push(_, 0, re(t, e));
   }
   let Q = null, H = 0;
   for (; P.length && H++ < r; ) {
     P.pop();
     const C = P.key, _ = P.g;
-    if (_ !== A[C]) continue;
+    if (_ !== O[C]) continue;
     const W = C >> 1, b = C & 1;
     if (W === y) {
       Q = C;
@@ -1646,14 +1646,14 @@ function Ci(t, e, o, n, a, s = [], r = 16e3, d = null) {
       const pt = at & 1, ot = at === 0 ? Y + 1 : at === 2 ? Y - 1 : Y, K = at === 1 ? et + 1 : at === 3 ? et - 1 : et;
       if (ot < 0 || K < 0 || ot >= p || K >= m) continue;
       const ft = K * p + ot, Mt = ft * 2 + pt, xt = (W < ft ? W : ft) * 2 + pt;
-      let O = k[xt];
-      if (O !== O) {
+      let A = k[xt];
+      if (A !== A) {
         const L = { x: h[Y], y: l[et] }, R = { x: h[ot], y: l[K] }, Z = pt ? z(!1, L.x) : z(!0, L.y);
-        O = Je(L, R, Z.obs) ? 1 / 0 : ht(L, R, Z), k[xt] = O;
+        A = Je(L, R, Z.obs) ? 1 / 0 : ht(L, R, Z), k[xt] = A;
       }
-      if (O === 1 / 0) continue;
-      const E = _ + O + (b !== pt ? a.bendPenalty : 0);
-      E >= A[Mt] - 1e-3 || (A[Mt] = E, w[Mt] = C, P.push(Mt, E, E + Math.abs(h[ot] - e.x) + Math.abs(l[K] - e.y)));
+      if (A === 1 / 0) continue;
+      const E = _ + A + (b !== pt ? a.bendPenalty : 0);
+      E >= O[Mt] - 1e-3 || (O[Mt] = E, w[Mt] = C, P.push(Mt, E, E + Math.abs(h[ot] - e.x) + Math.abs(l[K] - e.y)));
     }
   }
   if (Q === null) return null;
@@ -1664,21 +1664,21 @@ function Ci(t, e, o, n, a, s = [], r = 16e3, d = null) {
   }
   return We(J.reverse());
 }
-function qi(t, e) {
+function Bi(t, e) {
   const o = [], n = [];
   for (const a of t)
     for (const [s, r] of Se(a.points))
       Math.abs(s.x - r.x) < wt ? o.push(s.x - e.edgeGap, s.x + e.edgeGap) : n.push(s.y - e.edgeGap, s.y + e.edgeGap);
   return { xs: o, ys: n };
 }
-function Bi(t, e, o, n, a, s, r, d) {
+function qi(t, e, o, n, a, s, r, d) {
   const c = /* @__PURE__ */ new Set([(t.x + e.x) / 2]), u = /* @__PURE__ */ new Set([(t.y + e.y) / 2]);
   for (const m of o)
     m.x < Math.max(t.x, e.x) + 80 && m.x + m.w > Math.min(t.x, e.x) - 80 && (u.add(m.y), u.add(m.y + m.h)), m.y < Math.max(t.y, e.y) + 80 && m.y + m.h > Math.min(t.y, e.y) - 80 && (c.add(m.x), c.add(m.x + m.w));
   for (const m of a.xs) c.add(m);
   for (const m of a.ys) u.add(m);
   const i = { x: [], y: [] };
-  Ta(s, i.x, i.y);
+  Fa(s, i.x, i.y);
   for (const m of i.x)
     m > Math.min(t.x, e.x) - 80 && m < Math.max(t.x, e.x) + 80 && c.add(m);
   for (const m of i.y)
@@ -1755,10 +1755,10 @@ function Hi(t) {
       const m = p ? 0 : 1;
       let g = h[m];
       if (!g) {
-        const w = p ? Math.min(i.x, f.x) : Math.min(i.y, f.y), k = p ? Math.max(i.x, f.x) : Math.max(i.y, f.y), T = p ? i.x : i.y, F = p ? f.x : f.y, j = p ? e : o;
+        const w = p ? Math.min(i.x, f.x) : Math.min(i.y, f.y), k = p ? Math.max(i.x, f.x) : Math.max(i.y, f.y), F = p ? i.x : i.y, T = p ? f.x : f.y, j = p ? e : o;
         g = {
-          first: c(s((p ? "v" : "h") + T, j, T), p ? i.y : i.x),
-          last: c(s((p ? "v" : "h") + F, j, F), p ? f.y : f.x),
+          first: c(s((p ? "v" : "h") + F, j, F), p ? i.y : i.x),
+          last: c(s((p ? "v" : "h") + T, j, T), p ? f.y : f.x),
           middle: k - w <= 2 * pe ? null : r(
             (p ? "H" : "V") + w + "," + k,
             p ? o : e,
@@ -1847,19 +1847,19 @@ function ys(t, e, o, n, a, s, r = !1, d = !0) {
   for (const y of p) if (l.every((P) => Math.abs(y - P) >= h - 0.01)) return y;
   if (d && !r && kn < h) {
     const y = kn, P = [];
-    for (let A = 1; A <= 16; A++)
-      for (const w of [1, -1]) A * y <= u / 2 + wt && P.push(w * A * y);
-    P.sort((A, w) => Math.abs(A) - Math.abs(w) || (f < 0 ? A - w : w - A));
-    for (const A of P) if (l.every((w) => Math.abs(A - w) >= y - 0.01)) return A;
+    for (let O = 1; O <= 16; O++)
+      for (const w of [1, -1]) O * y <= u / 2 + wt && P.push(w * O * y);
+    P.sort((O, w) => Math.abs(O) - Math.abs(w) || (f < 0 ? O - w : w - O));
+    for (const O of P) if (l.every((w) => Math.abs(O - w) >= y - 0.01)) return O;
   }
   let m = 0, g = -1;
   for (let y = -u / 2; y <= u / 2; y += 2) {
-    const P = Math.min(...l.map((A) => Math.abs(y - A)));
+    const P = Math.min(...l.map((O) => Math.abs(y - O)));
     P > g && (g = P, m = y);
   }
   return Ut(m);
 }
-const xs = 100, ws = { right: "right", down: "bottom" }, Ms = { right: "left", down: "top" }, bs = 300, vs = { right: ["left", "top"], down: ["top", "left"] }, ks = { right: ["right", "bottom"], down: ["bottom", "right"] }, Ui = 80, Ss = 40, Es = 12, Is = 12, Yi = 0.5, Xi = 0.3, Os = 1;
+const xs = 100, ws = { right: "right", down: "bottom" }, Ms = { right: "left", down: "top" }, bs = 300, vs = { right: ["left", "top"], down: ["top", "left"] }, ks = { right: ["right", "bottom"], down: ["bottom", "right"] }, Ui = 80, Ss = 40, Es = 12, Is = 12, Yi = 0.5, Xi = 0.3, As = 1;
 function Ki(t, e) {
   let o = 0;
   for (let n = 1; n < t.length; n++) {
@@ -1874,7 +1874,7 @@ function Ki(t, e) {
   }
   return o;
 }
-const Ji = 10, As = 1.75, Vi = 1.2, Qi = 120, uo = (t) => Se(t).reduce((e, [o, n]) => e + re(o, n), 0), po = 4, Ls = 100, Zi = 1, tr = 4, er = 4, nr = 32;
+const Ji = 10, Os = 1.75, Vi = 1.2, Qi = 120, uo = (t) => Se(t).reduce((e, [o, n]) => e + re(o, n), 0), po = 4, Ls = 100, Zi = 1, tr = 4, er = 4, nr = 32;
 function $s(t, e, o, n, a) {
   if (!t.some((r) => r.gates)) return t;
   const s = [...o === "top" ? [e.x] : [], ...a === "top" ? [n.x] : []];
@@ -1913,25 +1913,25 @@ function or(t, e = {}) {
   };
   for (const b of h)
     if (b.from !== b.to && !b.label)
-      for (const Y of Fn)
+      for (const Y of Tn)
         y(b.from, b.to, Y) && g.set(b.from + "|" + Y, (g.get(b.from + "|" + Y) ?? 0) + 1);
   const P = (b, Y) => {
     const et = r.get(b), at = (Y === "left" || Y === "right" ? et.h : et.w) - 24, pt = Math.max(s.portGap, s.edgeGap), ot = (ft) => 1 + 2 * Math.floor(at / 2 / ft + wt), K = ot(pt);
     return o && (g.get(b + "|" + Y) ?? 0) > K && ot(Math.min(kn, pt)) > K;
-  }, A = (b) => [b.cfg.flow, e.direction].find((Y) => Y === "right" || Y === "down"), w = /* @__PURE__ */ new WeakMap(), k = (b, Y = l.has(b.id)) => {
+  }, O = (b) => [b.cfg.flow, e.direction].find((Y) => Y === "right" || Y === "down"), w = /* @__PURE__ */ new WeakMap(), k = (b, Y = l.has(b.id)) => {
     const et = /* @__PURE__ */ new Set([...i(b.from), ...i(b.to)]), at = [...r.values()].filter((K) => !K.frame || K.id === b.from || K.id === b.to).map((K) => ho(K, s.clearance));
     for (const [K, ft] of d)
       if (!ft.collapsed)
         if (!et.has(K)) at.push(ho(ft, s.clearance));
         else {
-          const Mt = Math.max(1, Math.min(ft.w - 6, ft.titleWidth ?? 1 / 0)), xt = { y: ft.y + 2, h: (ft.titleHeight ?? 28) + s.clearance }, O = Math.max(s.clearance, s.standoff);
+          const Mt = Math.max(1, Math.min(ft.w - 6, ft.titleWidth ?? 1 / 0)), xt = { y: ft.y + 2, h: (ft.titleHeight ?? 28) + s.clearance }, A = Math.max(s.clearance, s.standoff);
           at.push({ id: K + ":header", x: ft.x + 3, w: Mt, ...xt }), n ? at.push({
             id: K + ":header-band",
             // Beside the group only a clearance out, so a line can pass midway along its side.
             x: ft.x - s.clearance,
             w: ft.w + 2 * s.clearance,
-            y: ft.y - O,
-            h: xt.y + xt.h - ft.y + O,
+            y: ft.y - A,
+            h: xt.y + xt.h - ft.y + A,
             across: !0,
             ...Y ? {} : { gates: [] }
           }) : Mt < ft.w - 6 && at.push({
@@ -1950,11 +1950,11 @@ function or(t, e = {}) {
       { id: "wall-b", x: ot.x, y: ot.y + ot.h, w: ot.w, h: 2e6 }
     ), at;
   };
-  function T(b, Y, et, at, pt) {
+  function F(b, Y, et, at, pt) {
     if (b.length < 2) return !1;
     pt = $s(pt, b[0], et, b.at(-1), at);
-    const ot = b[0], K = b[1], ft = b.at(-1), Mt = b.at(-2), xt = ue[et], O = ue[at];
-    if (xt.x * (K.x - ot.x) + xt.y * (K.y - ot.y) <= wt || O.x * (Mt.x - ft.x) + O.y * (Mt.y - ft.y) <= wt)
+    const ot = b[0], K = b[1], ft = b.at(-1), Mt = b.at(-2), xt = ue[et], A = ue[at];
+    if (xt.x * (K.x - ot.x) + xt.y * (K.y - ot.y) <= wt || A.x * (Mt.x - ft.x) + A.y * (Mt.y - ft.y) <= wt)
       return !1;
     for (let E = 1; E < b.length; E++) {
       const L = b[E - 1], R = b[E];
@@ -1970,20 +1970,20 @@ function or(t, e = {}) {
     }
     return !0;
   }
-  function F(b, Y, et, at, pt, ot) {
+  function T(b, Y, et, at, pt, ot) {
     if (Y.cfg.waypoints?.length) return b;
     let K = We(b), ft = jn(K, ot, s, u);
     for (let Mt = 0; Mt < 4; Mt++) {
       let xt = !1;
-      const O = be(K, ot), E = je(K, ot, s.edgeGap);
+      const A = be(K, ot), E = je(K, ot, s.edgeGap);
       t: for (let L = K.length - 1; L >= 2; L--)
         for (let R = 0; R + L < K.length; R++) {
           const Z = R + L, V = K[R], G = K[Z];
           for (const X of [[{ x: V.x, y: G.y }], [{ x: G.x, y: V.y }], []]) {
             const D = We([...K.slice(0, R + 1), ...X, ...K.slice(Z)]);
-            if (D.length >= K.length || !T(D, Y, et, at, pt)) continue;
-            const ct = be(D, ot), B = je(D, ot, s.edgeGap), rt = jn(D, ot, s, u);
-            if (!(ct.crossings > O.crossings || B.laneDeficit > E.laneDeficit + 0.1 || rt >= ft - 0.01)) {
+            if (D.length >= K.length || !F(D, Y, et, at, pt)) continue;
+            const ct = be(D, ot), q = je(D, ot, s.edgeGap), rt = jn(D, ot, s, u);
+            if (!(ct.crossings > A.crossings || q.laneDeficit > E.laneDeficit + 0.1 || rt >= ft - 0.01)) {
               K = D, ft = rt, xt = !0;
               break t;
             }
@@ -1996,15 +1996,15 @@ function or(t, e = {}) {
   function j(b, Y, et, at = []) {
     const pt = v(b, Y, et, !1, at);
     if (!n || !k(b, !1).some((X) => X.gates)) return pt;
-    const ot = r.get(b.from), K = r.get(b.to), ft = ie(ot), Mt = ie(K), xt = Math.max(0, Math.abs(ft.x - Mt.x) - (ot.w + K.w) / 2) + Math.max(0, Math.abs(ft.y - Mt.y) - (ot.h + K.h) / 2), O = pt.blocked ? 1 / 0 : uo(pt.points), E = O > As * xt, L = [b.cfg.fromSide, b.cfg.toSide].some((X) => X && X !== "auto"), R = !pt.blocked && ($(b, pt) || L && O > Vi * xt + 40);
+    const ot = r.get(b.from), K = r.get(b.to), ft = ie(ot), Mt = ie(K), xt = Math.max(0, Math.abs(ft.x - Mt.x) - (ot.w + K.w) / 2) + Math.max(0, Math.abs(ft.y - Mt.y) - (ot.h + K.h) / 2), A = pt.blocked ? 1 / 0 : uo(pt.points), E = A > Os * xt, L = [b.cfg.fromSide, b.cfg.toSide].some((X) => X && X !== "auto"), R = !pt.blocked && ($(b, pt) || L && A > Vi * xt + 40);
     if (!E && !R) return pt;
     const Z = v(b, Y, et, !0, at);
     if (Z.blocked) return pt;
-    const V = E && O > As * uo(Z.points), G = R && w.get(Z) + Qi < w.get(pt);
+    const V = E && A > Os * uo(Z.points), G = R && w.get(Z) + Qi < w.get(pt);
     return !V && !G ? pt : (p.add(Z), Z);
   }
   function $(b, Y) {
-    const et = ie(r.get(b.from)), at = ie(r.get(b.to)), pt = A(b);
+    const et = ie(r.get(b.from)), at = ie(r.get(b.to)), pt = O(b);
     return !!pt && b.from !== b.to && (pt === "down" ? at.y - et.y : at.x - et.x) > 20 && (vs[pt].includes(Y.fromSide) || ks[pt].includes(Y.toSide));
   }
   function v(b, Y, et, at, pt = []) {
@@ -2016,44 +2016,44 @@ function or(t, e = {}) {
     }
   }
   function S(b, Y, et, at, pt = []) {
-    const ot = r.get(b.from), K = r.get(b.to), ft = b.cfg, Mt = pt.length ? [...k(b, at), ...pt] : k(b, at), xt = ie(ot), O = ie(K), E = b.pin || {}, L = E.from ? [E.from.side] : ft.fromSide && ft.fromSide !== "auto" ? [ft.fromSide] : e.quick && et ? [et.fromSide] : Fn, R = E.to ? [E.to.side] : ft.toSide && ft.toSide !== "auto" ? [ft.toSide] : e.quick && et ? [et.toSide] : Fn, Z = A(b), V = Z === "down" ? O.y - xt.y : O.x - xt.x, G = Z && b.from !== b.to && V > 20, X = (I) => G ? (I.fs === ws[Z] ? 0 : vs[Z].includes(I.fs) ? bs : xs) + (I.ts === Ms[Z] ? 0 : ks[Z].includes(I.ts) ? bs : xs) : 0, D = (I, U) => G && I === (U === "from" ? ws : Ms)[Z], ct = [];
-    let B = null;
-    const rt = o ? u.filter((I) => !I.border && (I.id === b.from || I.id === b.to)) : [], lt = (I, U, nt) => Y.filter((q) => q[nt] === I && q[nt + "Side"] === U).length, kt = (I, U, nt) => ue[I].x * (nt.x - U.x) + ue[I].y * (nt.y - U.y) > 0.01, vt = (I, U, nt) => {
-      const q = (I === "left" || I === "right" ? U.h : U.w) - 24, st = o ? Math.min(kn, Math.max(s.portGap, s.edgeGap)) : Math.max(s.portGap, s.edgeGap);
-      return nt < 1 + 2 * Math.floor(q / 2 / st + wt);
+    const ot = r.get(b.from), K = r.get(b.to), ft = b.cfg, Mt = pt.length ? [...k(b, at), ...pt] : k(b, at), xt = ie(ot), A = ie(K), E = b.pin || {}, L = E.from ? [E.from.side] : ft.fromSide && ft.fromSide !== "auto" ? [ft.fromSide] : e.quick && et ? [et.fromSide] : Tn, R = E.to ? [E.to.side] : ft.toSide && ft.toSide !== "auto" ? [ft.toSide] : e.quick && et ? [et.toSide] : Tn, Z = O(b), V = Z === "down" ? A.y - xt.y : A.x - xt.x, G = Z && b.from !== b.to && V > 20, X = (I) => G ? (I.fs === ws[Z] ? 0 : vs[Z].includes(I.fs) ? bs : xs) + (I.ts === Ms[Z] ? 0 : ks[Z].includes(I.ts) ? bs : xs) : 0, D = (I, U) => G && I === (U === "from" ? ws : Ms)[Z], ct = [];
+    let q = null;
+    const rt = o ? u.filter((I) => !I.border && (I.id === b.from || I.id === b.to)) : [], lt = (I, U, nt) => Y.filter((B) => B[nt] === I && B[nt + "Side"] === U).length, kt = (I, U, nt) => ue[I].x * (nt.x - U.x) + ue[I].y * (nt.y - U.y) > 0.01, vt = (I, U, nt) => {
+      const B = (I === "left" || I === "right" ? U.h : U.w) - 24, st = o ? Math.min(kn, Math.max(s.portGap, s.edgeGap)) : Math.max(s.portGap, s.edgeGap);
+      return nt < 1 + 2 * Math.floor(B / 2 / st + wt);
     };
-    function Ot(I, U, nt, q, st, dt) {
+    function At(I, U, nt, B, st, dt) {
       const gt = lt(dt, I, st);
-      return !gt || (st === "from" ? D(I, "from") : D(I, "to")) || o && kt(I, nt, q) && vt(I, U, gt) ? 0 : gt * s.fanoutPenalty;
+      return !gt || (st === "from" ? D(I, "from") : D(I, "to")) || o && kt(I, nt, B) && vt(I, U, gt) ? 0 : gt * s.fanoutPenalty;
     }
-    const Et = Math.max(0, Math.abs(xt.x - O.x) - (ot.w + K.w) / 2) + Math.max(0, Math.abs(xt.y - O.y) - (ot.h + K.h) / 2), Ft = (I) => Math.max(0, uo(I) - Et), St = o ? [
+    const Et = Math.max(0, Math.abs(xt.x - A.x) - (ot.w + K.w) / 2) + Math.max(0, Math.abs(xt.y - A.y) - (ot.h + K.h) / 2), Tt = (I) => Math.max(0, uo(I) - Et), St = o ? [
       ...i(b.from).filter((I) => !i(b.to).includes(I)).map((I) => ({ g: d.get(I), box: ot })),
       ...i(b.to).filter((I) => !i(b.from).includes(I)).map((I) => ({ g: d.get(I), box: K }))
-    ].filter((I) => I.g && !I.g.collapsed) : [], Qt = (I) => St.reduce((U, { g: nt, box: q }) => {
+    ].filter((I) => I.g && !I.g.collapsed) : [], Qt = (I) => St.reduce((U, { g: nt, box: B }) => {
       const st = Math.min(
-        q.x - nt.x,
-        nt.x + nt.w - (q.x + q.w),
-        q.y - nt.y,
-        nt.y + nt.h - (q.y + q.h)
+        B.x - nt.x,
+        nt.x + nt.w - (B.x + B.w),
+        B.y - nt.y,
+        nt.y + nt.h - (B.y + B.h)
       );
       return U + Math.max(0, Ki(I, nt) - Math.max(0, st));
     }, 0);
-    function Dt(I, U, nt = 1 / 0, q = !1) {
-      const st = ue[U.fs], dt = ue[U.ts], gt = { x: O.x - xt.x, y: O.y - xt.y }, bt = o ? Ls : 18, It = st.x * gt.x + st.y * gt.y < -0.01, Ct = dt.x * -gt.x + dt.y * -gt.y < -0.01, ut = o && (It && L.length > 1 || Ct && R.length > 1) ? Yi * Ft(I) : 0, tt = (It ? bt : 0) + (Ct ? bt : 0) + ut, yt = o ? (U.ts === "bottom" ? Ss : 0) + (U.ts === "right" ? Es : 0) + (U.fs === "top" || U.fs === "left" ? Is : 0) : 0, At = et ? (U.fs !== et.fromSide ? s.portStability : 0) + (U.ts !== et.toSide ? s.portStability : 0) : 0, Tt = U.fanout ??= Ot(U.fs, ot, xt, O, "from", b.from) + Ot(U.ts, K, O, xt, "to", b.to), Lt = o && U.fs === U.ts && I.length > 3 ? Ui : 0;
-      if (ms(I, s) + tt + yt + Lt + At + Tt + X(U) - Os >= nt)
+    function Dt(I, U, nt = 1 / 0, B = !1) {
+      const st = ue[U.fs], dt = ue[U.ts], gt = { x: A.x - xt.x, y: A.y - xt.y }, bt = o ? Ls : 18, It = st.x * gt.x + st.y * gt.y < -0.01, Ct = dt.x * -gt.x + dt.y * -gt.y < -0.01, ut = o && (It && L.length > 1 || Ct && R.length > 1) ? Yi * Tt(I) : 0, tt = (It ? bt : 0) + (Ct ? bt : 0) + ut, yt = o ? (U.ts === "bottom" ? Ss : 0) + (U.ts === "right" ? Es : 0) + (U.fs === "top" || U.fs === "left" ? Is : 0) : 0, Ot = et ? (U.fs !== et.fromSide ? s.portStability : 0) + (U.ts !== et.toSide ? s.portStability : 0) : 0, Ft = U.fanout ??= At(U.fs, ot, xt, A, "from", b.from) + At(U.ts, K, A, xt, "to", b.to), Lt = o && U.fs === U.ts && I.length > 3 ? Ui : 0;
+      if (ms(I, s) + tt + yt + Lt + Ot + Ft + X(U) - As >= nt)
         return 1 / 0;
-      if (q) return 0;
+      if (B) return 0;
       let Pt = 0;
       for (const [ee, se, Ce, Ke] of o ? [
         ["from", b.from, b.to, U.fs],
         ["to", b.to, b.from, U.ts]
       ] : []) {
         if (se === Ce) continue;
-        const Ae = Y.filter((mn) => mn[ee] === se && mn[ee + "Side"] === Ke), lo = ee === "from" && !b.label ? Fn.filter((mn) => P(se, mn) && y(se, Ce, mn)) : [];
-        lo.length && !lo.includes(Ke) && (Pt += 2 * s.fanoutPenalty), Pt -= Fi(I, Ae, lo.includes(Ke) ? 0 : Ji, s.edgeGap) * s.parallelPenalty;
+        const Oe = Y.filter((mn) => mn[ee] === se && mn[ee + "Side"] === Ke), lo = ee === "from" && !b.label ? Tn.filter((mn) => P(se, mn) && y(se, Ce, mn)) : [];
+        lo.length && !lo.includes(Ke) && (Pt += 2 * s.fanoutPenalty), Pt -= Ti(I, Oe, lo.includes(Ke) ? 0 : Ji, s.edgeGap) * s.parallelPenalty;
       }
-      const $t = Xi * Qt(I), Nt = rt.length ? cn(I, rt) * Zi : 0, qt = tt + yt + Lt + At + Tt + X(U), zt = (ee) => nt < 1 / 0 && ee - 1e-6 >= nt;
-      let Jt = ms(I, s) + $t + Pt + Nt + qt;
+      const $t = Xi * Qt(I), Nt = rt.length ? cn(I, rt) * Zi : 0, Bt = tt + yt + Lt + Ot + Ft + X(U), zt = (ee) => nt < 1 / 0 && ee - 1e-6 >= nt;
+      let Jt = ms(I, s) + $t + Pt + Nt + Bt;
       if (zt(Jt)) return 1 / 0;
       const Vt = u.length ? cn(I, u, nt - Jt + 1e-3) : 0;
       if (zt(Jt += Vt)) return 1 / 0;
@@ -2061,50 +2061,50 @@ function or(t, e = {}) {
       if (zt(Jt += jt.crossings * s.crossingPenalty + jt.shared * s.sharedPenalty))
         return 1 / 0;
       const Zt = je(I, Y, s.edgeGap).laneDeficit;
-      return $t + Pt + _a(I, s, Vt, jt, Zt) + Nt + tt + yt + Lt + At + Tt + X(U);
+      return $t + Pt + _a(I, s, Vt, jt, Zt) + Nt + tt + yt + Lt + Ot + Ft + X(U);
     }
-    const ne = (I) => B ? I < B.gen ? B.score + 0.01 : B.score - 0.01 : 1 / 0, Gt = (I, U, nt = U.obs, q = 1 / 0) => {
+    const ne = (I) => q ? I < q.gen ? q.score + 0.01 : q.score - 0.01 : 1 / 0, Gt = (I, U, nt = U.obs, B = 1 / 0) => {
       if (!I) return;
-      const st = ne(q), dt = We([U.start, ...I, U.end]);
+      const st = ne(B), dt = We([U.start, ...I, U.end]);
       for (let bt = 2; bt < dt.length; bt++) {
         const It = dt[bt - 2], Ct = dt[bt - 1], ut = dt[bt];
         if ((Math.abs(It.x - Ct.x) < wt && Math.abs(Ct.x - ut.x) < wt || Math.abs(It.y - Ct.y) < wt && Math.abs(Ct.y - ut.y) < wt) && (Ct.x - It.x) * (ut.x - Ct.x) + (Ct.y - It.y) * (ut.y - Ct.y) < -1e-3)
           return;
       }
-      if (B && Dt(dt, U, st, !0) === 1 / 0 || dt.length < 2 || Se(dt).some(([bt, It], Ct) => Ct > 0 && Ct < dt.length - 2 && Je(bt, It, nt)))
+      if (q && Dt(dt, U, st, !0) === 1 / 0 || dt.length < 2 || Se(dt).some(([bt, It], Ct) => Ct > 0 && Ct < dt.length - 2 && Je(bt, It, nt)))
         return;
       const gt = Dt(dt, U, st);
-      (!B || gt < st) && (B = { ...U, points: dt, score: gt, gen: q });
+      (!q || gt < st) && (q = { ...U, points: dt, score: gt, gen: B });
     }, Yt = (I) => o && I.shape === "diamond", Kt = (I, U) => Y.some(
       (nt) => nt.from === I && nt.fromSide === U || nt.to === I && nt.toSide === U
-    ), ae = (I, U, nt, q) => Yt(I) && q.length > 1 && Kt(U, nt) && q.some((st) => !Kt(U, st)), Rt = qi(Y, s), Xt = new zi(
+    ), ae = (I, U, nt, B) => Yt(I) && B.length > 1 && Kt(U, nt) && B.some((st) => !Kt(U, st)), Rt = Bi(Y, s), Xt = new zi(
       (I, U) => I.floor < U.floor || I.floor === U.floor && (I.idx < U.idx || I.idx === U.idx && I.k < U.k)
     ), te = (I) => {
-      const U = { x: O.x - xt.x, y: O.y - xt.y }, nt = ue[I.fs], q = ue[I.ts], st = o ? Ls : 18;
-      return (nt.x * U.x + nt.y * U.y < -0.01 ? st : 0) + (q.x * -U.x + q.y * -U.y < -0.01 ? st : 0) + (o ? (I.ts === "bottom" ? Ss : 0) + (I.ts === "right" ? Es : 0) + (I.fs === "top" || I.fs === "left" ? Is : 0) : 0) + (et && I.fs !== et.fromSide ? s.portStability : 0) + (et && I.ts !== et.toSide ? s.portStability : 0) + (I.fanout ??= Ot(I.fs, ot, xt, O, "from", b.from) + Ot(I.ts, K, O, xt, "to", b.to)) + X(I) - Os - 1;
+      const U = { x: A.x - xt.x, y: A.y - xt.y }, nt = ue[I.fs], B = ue[I.ts], st = o ? Ls : 18;
+      return (nt.x * U.x + nt.y * U.y < -0.01 ? st : 0) + (B.x * -U.x + B.y * -U.y < -0.01 ? st : 0) + (o ? (I.ts === "bottom" ? Ss : 0) + (I.ts === "right" ? Es : 0) + (I.fs === "top" || I.fs === "left" ? Is : 0) : 0) + (et && I.fs !== et.fromSide ? s.portStability : 0) + (et && I.ts !== et.toSide ? s.portStability : 0) + (I.fanout ??= At(I.fs, ot, xt, A, "from", b.from) + At(I.ts, K, A, xt, "to", b.to)) + X(I) - As - 1;
     }, Ht = [], oe = (I, U) => {
       const nt = te(I) + re(I.start, I.as) + re(I.bs, I.end);
       Ht.push({ c: I, o: U, stubs: nt, idx: Ht.length, min: nt + re(I.as, I.bs) });
-    }, Bt = () => B ? B.score + 0.01 : 1 / 0, le = (I) => I.idx * 1e6 + I.k + 1, fe = Hi(Y), de = ({ c: I, o: U, stubs: nt, idx: q }) => {
+    }, qt = () => q ? q.score + 0.01 : 1 / 0, le = (I) => I.idx * 1e6 + I.k + 1, fe = Hi(Y), de = ({ c: I, o: U, stubs: nt, idx: B }) => {
       const st = fe(I.as, I.bs);
-      Bi(I.as, I.bs, U, s, Rt, u, Bt() - nt, (dt, gt, bt) => {
+      qi(I.as, I.bs, U, s, Rt, u, qt() - nt, (dt, gt, bt) => {
         let It = nt + Qo(dt) + Wi(I.start, dt, I.end) * s.bendPenalty;
-        It >= Bt() || (It += st(dt, bt) * s.crossingPenalty, It < Bt() && Xt.push({ c: I, o: U, raw: dt, floor: It, idx: q, k: gt }));
+        It >= qt() || (It += st(dt, bt) * s.crossingPenalty, It < qt() && Xt.push({ c: I, o: U, raw: dt, floor: It, idx: B, k: gt }));
       });
     };
     for (const I of L)
       for (const U of R) {
         if (b.from === b.to && I === U || ae(ot, b.from, I, L) || ae(K, b.to, U, R)) continue;
-        let nt = Yt(ot) ? 0 : ys(b.from, I, ot, Y, s, K, !b.label && P(b.from, I), o), q = Yt(K) ? 0 : ys(b.to, U, K, Y, s, ot, !1, o);
+        let nt = Yt(ot) ? 0 : ys(b.from, I, ot, Y, s, K, !b.label && P(b.from, I), o), B = Yt(K) ? 0 : ys(b.to, U, K, Y, s, ot, !1, o);
         if ((I === "left" || I === "right") == (U === "left" || U === "right") && b.from !== b.to && !Yt(K)) {
-          const jt = I === "left" || I === "right", Zt = jt ? "y" : "x", ee = (jt ? K.h : K.w) / 2 - 12, se = me(ot, I, nt)[Zt] - ie(K)[Zt], Ce = K.frame ? Qn(se, -ee, ee) : se, Ke = Y.flatMap((Ae) => [
-            ...Ae.from === b.to && Ae.fromSide === U ? [Ae.fromOffset] : [],
-            ...Ae.to === b.to && Ae.toSide === U ? [Ae.toOffset] : []
+          const jt = I === "left" || I === "right", Zt = jt ? "y" : "x", ee = (jt ? K.h : K.w) / 2 - 12, se = me(ot, I, nt)[Zt] - ie(K)[Zt], Ce = K.frame ? Qn(se, -ee, ee) : se, Ke = Y.flatMap((Oe) => [
+            ...Oe.from === b.to && Oe.fromSide === U ? [Oe.fromOffset] : [],
+            ...Oe.to === b.to && Oe.toSide === U ? [Oe.toOffset] : []
           ]);
-          Math.abs(Ce) <= ee && Ke.every((Ae) => Math.abs(Ce - Ae) >= Math.max(s.portGap, s.edgeGap) - 0.01) && (q = Ce);
+          Math.abs(Ce) <= ee && Ke.every((Oe) => Math.abs(Ce - Oe) >= Math.max(s.portGap, s.edgeGap) - 0.01) && (B = Ce);
         }
-        typeof ft.toOffset == "number" && ft.toSide === U && !Yt(K) && (q = ft.toOffset), E.from && (nt = E.from.offset), E.to && (q = E.to.offset);
-        const dt = me(ot, I, nt), gt = me(K, U, q), bt = $s(Mt, dt, I, gt, U), It = s.standoff ? {
+        typeof ft.toOffset == "number" && ft.toSide === U && !Yt(K) && (B = ft.toOffset), E.from && (nt = E.from.offset), E.to && (B = E.to.offset);
+        const dt = me(ot, I, nt), gt = me(K, U, B), bt = $s(Mt, dt, I, gt, U), It = s.standoff ? {
           right: K.x - ot.x - ot.w,
           left: ot.x - K.x - K.w,
           bottom: K.y - ot.y - ot.h,
@@ -2112,26 +2112,26 @@ function or(t, e = {}) {
         }[I] : 0, Ct = ue[I].x === -ue[U].x && ue[I].y === -ue[U].y && It > 0 && It < 2 * (s.clearance + 3), ut = Ct ? It / 2 : s.clearance + 3, tt = Ct ? bt.filter((jt) => jt.id !== b.from && jt.id !== b.to) : null, yt = (jt, Zt, ee, se) => ({
           x: Ut(Zt === "left" ? jt.x - se : Zt === "right" ? jt.x + jt.w + se : ee.x),
           y: Ut(Zt === "top" ? jt.y - se : Zt === "bottom" ? jt.y + jt.h + se : ee.y)
-        }), At = (jt, Zt, ee) => !Je(jt, Zt, tt || bt.filter((se) => se.id !== ee)), Tt = Math.max(ut, s.standoff);
+        }), Ot = (jt, Zt, ee) => !Je(jt, Zt, tt || bt.filter((se) => se.id !== ee)), Ft = Math.max(ut, s.standoff);
         let Lt = yt(ot, I, dt, ut), Pt = yt(K, U, gt, ut);
-        if (!At(dt, Lt, b.from) || !At(gt, Pt, b.to)) continue;
-        if (!Ct && Yt(ot) && Tt > ut) {
-          const jt = yt(ot, I, dt, Tt);
-          At(dt, jt, b.from) && (Lt = jt);
+        if (!Ot(dt, Lt, b.from) || !Ot(gt, Pt, b.to)) continue;
+        if (!Ct && Yt(ot) && Ft > ut) {
+          const jt = yt(ot, I, dt, Ft);
+          Ot(dt, jt, b.from) && (Lt = jt);
         }
-        if (!Ct && Yt(K) && Tt > ut) {
-          const jt = yt(K, U, gt, Tt);
-          At(gt, jt, b.to) && (Pt = jt);
+        if (!Ct && Yt(K) && Ft > ut) {
+          const jt = yt(K, U, gt, Ft);
+          Ot(gt, jt, b.to) && (Pt = jt);
         }
-        const $t = { fs: I, ts: U, fo: nt, toff: q, start: dt, end: gt, as: Lt, bs: Pt, obs: bt }, Nt = [dt, ...ft.waypoints || [], gt];
+        const $t = { fs: I, ts: U, fo: nt, toff: B, start: dt, end: gt, as: Lt, bs: Pt, obs: bt }, Nt = [dt, ...ft.waypoints || [], gt];
         if ($t.lower = Nt.reduce((jt, Zt, ee) => ee ? jt + re(Nt[ee - 1], Zt) : 0, 0) + X($t) + (et && I !== et.fromSide ? s.portStability : 0) + (et && U !== et.toSide ? s.portStability : 0), Ct) {
           if (ft.waypoints?.length) continue;
           oe($t, [...tt, { ...ot, id: b.from }, { ...K, id: b.to }]);
           continue;
         }
         if (ct.push($t), ft.waypoints?.length) continue;
-        const qt = ue[I], zt = ue[U], Jt = gt.x - dt.x, Vt = gt.y - dt.y;
-        (dt.x === gt.x || dt.y === gt.y) && qt.x * Jt + qt.y * Vt > 0 && zt.x * -Jt + zt.y * -Vt > 0 && !Je(
+        const Bt = ue[I], zt = ue[U], Jt = gt.x - dt.x, Vt = gt.y - dt.y;
+        (dt.x === gt.x || dt.y === gt.y) && Bt.x * Jt + Bt.y * Vt > 0 && zt.x * -Jt + zt.y * -Vt > 0 && !Je(
           dt,
           gt,
           bt.filter((jt) => jt.id !== b.from && jt.id !== b.to)
@@ -2148,26 +2148,26 @@ function or(t, e = {}) {
     for (let I = 0; ; ) {
       const U = Xt.items[0];
       if (I < Ht.length && (!U || Ht[I].min <= U.floor)) {
-        Ht[I].min >= Bt() ? I = Ht.length : de(Ht[I++]);
+        Ht[I].min >= qt() ? I = Ht.length : de(Ht[I++]);
         continue;
       }
-      if (!U || U.floor >= Bt()) break;
+      if (!U || U.floor >= qt()) break;
       const nt = Xt.pop();
       if (nt.path) {
         Gt(nt.path, nt.c, nt.c.obs, le(nt));
         continue;
       }
-      const q = We(nt.raw);
-      Se(q).some(([st, dt]) => Je(st, dt, nt.o)) || Gt(q, nt.c, nt.o, le(nt));
+      const B = We(nt.raw);
+      Se(B).some(([st, dt]) => Je(st, dt, nt.o)) || Gt(B, nt.c, nt.o, le(nt));
     }
     ct.sort((I, U) => I.lower - U.lower || _n(I.fs + ":" + I.ts, U.fs + ":" + U.ts));
     let he = 0;
     for (const I of ct) {
-      if (B && I.lower > B.score) continue;
-      if (he++ >= (e.quick ? 1 : 3) || B && !be(B.points, Y).crossings && !je(B.points, Y, s.edgeGap).lanePairs && !ft.waypoints?.length && B.points.length <= 6)
+      if (q && I.lower > q.score) continue;
+      if (he++ >= (e.quick ? 1 : 3) || q && !be(q.points, Y).crossings && !je(q.points, Y, s.edgeGap).lanePairs && !ft.waypoints?.length && q.points.length <= 6)
         break;
       const U = [I.as, ...ft.waypoints || [], I.bs], nt = [];
-      let q = !0;
+      let B = !0;
       for (let st = 1; st < U.length; st++) {
         const dt = U[st - 1], gt = U[st], bt = {
           x0: Math.min(ot.x, K.x, dt.x, gt.x),
@@ -2181,16 +2181,16 @@ function or(t, e = {}) {
           if (Ct = Ci(dt, gt, I.obs, Y, s, u, u.length ? 64e3 : 16e3, tt), Ct) break;
         }
         if (!Ct) {
-          q = !1;
+          B = !1;
           break;
         }
         nt.push(...Ct);
       }
-      q && Gt(nt, I);
+      B && Gt(nt, I);
     }
-    if (!B && e.quick && et) return S(b, Y, null, at, pt);
-    if (!B) {
-      const I = L[0], U = R[0], nt = me(ot, I), q = me(K, U);
+    if (!q && e.quick && et) return S(b, Y, null, at, pt);
+    if (!q) {
+      const I = L[0], U = R[0], nt = me(ot, I), B = me(K, U);
       return {
         id: b.id,
         from: b.from,
@@ -2199,30 +2199,30 @@ function or(t, e = {}) {
         toSide: U,
         fromOffset: 0,
         toOffset: 0,
-        points: We([nt, { x: q.x, y: nt.y }, q]),
+        points: We([nt, { x: B.x, y: nt.y }, B]),
         blocked: !0,
         reason: "No clear route within the search budget and current side / waypoint constraints."
       };
     }
-    B.points = F(B.points, b, B.fs, B.ts, Mt, Y);
+    q.points = T(q.points, b, q.fs, q.ts, Mt, Y);
     const we = {
       id: b.id,
       from: b.from,
       to: b.to,
-      fromSide: B.fs,
-      toSide: B.ts,
-      fromOffset: B.fo,
-      toOffset: B.toff,
-      points: B.points,
+      fromSide: q.fs,
+      toSide: q.ts,
+      fromOffset: q.fo,
+      toOffset: q.toff,
+      points: q.points,
       blocked: !1
     };
-    return w.set(we, B.score), we;
+    return w.set(we, q.score), we;
   }
   const M = (b) => {
     const Y = b.cfg.plan;
     if (!Y || b.from === b.to || b.cfg.waypoints?.length) return null;
     const et = Y.points, at = Math.abs(et[0].y - et[1].y) < wt, pt = at ? et[1].x > et[0].x ? "right" : "left" : et[1].y > et[0].y ? "bottom" : "top", ot = et.at(-2), K = et.at(-1), ft = Math.abs(ot.y - K.y) < wt ? K.x > ot.x ? "left" : "right" : K.y > ot.y ? "top" : "bottom", Mt = me(r.get(b.from), pt, Y.fromOffset), xt = me(r.get(b.to), ft, Y.toOffset);
-    return b.cfg.fromSide && b.cfg.fromSide !== "auto" && b.cfg.fromSide !== pt || b.cfg.toSide && b.cfg.toSide !== "auto" && b.cfg.toSide !== ft || typeof b.cfg.toOffset == "number" && b.cfg.toOffset !== Y.toOffset || re(et[0], Mt) > 0.02 || re(K, xt) > 0.02 || !T(et, b, pt, ft, k(b)) ? null : {
+    return b.cfg.fromSide && b.cfg.fromSide !== "auto" && b.cfg.fromSide !== pt || b.cfg.toSide && b.cfg.toSide !== "auto" && b.cfg.toSide !== ft || typeof b.cfg.toOffset == "number" && b.cfg.toOffset !== Y.toOffset || re(et[0], Mt) > 0.02 || re(K, xt) > 0.02 || !F(et, b, pt, ft, k(b)) ? null : {
       id: b.id,
       from: b.from,
       to: b.to,
@@ -2230,7 +2230,7 @@ function or(t, e = {}) {
       toSide: ft,
       fromOffset: Y.fromOffset,
       toOffset: Y.toOffset,
-      points: et.map((O) => ({ x: O.x, y: O.y })),
+      points: et.map((A) => ({ x: A.x, y: A.y })),
       blocked: !1
     };
   };
@@ -2257,7 +2257,7 @@ function or(t, e = {}) {
       blocked: b.filter((K) => K.blocked).length,
       bends: b.reduce((K, ft) => K + Math.max(0, ft.points.length - 2), 0),
       length: Ut(
-        b.reduce((K, ft) => K + Se(ft.points).reduce((Mt, [xt, O]) => Mt + re(xt, O), 0), 0)
+        b.reduce((K, ft) => K + Se(ft.points).reduce((Mt, [xt, A]) => Mt + re(xt, A), 0), 0)
       )
     };
   }, mt = (b) => {
@@ -2292,16 +2292,16 @@ function or(t, e = {}) {
         const K = x.findIndex((L) => L.id === ot.id), ft = x.filter((L, R) => R !== K), Mt = be(x[K].points, ft);
         if (!x[K].blocked && !Mt.crossings && !Mt.shared && !je(x[K].points, ft, s.edgeGap).lanePairs && !ht(x[K]))
           continue;
-        const xt = j(ot, ft, x[K]), O = [...x];
-        O[K] = xt;
-        const E = mt(O);
-        E < pt - 0.1 && (x = O, pt = E, m(), Q++);
+        const xt = j(ot, ft, x[K]), A = [...x];
+        A[K] = xt;
+        const E = mt(A);
+        E < pt - 0.1 && (x = A, pt = E, m(), Q++);
       }
     }
   let H = 0;
   if (!e.quick && o && h.length <= nr) {
-    const b = (xt) => xt.toSide === "bottom" || ht(xt) || xt.fromSide === xt.toSide && xt.points.length > 3, Y = (xt) => mt(xt) + xt.reduce((O, E) => O + cn(E.points, u), 0), et = (xt, O) => {
-      const E = /* @__PURE__ */ new Set([O.from, O.to]), L = Se(xt.points);
+    const b = (xt) => xt.toSide === "bottom" || ht(xt) || xt.fromSide === xt.toSide && xt.points.length > 3, Y = (xt) => mt(xt) + xt.reduce((A, E) => A + cn(E.points, u), 0), et = (xt, A) => {
+      const E = /* @__PURE__ */ new Set([A.from, A.to]), L = Se(xt.points);
       return L.filter(
         (R, Z) => !(Z === 0 && E.has(xt.from)) && !(Z === L.length - 1 && E.has(xt.to))
       ).map(
@@ -2315,45 +2315,45 @@ function or(t, e = {}) {
           s.edgeGap / 2
         )
       );
-    }, at = new Map(h.map((xt) => [xt.id, xt])), pt = (xt) => xt.cfg.waypoints?.length > 0 || N.has(xt.id), ot = ["from", "to"], K = (xt, O) => xt[O] + "|" + xt[O + "Side"], ft = (xt, O) => {
-      const E = new Set([x[xt], x[O]].flatMap((B) => ot.map((rt) => K(B, rt)))), L = x.flatMap(
-        (B, rt) => rt === xt || rt === O || B.from !== B.to && ot.some((lt) => E.has(K(B, lt))) ? [rt] : []
+    }, at = new Map(h.map((xt) => [xt.id, xt])), pt = (xt) => xt.cfg.waypoints?.length > 0 || N.has(xt.id), ot = ["from", "to"], K = (xt, A) => xt[A] + "|" + xt[A + "Side"], ft = (xt, A) => {
+      const E = new Set([x[xt], x[A]].flatMap((q) => ot.map((rt) => K(q, rt)))), L = x.flatMap(
+        (q, rt) => rt === xt || rt === A || q.from !== q.to && ot.some((lt) => E.has(K(q, lt))) ? [rt] : []
       );
-      if (L.length > er || L.some((B) => pt(at.get(x[B].id)))) return [];
+      if (L.length > er || L.some((q) => pt(at.get(x[q].id)))) return [];
       const R = /* @__PURE__ */ new Map();
-      for (const B of L)
+      for (const q of L)
         for (const rt of ot) {
-          const lt = K(x[B], rt);
-          R.has(lt) || R.set(lt, []), R.get(lt).push({ q: B, end: rt });
+          const lt = K(x[q], rt);
+          R.has(lt) || R.set(lt, []), R.get(lt).push({ q, end: rt });
         }
-      const Z = new Map(L.map((B) => [B, {}]));
+      const Z = new Map(L.map((q) => [q, {}]));
       let V = !1;
-      for (const B of R.values()) {
-        if (B.length < 2) continue;
-        const rt = x[B[0].q][B[0].end + "Side"], lt = rt === "left" || rt === "right" ? "y" : "x", kt = ({ q: Et, end: Ft }) => x[Et][Ft + "Offset"], vt = ({ q: Et, end: Ft }) => ie(r.get(x[Et][Ft === "from" ? "to" : "from"]))[lt], Ot = B.map(kt).sort((Et, Ft) => Et - Ft);
-        [...B].sort((Et, Ft) => vt(Et) - vt(Ft) || kt(Et) - kt(Ft)).forEach((Et, Ft) => {
-          Ot[Ft] !== kt(Et) && (V = !0), Z.get(Et.q)[Et.end] = { side: rt, offset: Ot[Ft] };
+      for (const q of R.values()) {
+        if (q.length < 2) continue;
+        const rt = x[q[0].q][q[0].end + "Side"], lt = rt === "left" || rt === "right" ? "y" : "x", kt = ({ q: Et, end: Tt }) => x[Et][Tt + "Offset"], vt = ({ q: Et, end: Tt }) => ie(r.get(x[Et][Tt === "from" ? "to" : "from"]))[lt], At = q.map(kt).sort((Et, Tt) => Et - Tt);
+        [...q].sort((Et, Tt) => vt(Et) - vt(Tt) || kt(Et) - kt(Tt)).forEach((Et, Tt) => {
+          At[Tt] !== kt(Et) && (V = !0), Z.get(Et.q)[Et.end] = { side: rt, offset: At[Tt] };
         });
       }
       if (!V) return [];
-      const G = x.filter((B, rt) => !L.includes(rt)), X = (B) => {
-        const rt = x[B], lt = Z.get(B).from, kt = lt ? me(r.get(rt.from), lt.side, lt.offset) : rt.points[0];
+      const G = x.filter((q, rt) => !L.includes(rt)), X = (q) => {
+        const rt = x[q], lt = Z.get(q).from, kt = lt ? me(r.get(rt.from), lt.side, lt.offset) : rt.points[0];
         return rt.fromSide === "left" || rt.fromSide === "right" ? kt.y : kt.x;
-      }, D = [...L].sort((B, rt) => X(B) - X(rt) || B - rt);
+      }, D = [...L].sort((q, rt) => X(q) - X(rt) || q - rt);
       return [...new Map(
-        [L, [...L].reverse(), D, [...D].reverse()].map((B) => [B.join(), B])
-      ).values()].map((B) => {
+        [L, [...L].reverse(), D, [...D].reverse()].map((q) => [q.join(), q])
+      ).values()].map((q) => {
         const rt = [...x], lt = [];
-        for (const kt of B) {
-          const vt = at.get(x[kt].id), Ot = j({ ...vt, pin: Z.get(kt) }, [...G, ...lt], x[kt]);
-          if (Ot.blocked) return x;
-          rt[kt] = Ot, lt.push(Ot);
+        for (const kt of q) {
+          const vt = at.get(x[kt].id), At = j({ ...vt, pin: Z.get(kt) }, [...G, ...lt], x[kt]);
+          if (At.blocked) return x;
+          rt[kt] = At, lt.push(At);
         }
         return rt;
       });
     }, Mt = /* @__PURE__ */ new Set();
     for (let xt = 0; xt < 2; xt++) {
-      let O = !1;
+      let A = !1;
       for (let E = 0; E < x.length; E++)
         for (let L = E + 1; L < x.length; L++) {
           if (!be(x[E].points, [x[L]]).crossings) continue;
@@ -2362,7 +2362,7 @@ function or(t, e = {}) {
           Mt.add(R);
           let Z = null, V = Y(x) - 0.1;
           const G = (X) => {
-            if (X.some((ct, B) => ct !== x[B] && b(ct) && !b(x[B])) || z(X).crossings >= z(x).crossings)
+            if (X.some((ct, q) => ct !== x[q] && b(ct) && !b(x[q])) || z(X).crossings >= z(x).crossings)
               return;
             const D = Y(X);
             D < V && (Z = X, V = D);
@@ -2371,29 +2371,29 @@ function or(t, e = {}) {
             [E, L],
             [L, E]
           ]) {
-            const ct = at.get(x[X].id), B = at.get(x[D].id);
+            const ct = at.get(x[X].id), q = at.get(x[D].id);
             if (pt(ct)) continue;
-            const rt = x.filter((vt, Ot) => Ot !== X && Ot !== D), lt = [], kt = j(ct, [...rt, x[D]], x[X], et(x[D], ct));
+            const rt = x.filter((vt, At) => At !== X && At !== D), lt = [], kt = j(ct, [...rt, x[D]], x[X], et(x[D], ct));
             if (!kt.blocked) {
               const vt = [...x];
-              if (vt[X] = kt, lt.push(vt), !pt(B)) {
-                const Ot = [...vt];
-                Ot[D] = j(B, [...rt, kt], x[D]), lt.push(Ot);
+              if (vt[X] = kt, lt.push(vt), !pt(q)) {
+                const At = [...vt];
+                At[D] = j(q, [...rt, kt], x[D]), lt.push(At);
               }
             }
-            if (!pt(B)) {
-              const vt = j(B, rt, x[D]), Ot = j(ct, [...rt, vt], x[X], et(vt, ct));
-              if (!Ot.blocked) {
+            if (!pt(q)) {
+              const vt = j(q, rt, x[D]), At = j(ct, [...rt, vt], x[X], et(vt, ct));
+              if (!At.blocked) {
                 const Et = [...x];
-                Et[D] = vt, Et[X] = Ot, lt.push(Et);
+                Et[D] = vt, Et[X] = At, lt.push(Et);
               }
             }
             for (const vt of lt) G(vt);
           }
           if (!Z) for (const X of ft(E, L)) G(X);
-          Z && (x = Z, m(), H++, O = !0);
+          Z && (x = Z, m(), H++, A = !0);
         }
-      if (!O) break;
+      if (!A) break;
     }
   }
   let J = 0;
@@ -2401,21 +2401,21 @@ function or(t, e = {}) {
     for (let b = 0; b < 3; b++) {
       let Y = !1;
       for (let et = 0; et < x.length; et++) {
-        const at = x[et], pt = h.find((O) => O.id === at.id);
+        const at = x[et], pt = h.find((A) => A.id === at.id);
         if (at.blocked || pt.cfg.waypoints?.length || N.has(pt.id)) continue;
-        const ot = x.filter((O, E) => E !== et), K = k(pt);
+        const ot = x.filter((A, E) => E !== et), K = k(pt);
         if (!je(at.points, ot, s.edgeGap).lanePairs) continue;
         let ft = at.points, Mt = jn(ft, ot, s, u), xt = be(ft, ot);
-        for (let O = 1; O < at.points.length - 2; O++) {
-          const E = at.points[O], L = at.points[O + 1], R = Math.abs(E.y - L.y) < wt, Z = R ? "y" : "x", V = /* @__PURE__ */ new Set();
+        for (let A = 1; A < at.points.length - 2; A++) {
+          const E = at.points[A], L = at.points[A + 1], R = Math.abs(E.y - L.y) < wt, Z = R ? "y" : "x", V = /* @__PURE__ */ new Set();
           for (const G of ot)
             for (const [X, D] of Se(G.points))
-              Math.abs(X.y - D.y) < wt === R && Ti(E, L, X, D, s.edgeGap * 2) && (V.add(Ut(X[Z] + s.edgeGap)), V.add(Ut(X[Z] - s.edgeGap)));
+              Math.abs(X.y - D.y) < wt === R && Fi(E, L, X, D, s.edgeGap * 2) && (V.add(Ut(X[Z] + s.edgeGap)), V.add(Ut(X[Z] - s.edgeGap)));
           for (const G of V) {
-            const X = qe(at.points);
-            X[O][Z] = G, X[O + 1][Z] = G;
+            const X = Be(at.points);
+            X[A][Z] = G, X[A + 1][Z] = G;
             const D = We(X);
-            if (!T(D, pt, at.fromSide, at.toSide, K) || be(D, ot).crossings > xt.crossings)
+            if (!F(D, pt, at.fromSide, at.toSide, K) || be(D, ot).crossings > xt.crossings)
               continue;
             const ct = jn(D, ot, s, u);
             ct < Mt - 0.1 && (ft = D, Mt = ct);
@@ -2423,7 +2423,7 @@ function or(t, e = {}) {
         }
         ft !== at.points && (x[et] = {
           ...at,
-          points: F(ft, pt, at.fromSide, at.toSide, K, ot)
+          points: T(ft, pt, at.fromSide, at.toSide, K, ot)
         }, Y = !0, J++);
       }
       if (!Y) break;
@@ -2436,82 +2436,82 @@ function or(t, e = {}) {
     ), ot = [...r.values()], K = (G) => {
       let X = 0;
       for (const [D, ct] of Se(G)) {
-        const B = Math.abs(D.y - ct.y) < wt;
-        if (!B && Math.abs(D.x - ct.x) >= wt) continue;
-        const rt = B ? D.y : D.x, lt = B ? Math.min(D.x, ct.x) : Math.min(D.y, ct.y), kt = B ? Math.max(D.x, ct.x) : Math.max(D.y, ct.y);
+        const q = Math.abs(D.y - ct.y) < wt;
+        if (!q && Math.abs(D.x - ct.x) >= wt) continue;
+        const rt = q ? D.y : D.x, lt = q ? Math.min(D.x, ct.x) : Math.min(D.y, ct.y), kt = q ? Math.max(D.x, ct.x) : Math.max(D.y, ct.y);
         for (const vt of ot) {
-          const Ot = B ? vt.y : vt.x, Et = B ? vt.y + vt.h : vt.x + vt.w, Ft = Math.min(kt, B ? vt.x + vt.w : vt.y + vt.h) - Math.max(lt, B ? vt.x : vt.y), St = rt < Ot ? Ot - rt : rt > Et ? rt - Et : -1;
-          Ft > s.portGap && St > wt && St < s.clearance + 5 && X++;
+          const At = q ? vt.y : vt.x, Et = q ? vt.y + vt.h : vt.x + vt.w, Tt = Math.min(kt, q ? vt.x + vt.w : vt.y + vt.h) - Math.max(lt, q ? vt.x : vt.y), St = rt < At ? At - rt : rt > Et ? rt - Et : -1;
+          Tt > s.portGap && St > wt && St < s.clearance + 5 && X++;
         }
       }
       return X;
     }, ft = (G, X = {}, D = !1, ct = 0.5) => {
-      const B = x.map(
-        (Ot, Et) => G.has(Et) ? { ...Ot, ...X[Et], points: We(G.get(Et)) } : Ot
+      const q = x.map(
+        (At, Et) => G.has(Et) ? { ...At, ...X[Et], points: We(G.get(Et)) } : At
       );
-      for (const Ot of G.keys()) {
-        const Et = B[Ot], Ft = b.get(Et.id), St = Ft.cfg.waypoints || [];
-        if (N.has(Et.id) || St.length && !(D && St.every((Qt) => pt(Qt, Et.points))) || !T(Et.points, Ft, Et.fromSide, Et.toSide, et(Ft)) || at(Et.points) > at(x[Ot].points)) return !1;
+      for (const At of G.keys()) {
+        const Et = q[At], Tt = b.get(Et.id), St = Tt.cfg.waypoints || [];
+        if (N.has(Et.id) || St.length && !(D && St.every((Qt) => pt(Qt, Et.points))) || !F(Et.points, Tt, Et.fromSide, Et.toSide, et(Tt)) || at(Et.points) > at(x[At].points)) return !1;
       }
-      const rt = z(x), lt = z(B);
+      const rt = z(x), lt = z(q);
       if (lt.crossings > rt.crossings || lt.shared > rt.shared + 0.01 || lt.lanePairs > rt.lanePairs || lt.laneDeficit > rt.laneDeficit + 0.1)
         return !1;
       let kt = 0, vt = 0;
-      for (const Ot of G.keys())
-        kt += cn(x[Ot].points, u), vt += cn(B[Ot].points, u);
+      for (const At of G.keys())
+        kt += cn(x[At].points, u), vt += cn(q[At].points, u);
       if (vt > kt + ct) return !1;
       if (ct > 0.5) {
-        let Ot = 0, Et = 0;
-        for (const Ft of G.keys())
-          Ot += K(x[Ft].points), Et += K(B[Ft].points);
-        if (Et > Ot) return !1;
+        let At = 0, Et = 0;
+        for (const Tt of G.keys())
+          At += K(x[Tt].points), Et += K(q[Tt].points);
+        if (Et > At) return !1;
       }
-      return x = B, _++, !0;
-    }, Mt = (G) => !["pill", "circle", "diamond", "icon"].includes(G.shape), xt = ["from", "to"], O = (G, X, D = 0) => X === "from" ? G[D] : G[G.length - 1 - D], E = (G, X, D) => {
+      return x = q, _++, !0;
+    }, Mt = (G) => !["pill", "circle", "diamond", "icon"].includes(G.shape), xt = ["from", "to"], A = (G, X, D = 0) => X === "from" ? G[D] : G[G.length - 1 - D], E = (G, X, D) => {
       const ct = X === "left" || X === "right" ? "x" : "y";
       return Mt(G) || Math.abs(me(G, X, D)[ct] - me(G, X)[ct]) <= 2;
     }, L = () => {
       const G = /* @__PURE__ */ new Map();
       x.forEach((X, D) => {
         for (const ct of xt) {
-          const B = X[ct] + "|" + X[ct + "Side"];
-          G.has(B) || G.set(B, []), G.get(B).push({ i: D, end: ct });
+          const q = X[ct] + "|" + X[ct + "Side"];
+          G.has(q) || G.set(q, []), G.get(q).push({ i: D, end: ct });
         }
       });
       for (const [X, D] of G) {
-        const [ct, B] = X.split("|"), rt = r.get(ct), lt = B === "left" || B === "right", kt = lt ? "y" : "x", vt = ie(rt)[kt], Ot = (lt ? rt.h : rt.w) / 2 - 10, Et = [...new Set(D.map(({ i: Rt, end: Xt }) => Ut(O(x[Rt].points, Xt)[kt])))];
+        const [ct, q] = X.split("|"), rt = r.get(ct), lt = q === "left" || q === "right", kt = lt ? "y" : "x", vt = ie(rt)[kt], At = (lt ? rt.h : rt.w) / 2 - 10, Et = [...new Set(D.map(({ i: Rt, end: Xt }) => Ut(A(x[Rt].points, Xt)[kt])))];
         if (Et.length < 2) continue;
-        const Ft = Ut(vt - Et.reduce((Rt, Xt) => Rt + Xt, 0) / Et.length);
-        if (Math.abs(Ft) < 2 || Et.some((Rt) => Math.abs(Rt + Ft - vt) > Ot + wt) || Et.some((Rt) => !E(rt, B, Rt + Ft - vt))) continue;
+        const Tt = Ut(vt - Et.reduce((Rt, Xt) => Rt + Xt, 0) / Et.length);
+        if (Math.abs(Tt) < 2 || Et.some((Rt) => Math.abs(Rt + Tt - vt) > At + wt) || Et.some((Rt) => !E(rt, q, Rt + Tt - vt))) continue;
         const St = /* @__PURE__ */ new Map(), Qt = {}, Dt = /* @__PURE__ */ new Set();
         for (const { i: Rt, end: Xt } of D) {
-          const te = qe(St.get(Rt) ?? x[Rt].points), Ht = Ut(O(te, Xt)[kt] + Ft - vt), oe = me(rt, B, Ht);
-          if (Object.assign(O(te, Xt), oe), Qt[Rt] = { ...Qt[Rt], [Xt + "Offset"]: Ht }, te.length === 2) {
-            const Bt = Xt === "from" ? "to" : "from", le = r.get(x[Rt][Bt]), fe = x[Rt][Bt + "Side"], de = Ut(O(te, Bt)[kt] + Ft - ie(le)[kt]);
+          const te = Be(St.get(Rt) ?? x[Rt].points), Ht = Ut(A(te, Xt)[kt] + Tt - vt), oe = me(rt, q, Ht);
+          if (Object.assign(A(te, Xt), oe), Qt[Rt] = { ...Qt[Rt], [Xt + "Offset"]: Ht }, te.length === 2) {
+            const qt = Xt === "from" ? "to" : "from", le = r.get(x[Rt][qt]), fe = x[Rt][qt + "Side"], de = Ut(A(te, qt)[kt] + Tt - ie(le)[kt]);
             if (!E(le, fe, de)) {
               St.clear();
               break;
             }
-            Object.assign(O(te, Bt), me(le, fe, de)), Qt[Rt][Bt + "Offset"] = de, Dt.add(x[Rt][Bt] + "|" + fe);
-          } else O(te, Xt, 1)[kt] = oe[kt];
+            Object.assign(A(te, qt), me(le, fe, de)), Qt[Rt][qt + "Offset"] = de, Dt.add(x[Rt][qt] + "|" + fe);
+          } else A(te, Xt, 1)[kt] = oe[kt];
           St.set(Rt, te);
         }
         const ne = new Map(St);
         for (const Rt of Dt) {
-          const [Xt, te] = Rt.split("|"), Ht = r.get(Xt), oe = ie(Ht)[kt], Bt = (lt ? Ht.h : Ht.w) / 2 - 10, le = G.get(Rt) ?? [], fe = ({ i: I, end: U }) => O(St.get(I) ?? x[I].points, U)[kt], de = le.filter(({ i: I }) => !St.has(I) && x[I].points.length >= 4);
+          const [Xt, te] = Rt.split("|"), Ht = r.get(Xt), oe = ie(Ht)[kt], qt = (lt ? Ht.h : Ht.w) / 2 - 10, le = G.get(Rt) ?? [], fe = ({ i: I, end: U }) => A(St.get(I) ?? x[I].points, U)[kt], de = le.filter(({ i: I }) => !St.has(I) && x[I].points.length >= 4);
           if (!de.length || !Mt(Ht)) continue;
           const he = le.reduce((I, U) => I + fe(U), 0), we = Ut((le.length * oe - he) / de.length);
           if (!(Math.abs(we) < 2))
             for (const I of de) {
-              const U = qe(x[I.i].points), nt = Ut(O(U, I.end)[kt] + we - oe);
-              Math.abs(nt) > Bt + wt || (Object.assign(O(U, I.end), me(Ht, te, nt)), O(U, I.end, 1)[kt] = O(U, I.end)[kt], Qt[I.i] = { ...Qt[I.i], [I.end + "Offset"]: nt }, St.set(I.i, U));
+              const U = Be(x[I.i].points), nt = Ut(A(U, I.end)[kt] + we - oe);
+              Math.abs(nt) > qt + wt || (Object.assign(A(U, I.end), me(Ht, te, nt)), A(U, I.end, 1)[kt] = A(U, I.end)[kt], Qt[I.i] = { ...Qt[I.i], [I.end + "Offset"]: nt }, St.set(I.i, U));
             }
         }
         if (!St.size) continue;
-        const Gt = lt ? "x" : "y", Yt = { left: rt.x, right: rt.x + rt.w, top: rt.y, bottom: rt.y + rt.h }[B], Kt = B === "left" || B === "top" ? -1 : 1, ae = (Rt) => new Map(
+        const Gt = lt ? "x" : "y", Yt = { left: rt.x, right: rt.x + rt.w, top: rt.y, bottom: rt.y + rt.h }[q], Kt = q === "left" || q === "top" ? -1 : 1, ae = (Rt) => new Map(
           [...Rt].map(([Xt, te]) => {
-            const Ht = D.find((Bt) => Bt.i === Xt)?.end, oe = qe(te);
-            return Ht && oe.length >= 4 && Math.abs(O(oe, Ht, 1)[Gt] - O(oe, Ht, 2)[Gt]) < wt && Math.abs(O(oe, Ht, 1)[Gt] - Yt) < s.standoff && (O(oe, Ht, 1)[Gt] = Yt + Kt * s.standoff, O(oe, Ht, 2)[Gt] = Yt + Kt * s.standoff), [Xt, oe];
+            const Ht = D.find((qt) => qt.i === Xt)?.end, oe = Be(te);
+            return Ht && oe.length >= 4 && Math.abs(A(oe, Ht, 1)[Gt] - A(oe, Ht, 2)[Gt]) < wt && Math.abs(A(oe, Ht, 1)[Gt] - Yt) < s.standoff && (A(oe, Ht, 1)[Gt] = Yt + Kt * s.standoff, A(oe, Ht, 2)[Gt] = Yt + Kt * s.standoff), [Xt, oe];
           })
         );
         for (const Rt of St.size > ne.size ? [St, ne] : [ne])
@@ -2530,82 +2530,82 @@ function or(t, e = {}) {
     });
     for (const [G, X] of R) {
       if (X.length < 2) continue;
-      const [, D, ct] = G.split("|"), B = ct === "left" || ct === "right" ? "x" : "y", rt = (vt) => Ut(O(x[vt].points, D, 1)[B]), lt = [...new Set(X.map(rt))];
+      const [, D, ct] = G.split("|"), q = ct === "left" || ct === "right" ? "x" : "y", rt = (vt) => Ut(A(x[vt].points, D, 1)[q]), lt = [...new Set(X.map(rt))];
       if (lt.length < 2) continue;
-      const kt = (vt) => X.reduce((Ot, Et) => Ot + Math.abs(rt(Et) - vt), 0);
-      lt.sort((vt, Ot) => kt(vt) - kt(Ot) || vt - Ot);
+      const kt = (vt) => X.reduce((At, Et) => At + Math.abs(rt(Et) - vt), 0);
+      lt.sort((vt, At) => kt(vt) - kt(At) || vt - At);
       for (const vt of lt) {
-        const Ot = /* @__PURE__ */ new Map();
+        const At = /* @__PURE__ */ new Map();
         for (const Et of X) {
           if (rt(Et) === vt) continue;
-          const Ft = qe(x[Et].points);
-          O(Ft, D, 1)[B] = vt, O(Ft, D, 2)[B] = vt, Ot.set(Et, Ft);
+          const Tt = Be(x[Et].points);
+          A(Tt, D, 1)[q] = vt, A(Tt, D, 2)[q] = vt, At.set(Et, Tt);
         }
-        if (ft(Ot)) break;
+        if (ft(At)) break;
       }
     }
     if (e.jogs !== !1)
       for (let G = 0; G < x.length; G++) {
-        const X = Math.max(s.portGap, s.edgeGap), D = (B, rt, lt, kt) => {
-          const vt = qe(B), Ot = {};
+        const X = Math.max(s.portGap, s.edgeGap), D = (q, rt, lt, kt) => {
+          const vt = Be(q), At = {};
           vt[rt][lt] = kt, vt[rt + 1][lt] = kt;
-          for (const [Et, Ft] of [
+          for (const [Et, Tt] of [
             [rt, "from"],
             [rt + 1, "to"]
           ]) {
-            if (Et !== (Ft === "from" ? 0 : B.length - 1)) continue;
-            const St = x[G][Ft], Qt = x[G][Ft + "Side"], Dt = r.get(St);
+            if (Et !== (Tt === "from" ? 0 : q.length - 1)) continue;
+            const St = x[G][Tt], Qt = x[G][Tt + "Side"], Dt = r.get(St);
             if (!Dt || !Mt(Dt) || (Qt === "left" || Qt === "right") != (lt === "y"))
               return null;
             const ne = Ut(kt - ie(Dt)[lt]);
             if (Math.abs(ne) > (lt === "y" ? Dt.h : Dt.w) / 2 - 10 + wt || x.some(
               (Yt, Kt) => xt.some(
-                (ae) => (Kt !== G || ae !== Ft) && Yt[ae] === St && Yt[ae + "Side"] === Qt && Math.abs(O(Yt.points, ae)[lt] - kt) < X - 0.01
+                (ae) => (Kt !== G || ae !== Tt) && Yt[ae] === St && Yt[ae + "Side"] === Qt && Math.abs(A(Yt.points, ae)[lt] - kt) < X - 0.01
               )
             )) return null;
-            Object.assign(vt[Et], me(Dt, Qt, ne)), Ot[Ft + "Offset"] = ne;
+            Object.assign(vt[Et], me(Dt, Qt, ne)), At[Tt + "Offset"] = ne;
           }
-          return { next: vt, extra: Ot };
+          return { next: vt, extra: At };
         }, ct = x[G].points;
-        for (let B = 1; B < ct.length - 2; B++) {
-          if (re(ct[B], ct[B + 1]) >= 12) continue;
-          const rt = Math.abs(ct[B].x - ct[B + 1].x) < wt ? "y" : "x";
+        for (let q = 1; q < ct.length - 2; q++) {
+          if (re(ct[q], ct[q + 1]) >= 12) continue;
+          const rt = Math.abs(ct[q].x - ct[q + 1].x) < wt ? "y" : "x";
           if ([
-            D(ct, B - 1, rt, ct[B + 1][rt]),
-            D(ct, B + 1, rt, ct[B][rt])
+            D(ct, q - 1, rt, ct[q + 1][rt]),
+            D(ct, q + 1, rt, ct[q][rt])
           ].some((kt) => kt && ft(/* @__PURE__ */ new Map([[G, kt.next]]), { [G]: kt.extra }, !0)))
             break;
         }
       }
     L();
     const Z = (G, X, D, ct) => {
-      let B = -1 / 0, rt = 1 / 0;
+      let q = -1 / 0, rt = 1 / 0;
       for (const lt of u)
         if (!(Math.min(ct, G ? lt.x + lt.w : lt.y + lt.h) - Math.max(D, G ? lt.x : lt.y) <= 1))
           for (const vt of G ? [lt.y, lt.y + lt.h] : [lt.x, lt.x + lt.w])
-            !lt.border && vt === (G ? lt.y + lt.h : lt.x + lt.w) && X < vt - wt || !lt.border && vt === (G ? lt.y : lt.x) && X > vt + wt || (vt <= X + wt && (B = Math.max(B, vt)), vt >= X - wt && (rt = Math.min(rt, vt)));
-      return [B, rt];
+            !lt.border && vt === (G ? lt.y + lt.h : lt.x + lt.w) && X < vt - wt || !lt.border && vt === (G ? lt.y : lt.x) && X > vt + wt || (vt <= X + wt && (q = Math.max(q, vt)), vt >= X - wt && (rt = Math.min(rt, vt)));
+      return [q, rt];
     };
     for (let G = 0; G < x.length; G++)
       for (let X = 1; X < x[G].points.length - 2; X++) {
-        const D = x[G].points, ct = D[X], B = D[X + 1], rt = Math.abs(ct.y - B.y) < wt, lt = rt ? "y" : "x", kt = rt ? "x" : "y";
-        if (re(ct, B) <= 12) continue;
-        const [vt, Ot] = Z(
+        const D = x[G].points, ct = D[X], q = D[X + 1], rt = Math.abs(ct.y - q.y) < wt, lt = rt ? "y" : "x", kt = rt ? "x" : "y";
+        if (re(ct, q) <= 12) continue;
+        const [vt, At] = Z(
           rt,
           ct[lt],
-          Math.min(ct[kt], B[kt]),
-          Math.max(ct[kt], B[kt])
-        ), Et = Ot - vt, Ft = Ut((vt + Ot) / 2);
-        if (!(Et <= 4 * s.standoff) || Math.abs(Ft - ct[lt]) < 1) continue;
-        const St = qe(D);
-        St[X][lt] = Ft, St[X + 1][lt] = Ft, ft(/* @__PURE__ */ new Map([[G, St]]), {}, !1, po);
+          Math.min(ct[kt], q[kt]),
+          Math.max(ct[kt], q[kt])
+        ), Et = At - vt, Tt = Ut((vt + At) / 2);
+        if (!(Et <= 4 * s.standoff) || Math.abs(Tt - ct[lt]) < 1) continue;
+        const St = Be(D);
+        St[X][lt] = Tt, St[X + 1][lt] = Tt, ft(/* @__PURE__ */ new Map([[G, St]]), {}, !1, po);
       }
     const V = s.edgeGap;
     for (const G of [!0, !1]) {
       const X = G ? "y" : "x", D = G ? "x" : "y", ct = [];
       x.forEach(
-        (B, rt) => Se(B.points).forEach(([lt, kt], vt) => {
-          vt === 0 || vt === B.points.length - 2 || re(lt, kt) <= 12 || Math.abs(lt.y - kt.y) < wt === G && ct.push({
+        (q, rt) => Se(q.points).forEach(([lt, kt], vt) => {
+          vt === 0 || vt === q.points.length - 2 || re(lt, kt) <= 12 || Math.abs(lt.y - kt.y) < wt === G && ct.push({
             i: rt,
             k: vt,
             at: Ut(lt[X]),
@@ -2613,16 +2613,16 @@ function or(t, e = {}) {
             hi: Math.max(lt[D], kt[D])
           });
         })
-      ), ct.sort((B, rt) => B.at - rt.at);
-      for (let B = 1; B < ct.length; B++) {
-        const rt = ct[B], lt = ct.slice(0, B).filter(
+      ), ct.sort((q, rt) => q.at - rt.at);
+      for (let q = 1; q < ct.length; q++) {
+        const rt = ct[q], lt = ct.slice(0, q).filter(
           (Et) => Et.i !== rt.i && Et.at < rt.at && Math.min(Et.hi, rt.hi) - Math.max(Et.lo, rt.lo) > 1
         ).at(-1);
         if (!lt) continue;
         const kt = rt.at - lt.at;
         if (Math.abs(kt - V) <= 1 || kt > 2.5 * V) continue;
-        const vt = Ut(lt.at + V), Ot = qe(x[rt.i].points);
-        Math.abs(Ot[rt.k][X] - rt.at) > wt || Math.abs(Ot[rt.k + 1][X] - rt.at) > wt || (Ot[rt.k][X] = vt, Ot[rt.k + 1][X] = vt, ft(/* @__PURE__ */ new Map([[rt.i, Ot]])) && (rt.at = vt));
+        const vt = Ut(lt.at + V), At = Be(x[rt.i].points);
+        Math.abs(At[rt.k][X] - rt.at) > wt || Math.abs(At[rt.k + 1][X] - rt.at) > wt || (At[rt.k][X] = vt, At[rt.k + 1][X] = vt, ft(/* @__PURE__ */ new Map([[rt.i, At]])) && (rt.at = vt));
       }
     }
   }
@@ -2860,7 +2860,7 @@ function Ca(t, e, o = 0.75) {
   const a = (t - n) / Math.max(1e-5, e - n);
   return 1 - a * a * (3 - 2 * a);
 }
-function qa(t, e) {
+function Ba(t, e) {
   return Math.hypot(
     Math.max(e.x - t.x, 0, t.x - e.x - e.w),
     Math.max(e.y - t.y, 0, t.y - e.y - e.h)
@@ -2882,11 +2882,11 @@ function ts(t) {
     )
   };
 }
-function Ba(t, e, o, n = 0.75, a = []) {
+function qa(t, e, o, n = 0.75, a = []) {
   const s = ts(t), r = new Set(a), d = {}, c = [];
   for (const u of t.graph.nodes) {
     if (!s.visible(u.id)) continue;
-    const i = Ca(qa(e, t.layout.nodes[u.id]), o, n);
+    const i = Ca(Ba(e, t.layout.nodes[u.id]), o, n);
     if (!(i <= 1e-4)) {
       if (s.locked(u.id) || r.has(u.id) || s.parents(u.id).some((f) => r.has(f))) {
         c.push(u.id);
@@ -2897,23 +2897,23 @@ function Ba(t, e, o, n = 0.75, a = []) {
   }
   return { weights: d, locked: c };
 }
-function Oo(t, e) {
+function Ao(t, e) {
   const o = Math.min(t.x + t.w, e.x + e.w) - Math.max(t.x, e.x), n = Math.min(t.y + t.h, e.y + e.h) - Math.max(t.y, e.y);
   return o > 5e-3 && n > 5e-3 ? o * n : 0;
 }
-function Ao(t, e) {
+function Oo(t, e) {
   const o = ts(t), n = [...t.graph.nodes, ...t.graph.groups].filter((s) => o.visible(s.id)), a = /* @__PURE__ */ new Map();
   for (let s = 0; s < n.length; s++)
     for (let r = s + 1; r < n.length; r++) {
       const d = n[s], c = n[r];
       if (o.parents(d.id).includes(c.id) || o.parents(c.id).includes(d.id)) continue;
-      const u = Oo(e[d.id], e[c.id]);
+      const u = Ao(e[d.id], e[c.id]);
       u && a.set(d.id + "\0" + c.id, u);
     }
   return a;
 }
 function fr(t, e, o) {
-  const n = Ao(t, e), a = Ao(t, o);
+  const n = Oo(t, e), a = Oo(t, o);
   for (const [s, r] of a) if (r > (n.get(s) || 0) + 0.01) return !1;
   return !0;
 }
@@ -2924,7 +2924,7 @@ function dr(t, e, o, n) {
   return { x: fn(n.x, c, u), y: fn(n.y, i, f) };
 }
 function hr(t, e = {}) {
-  const o = Ra(e), n = De(t), a = n.layout.nodes, s = De(a), r = e.point || { x: 0, y: 0 }, d = e.worldRadius ?? o.radius, c = Ba(
+  const o = Ra(e), n = De(t), a = n.layout.nodes, s = De(a), r = e.point || { x: 0, y: 0 }, d = e.worldRadius ?? o.radius, c = qa(
     t,
     r,
     d,
@@ -3004,25 +3004,25 @@ function hr(t, e = {}) {
     const ht = dr(t, a, S, { x: s[S].x + x, y: s[S].y + N });
     a[S].x = ht.x, a[S].y = ht.y;
   }
-  const y = new Set(Object.keys(u)), P = [...n.graph.nodes, ...n.graph.groups].filter((S) => i.visible(S.id)), A = new Map(P.map((S) => [S.id, new Set(i.parents(S.id))])), w = [];
+  const y = new Set(Object.keys(u)), P = [...n.graph.nodes, ...n.graph.groups].filter((S) => i.visible(S.id)), O = new Map(P.map((S) => [S.id, new Set(i.parents(S.id))])), w = [];
   for (let S = 0; S < P.length; S++)
     for (let M = S + 1; M < P.length; M++) {
       const x = P[S].id, N = P[M].id;
-      !y.has(x) && !y.has(N) || A.get(x).has(N) || A.get(N).has(x) || w.push([x, N, Oo(s[x], s[N])]);
+      !y.has(x) && !y.has(N) || O.get(x).has(N) || O.get(N).has(x) || w.push([x, N, Ao(s[x], s[N])]);
     }
-  const k = () => w.every(([S, M, x]) => Oo(a[S], a[M]) <= x + 0.01);
-  let T = !1, F = 1;
+  const k = () => w.every(([S, M, x]) => Ao(a[S], a[M]) <= x + 0.01);
+  let F = !1, T = 1;
   const j = De(a);
   for (let S = 0; S < 12; S++) {
     for (const M of Object.keys(u))
-      a[M].x = s[M].x + (j[M].x - s[M].x) * F, a[M].y = s[M].y + (j[M].y - s[M].y) * F;
+      a[M].x = s[M].x + (j[M].x - s[M].x) * T, a[M].y = s[M].y + (j[M].y - s[M].y) * T;
     if (k()) {
-      T = !0;
+      F = !0;
       break;
     }
-    F *= 0.5;
+    T *= 0.5;
   }
-  T || (n.layout.nodes = De(s));
+  F || (n.layout.nodes = De(s));
   const $ = Object.keys(u).filter((S) => Io(s[S], n.layout.nodes[S]) > 1e-3), v = Math.max(0, ...$.map((S) => Io(s[S], n.layout.nodes[S])));
   return {
     document: n,
@@ -3030,8 +3030,8 @@ function hr(t, e = {}) {
     locked: c.locked,
     moved: $,
     maxDisplacement: v,
-    blocked: !T || F < 0.02,
-    attenuation: F,
+    blocked: !F || T < 0.02,
+    attenuation: T,
     mode: o.mode
   };
 }
@@ -3115,13 +3115,13 @@ const gr = {
   defaults: lr,
   settings: Ra,
   weight: Ca,
-  rectDistance: qa,
-  field: Ba,
+  rectDistance: Ba,
+  field: qa,
   dab: hr,
   journey: ur,
   lookahead: pr,
   summarizeFrames: Ha,
-  violationPairs: Ao,
+  violationPairs: Oo,
   noWorse: fr
 }, mr = gr;
 var yr = {
@@ -3257,7 +3257,7 @@ function Er(t, e, o) {
   for (; n && ce(n + "…", o) > e; ) n = n.slice(0, -1);
   return n.trimEnd() + "…";
 }
-const Ps = ["drafting", "fieldnotes", "signal", "ink", "blueprint"], Zn = "drafting", $o = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950], Qe = 500, Ir = (t) => en[t]?.dark ? 950 : 50, Or = (t) => en[t]?.dark ? 900 : 100, Go = [
+const Ps = ["drafting", "fieldnotes", "signal", "ink", "blueprint"], Zn = "drafting", $o = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950], Qe = 500, Ir = (t) => en[t]?.dark ? 950 : 50, Ar = (t) => en[t]?.dark ? 900 : 100, Go = [
   "primary",
   "secondary",
   "slate",
@@ -3272,15 +3272,15 @@ const Ps = ["drafting", "fieldnotes", "signal", "ink", "blueprint"], Zn = "draft
   "red",
   "rose",
   "violet"
-], to = (t) => Go.includes(t), Ts = ["dashed", "solid"], es = () => ({
+], to = (t) => Go.includes(t), Fs = ["dashed", "solid"], es = () => ({
   theme: Zn,
   overrides: {},
   colors: []
-}), Fs = {
+}), Ts = {
   paddingX: { min: 4, max: 48 },
   paddingY: { min: 4, max: 48 },
   radius: { min: 0, max: 24 }
-}, Ar = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i, en = {
+}, Or = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i, en = {
   drafting: {
     label: "Drafting",
     description: "Navy ink on cool paper, with drafting blue and marker gold",
@@ -3385,6 +3385,32 @@ const Ps = ["drafting", "fieldnotes", "signal", "ink", "blueprint"], Zn = "draft
     primary: ["#2B3A55", 900],
     secondary: ["#C23B22", 600]
   },
+  // The default theme on a dark page: the same type, spacing and families as drafting, so it
+  // draws every box in the same place. Graphite surfaces, lighter than the canvas the higher
+  // they sit, with drafting blue and marker gold lifted to read on them. Not a file's theme.
+  "drafting-dark": {
+    label: "Drafting dark",
+    description: "Drafting on a graphite page, for a dark host",
+    dark: !0,
+    canvas: "#16191E",
+    text: "#E7EAEF",
+    muted: "#9BA3B0",
+    connection: "#AEB6C2",
+    node: { fill: "#21252C", stroke: "#3D4450", ink: "#E7EAEF" },
+    group: { fill: "#1B1F25", stroke: "#30363F", ink: "#C8CED8" },
+    paddingX: 12,
+    paddingY: 20,
+    radius: 4,
+    shadow: !1,
+    titleFont: "sans",
+    annotationFont: "sans",
+    titleSize: 13,
+    titleLine: 16,
+    annotationSize: 11,
+    chroma: 0.9,
+    primary: ["#7FA4E6", 300],
+    secondary: ["#F0B43C", 400]
+  },
   blueprint: {
     label: "Blueprint",
     description: "White lines on blueprint blue, cyan and yellow, monospace titles",
@@ -3453,7 +3479,7 @@ const js = {
   800: 0.38,
   900: 0.32,
   950: 0.26
-}, os = (t) => t <= 300, Ka = (t) => t >= 45 && t <= 110, To = { 400: 0.8, 500: 0.74 }, $r = (t, e) => To[t] === void 0 ? void 0 : To[t] - (e < 65 ? 0.07 : 0), Gr = (t, e) => os(t) || Ka(e) && t in To, Ge = {
+}, os = (t) => t <= 300, Ka = (t) => t >= 45 && t <= 110, Fo = { 400: 0.8, 500: 0.74 }, $r = (t, e) => Fo[t] === void 0 ? void 0 : Fo[t] - (e < 65 ? 0.07 : 0), Gr = (t, e) => os(t) || Ka(e) && t in Fo, Ge = {
   /** Dark title text on a pale fill. */
   paleInk: 7,
   /** White title text on a dark fill. */
@@ -3477,7 +3503,7 @@ const js = {
   red: [32, 0.17],
   rose: [358, 0.12],
   violet: [305, 0.13]
-}, Tr = (t) => In([0.24, 0.035, t]), Fr = "#FFFFFF";
+}, Fr = (t) => In([0.24, 0.035, t]), Tr = "#FFFFFF";
 function Ue(t, e, o) {
   if (eo(t, e) >= o) return t;
   const [n, a, s] = ns(t), r = Po(e) > 0.18 ? -0.01 : 0.01;
@@ -3487,7 +3513,7 @@ function Ue(t, e, o) {
   return d;
 }
 function Ds(t, e, o, n, a, s, r) {
-  const d = Gr(t, n), c = d ? Tr(n) : Fr, u = os(t) ? Ge.paleInk : Ge.darkInk;
+  const d = Gr(t, n), c = d ? Fr(n) : Tr, u = os(t) ? Ge.paleInk : Ge.darkInk;
   let i = r ? ns(r)[0] : e, f = r ?? In([i, o * Xn(i), n]);
   for (; eo(f, c) < u && i > 0.05 && i < 0.995; )
     i += d ? 5e-3 : -0.01, f = In([i, o * Xn(i), n]);
@@ -3591,7 +3617,7 @@ function Re(t) {
   };
   return Nn.size > 50 && Nn.clear(), Nn.set(o, h), h;
 }
-const Ye = (t) => Math.round(t * 10) / 10, nn = (t, e) => Math.abs(t.x - e.x) + Math.abs(t.y - e.y), Fo = (t, e, o = 0) => t.x >= e.x - o && t.x <= e.x + e.w + o && t.y >= e.y - o && t.y <= e.y + e.h + o, Nr = (t, e) => Fo({ x: e.x, y: e.y }, t) && Fo({ x: e.x + e.w, y: e.y + e.h }, t), Xe = (t, e, o = 0) => t.x < e.x + e.w + o && t.x + t.w + o > e.x && t.y < e.y + e.h + o && t.y + t.h + o > e.y;
+const Ye = (t) => Math.round(t * 10) / 10, nn = (t, e) => Math.abs(t.x - e.x) + Math.abs(t.y - e.y), To = (t, e, o = 0) => t.x >= e.x - o && t.x <= e.x + e.w + o && t.y >= e.y - o && t.y <= e.y + e.h + o, Nr = (t, e) => To({ x: e.x, y: e.y }, t) && To({ x: e.x + e.w, y: e.y + e.h }, t), Xe = (t, e, o = 0) => t.x < e.x + e.w + o && t.x + t.w + o > e.x && t.y < e.y + e.h + o && t.y + t.h + o > e.y;
 function Cs(t, e = 0) {
   if (!t.length) return { x: 70, y: 160, w: 240, h: 160 };
   let o = 1 / 0, n = 1 / 0, a = -1 / 0, s = -1 / 0;
@@ -3613,15 +3639,15 @@ function Rr(t, e) {
   }
   return o;
 }
-const Mn = (t) => JSON.parse(JSON.stringify(t)), ye = 24, Cr = 48, no = 97, On = 10, oo = 18, Va = (t, e = Cr) => ({
+const Mn = (t) => JSON.parse(JSON.stringify(t)), ye = 24, Cr = 48, no = 97, An = 10, oo = 18, Va = (t, e = Cr) => ({
   x: t.x + ye,
   y: t.y + e
-}), qr = 48, Br = { shape: "box", color: "auto", icon: "" };
+}), Br = 48, qr = { shape: "box", color: "auto", icon: "" };
 function Qa(t) {
   return t === "circle" || t === "icon" ? { w: 80, h: 80 } : t === "diamond" ? { w: 112, h: 112 } : t === "text" ? { w: 164, h: 38 } : { w: 164, h: 56 };
 }
 const ss = (t, e) => e ? t.graph.nodes.find((o) => o.id === e) : void 0, Za = (t, e) => e ? t.graph.groups.find((o) => o.id === e) : void 0, go = (t, e) => e ? t.graph.edges.find((o) => o.id === e) : void 0, Hr = (t, e) => ss(t, e) ?? Za(t, e), zr = (t, e) => ({
-  ...Br,
+  ...qr,
   ...t.styles[e]
 }), Wr = (t, e) => e ? t.layout.containers[e]?.cellsBand : void 0, Ur = (t, e) => Wr(t, ss(t, e)?.parentId) !== void 0;
 function gn(t, e) {
@@ -3676,7 +3702,7 @@ function ec(t, e, o) {
       return s;
   }
 }
-const qs = 3, Kn = (t, e = 1) => t.groupHeader + (e - 1) * t.groupTitle.lineHeight;
+const Bs = 3, Kn = (t, e = 1) => t.groupHeader + (e - 1) * t.groupTitle.lineHeight;
 function nc(t, e, o, n = 1) {
   const a = Math.max(40, e - no), s = tn(t, a, o.groupTitle, !0);
   if (s.length <= n) return s;
@@ -3684,16 +3710,16 @@ function nc(t, e, o, n = 1) {
   return r[n - 1] = Er(s.slice(n - 1).join(" "), a, o.groupTitle), r;
 }
 const oc = 168, ti = (t, e = !1) => e ? { ...t.annotation, size: t.annotation.size + 1.5, lineHeight: t.annotation.lineHeight + 2 } : t.annotation, sc = 140, ei = (t, e, o = !1) => tn(t, o ? oc : sc, ti(e, o)), ve = { out: 36, down: 22, label: 4 };
-function Te(t, e = Re(), o = !1) {
+function Fe(t, e = Re(), o = !1) {
   const n = ti(e, o), a = ei(t, e, o), s = Math.max(...a.map((r) => ce(r, n))) + 16;
   return {
     w: Math.round(Math.max(36, s)),
     h: Math.round(a.length * n.lineHeight + 6)
   };
 }
-function Bs(t, e) {
+function qs(t, e) {
   if (!t) return { right: ve.out, above: 0, below: ve.down };
-  const { w: o, h: n } = Te(t, e, !0);
+  const { w: o, h: n } = Fe(t, e, !0);
   return {
     right: ve.out + ve.label + o,
     above: Math.max(0, n / 2 - ve.down / 2),
@@ -3725,12 +3751,12 @@ function cc(t, e, o, n = 0) {
   }
   const i = Array(r).fill(0), f = Array(a.length ? c + 1 : 0).fill(0);
   for (const w of a) {
-    const { row: k, col: T, span: F } = d.get(w.id);
-    F === 1 && (i[T] = Math.max(i[T], s.get(w.id).w)), f[k] = Math.max(f[k], s.get(w.id).h);
+    const { row: k, col: F, span: T } = d.get(w.id);
+    T === 1 && (i[F] = Math.max(i[F], s.get(w.id).w)), f[k] = Math.max(f[k], s.get(w.id).h);
   }
   for (const w of a) {
-    const { col: k, span: T } = d.get(w.id), F = s.get(w.id).w - i.slice(k, k + T).reduce((j, $) => j + $, 0);
-    F > 0 && (i[k + T - 1] += F);
+    const { col: k, span: F } = d.get(w.id), T = s.get(w.id).w - i.slice(k, k + F).reduce((j, $) => j + $, 0);
+    T > 0 && (i[k + F - 1] += T);
   }
   const h = n - i.reduce((w, k) => w + k, 0);
   h > 0 && (i[r - 1] += h);
@@ -3739,16 +3765,16 @@ function cc(t, e, o, n = 0) {
   for (const w of f) p.push(p.at(-1) + w);
   const m = l.at(-1), g = p.at(-1), y = /* @__PURE__ */ new Map();
   for (const w of a) {
-    const { row: k, col: T, span: F } = d.get(w.id);
-    y.set(w.id, { x: l[T], y: p[k], w: l[T + F] - l[T], h: f[k] });
+    const { row: k, col: F, span: T } = d.get(w.id);
+    y.set(w.id, { x: l[F], y: p[k], w: l[F + T] - l[F], h: f[k] });
   }
-  const P = ao(o.groupTitle.lineHeight), A = r > 1 || e.direction === "right";
+  const P = ao(o.groupTitle.lineHeight), O = r > 1 || e.direction === "right";
   return t.forEach((w, k) => {
     if (!w.marker) return;
-    const T = t.slice(k + 1).find(($) => !$.marker), F = T ? y.get(T.id) : void 0, j = yo / 2;
+    const F = t.slice(k + 1).find(($) => !$.marker), T = F ? y.get(F.id) : void 0, j = yo / 2;
     y.set(
       w.id,
-      A ? { x: (F?.x ?? m) - j, y: -P, w: yo, h: g + P + Hs } : { x: 0, y: (F?.y ?? g) - j, w: m + Hs, h: yo }
+      O ? { x: (T?.x ?? m) - j, y: -P, w: yo, h: g + P + Hs } : { x: 0, y: (T?.y ?? g) - j, w: m + Hs, h: yo }
     );
   }), { boxes: y, w: m, h: g };
 }
@@ -3762,8 +3788,8 @@ function dc(t, e, o) {
       y.push({ row: d, col: c, span: n - c }), d++, c = 0;
     else
       for (let P = g.span ?? 1; P > 0; ) {
-        const A = Math.min(P, n - c);
-        y.push({ row: d, col: c, span: A }), P -= A, c += A, c === n && (d++, c = 0);
+        const O = Math.min(P, n - c);
+        y.push({ row: d, col: c, span: O }), P -= O, c += O, c === n && (d++, c = 0);
       }
     r.set(g.id, y);
   }
@@ -3780,7 +3806,7 @@ function dc(t, e, o) {
     h: f
   }), l = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
   for (const g of t) {
-    const y = i(g.id), P = r.get(g.id).filter((A) => A !== y);
+    const y = i(g.id), P = r.get(g.id).filter((O) => O !== y);
     l.set(g.id, h(y)), P.length && p.set(g.id, P.map(h));
   }
   const m = e.ruler ? Math.round(o.annotation.lineHeight + 6) : 0;
@@ -3885,28 +3911,28 @@ function vc(t, e, o = {}) {
   for (const p of e) {
     const m = n.get(p.source), g = n.get(p.target);
     if (!m || !g || m === g || p.from !== "auto" || p.to !== "auto") continue;
-    const y = [m.id, ...a(m.id)], P = [g.id, ...a(g.id)].find((F) => y.includes(F) && F !== m.id && F !== g.id), A = P && n.get(P)?.type === "group" ? n.get(P) : void 0, w = (F) => {
-      let j = F;
-      for (; j.parent !== (A?.id ?? "root"); ) j = n.get(j.parent);
+    const y = [m.id, ...a(m.id)], P = [g.id, ...a(g.id)].find((T) => y.includes(T) && T !== m.id && T !== g.id), O = P && n.get(P)?.type === "group" ? n.get(P) : void 0, w = (T) => {
+      let j = T;
+      for (; j.parent !== (O?.id ?? "root"); ) j = n.get(j.parent);
       return j;
-    }, [k, T] = [w(m), w(g)];
-    if (A && k !== T) {
-      const F = (z, mt, it) => z === mt || i(mt, c(it)).some((ht) => !u(z, mt, ht, ""));
+    }, [k, F] = [w(m), w(g)];
+    if (O && k !== F) {
+      const T = (z, mt, it) => z === mt || i(mt, c(it)).some((ht) => !u(z, mt, ht, ""));
       if (!t.some(
-        (z) => z.parent === A.id && z !== k && z !== T && kc(k, T, z)
-      ) && F(m, k, g) && F(g, T, m)) continue;
-      const $ = Math.abs(c(k).y - c(T).y) > Math.abs(c(k).x - c(T).x), v = (z, mt, it) => (c(z)[it] - c(mt)[it]) / Math.max(1, it === "x" ? mt.w : mt.h), S = $ ? "x" : "y", M = v(m, k, S) + v(g, T, S), x = c(T)[$ ? "y" : "x"] > c(k)[$ ? "y" : "x"], N = Math.abs(M) > 0.1 ? M > 0 : x;
-      d(A.id, $ ? N ? "right" : "left" : N ? "bottom" : "top");
+        (z) => z.parent === O.id && z !== k && z !== F && kc(k, F, z)
+      ) && T(m, k, g) && T(g, F, m)) continue;
+      const $ = Math.abs(c(k).y - c(F).y) > Math.abs(c(k).x - c(F).x), v = (z, mt, it) => (c(z)[it] - c(mt)[it]) / Math.max(1, it === "x" ? mt.w : mt.h), S = $ ? "x" : "y", M = v(m, k, S) + v(g, F, S), x = c(F)[$ ? "y" : "x"] > c(k)[$ ? "y" : "x"], N = Math.abs(M) > 0.1 ? M > 0 : x;
+      d(O.id, $ ? N ? "right" : "left" : N ? "bottom" : "top");
       continue;
     }
-    for (const [F, j] of [
+    for (const [T, j] of [
       [m, g],
       [g, m]
     ]) {
-      const $ = F.parent === "root" ? void 0 : n.get(F.parent);
-      if (!$ || A && $.id === A.id || s(j.id, $.id)) continue;
+      const $ = T.parent === "root" ? void 0 : n.get(T.parent);
+      if (!$ || O && $.id === O.id || s(j.id, $.id)) continue;
       const v = i($, c(j));
-      !v.length || v.some((S) => !u(F, $, S, j.id)) || (v.some((S) => S === "left" || S === "right") ? d($.id, c(F).y < c($).y + 24 ? "top" : "bottom") : d($.id, c(j).x < c(F).x ? "left" : "right"));
+      !v.length || v.some((S) => !u(T, $, S, j.id)) || (v.some((S) => S === "left" || S === "right") ? d($.id, c(T).y < c($).y + 24 ? "top" : "bottom") : d($.id, c(j).x < c(T).x ? "left" : "right"));
     }
   }
   const f = o.standoff ?? bc, h = Math.max(o.edgeGap ?? Ws, o.portGap ?? Ws), l = (p) => p ? 2 * f + (p - 1) * h : ye;
@@ -3928,14 +3954,14 @@ function kc(t, e, o) {
   return o.x < c.x && o.x + o.w > d.x && o.y < c.y && o.y + o.h > d.y;
 }
 const Us = 20, Cn = 20, Sc = 12, Ec = 16;
-function Ic(t, e, o, n, a = (s) => Te(s)) {
+function Ic(t, e, o, n, a = (s) => Fe(s)) {
   const s = /* @__PURE__ */ new Map();
   for (const r of t.filter((d) => d.scope === "root")) {
     const d = r.axis === "right", c = (g) => d ? g.x : g.y, u = (g) => d ? g.x + g.w : g.y + g.h, i = (g) => d ? g.y : g.x, f = (g) => d ? g.y + g.h : g.x + g.w, h = (g) => (c(g) + u(g)) / 2, l = (g) => (i(g) + f(g)) / 2, p = [...o.values()].filter((g) => g.parent === r.scope);
     (r.bands?.map((g) => g.map((y) => o.get(y))) ?? [p]).forEach((g) => {
-      const y = Math.min(...g.map(i)), P = Math.max(...g.map(f)), A = Math.min(...g.map(c)), w = Math.max(...g.map(u)), k = new Set(g.map(($) => $.id)), T = ($) => [...o.values()].some(
-        (v) => v.parent === r.scope && !k.has(v.id) && c(v) < w && u(v) > A && ($ ? f(v) <= y : i(v) >= P)
-      ), F = { before: !T(!0), after: !T(!1) }, j = [];
+      const y = Math.min(...g.map(i)), P = Math.max(...g.map(f)), O = Math.min(...g.map(c)), w = Math.max(...g.map(u)), k = new Set(g.map(($) => $.id)), F = ($) => [...o.values()].some(
+        (v) => v.parent === r.scope && !k.has(v.id) && c(v) < w && u(v) > O && ($ ? f(v) <= y : i(v) >= P)
+      ), T = { before: !F(!0), after: !F(!1) }, j = [];
       for (const $ of e) {
         if (n.has($.id) || $.from !== "auto" || $.to !== "auto") continue;
         const v = o.get($.source), S = o.get($.target);
@@ -3946,7 +3972,7 @@ function Ic(t, e, o, n, a = (s) => Te(s)) {
         if (!it.some((W) => i(W) < mt && f(W) > z) && !(M && it.length)) continue;
         const Q = (W, b) => !g.some(
           (Y) => Y !== W && c(Y) < u(W) && u(Y) > c(W) && (b ? f(Y) <= i(W) : i(Y) >= f(W))
-        ), H = (W) => !F[W ? "before" : "after"] || !Q(v, W) || !Q(S, W) ? 1 / 0 : W ? i(v) - y + (i(S) - y) : P - f(v) + (P - f(S)), [J, C] = [H(!0), H(!1)];
+        ), H = (W) => !T[W ? "before" : "after"] || !Q(v, W) || !Q(S, W) ? 1 / 0 : W ? i(v) - y + (i(S) - y) : P - f(v) + (P - f(S)), [J, C] = [H(!0), H(!1)];
         if (!Number.isFinite(J) && !Number.isFinite(C)) continue;
         const _ = J === C ? !M : J < C;
         j.push({ id: $.id, before: _, from: h(x), to: h(N), back: M });
@@ -3960,7 +3986,7 @@ function Ic(t, e, o, n, a = (s) => Te(s)) {
           let z = 0;
           for (; S[z]?.some(([W, b]) => x.from < b + Cn && x.to > W - Cn); ) z++;
           (S[z] ??= []).push([x.from, x.to]);
-          const mt = e.find((W) => W.id === x.id), it = o.get(mt.target), ht = $ ? y - Us - z * Cn : P + Us + z * Cn, Q = Oc(it, g, !x.back, c, u), H = Math.min(Ec, (f(it) - i(it)) / 2 - Sc), J = Ac(it, g, !x.back, mt.id, e, o, c, u, i, f), C = it.shape === "diamond" && J.length > 0 || J.some((W) => {
+          const mt = e.find((W) => W.id === x.id), it = o.get(mt.target), ht = $ ? y - Us - z * Cn : P + Us + z * Cn, Q = Ac(it, g, !x.back, c, u), H = Math.min(Ec, (f(it) - i(it)) / 2 - Sc), J = Oc(it, g, !x.back, mt.id, e, o, c, u, i, f), C = it.shape === "diamond" && J.length > 0 || J.some((W) => {
             if (!W.label) return !1;
             const { w: b, h: Y } = a(W.label);
             return (d ? Y : b) / 2 + 2 > H;
@@ -3977,11 +4003,11 @@ function Ic(t, e, o, n, a = (s) => Te(s)) {
   }
   return s;
 }
-function Oc(t, e, o, n, a) {
+function Ac(t, e, o, n, a) {
   const s = e.filter((r) => r !== t && (o ? a(r) <= n(t) : n(r) >= a(t))).map((r) => o ? n(t) - a(r) : n(r) - a(t));
   return Math.min(48, ...s);
 }
-function Ac(t, e, o, n, a, s, r, d, c, u) {
+function Oc(t, e, o, n, a, s, r, d, c, u) {
   const i = new Set(
     e.filter(
       (h) => h !== t && (o ? d(h) <= r(t) : r(h) >= d(t)) && c(h) < u(t) && u(h) > c(t)
@@ -4006,19 +4032,19 @@ function Lc(t, e, o, n, a, s = si) {
   ), p = [], m = [];
   for (const [g, y] of e.entries())
     for (const P of y) {
-      const A = c(P);
-      A && (p[g] = Math.min(p[g] ?? 1 / 0, A.y), m[g] = Math.max(m[g] ?? -1 / 0, A.y + A.h));
+      const O = c(P);
+      O && (p[g] = Math.min(p[g] ?? 1 / 0, O.y), m[g] = Math.max(m[g] ?? -1 / 0, O.y + O.h));
     }
   for (const [g, { placed: y, level: P }] of h) {
-    const A = Math.max(0, ...P) + 1, w = (p[g + 1] ?? 0) - (m[g] ?? 0), k = A > 1 ? Math.min(s.track, Math.max(0, w - 2 * ai) / (A - 1)) : 0, T = (m[g] ?? 0) + (w - (A - 1) * k) / 2;
-    y.forEach((F, j) => F.y = dn(T + P[j] * k));
+    const O = Math.max(0, ...P) + 1, w = (p[g + 1] ?? 0) - (m[g] ?? 0), k = O > 1 ? Math.min(s.track, Math.max(0, w - 2 * ai) / (O - 1)) : 0, F = (m[g] ?? 0) + (w - (O - 1) * k) / 2;
+    y.forEach((T, j) => T.y = dn(F + P[j] * k));
   }
   for (const g of u) {
-    const y = c(g.chain[0]), P = c(g.chain.at(-1)), A = i.get(g.id), w = f.get(g.id), k = [{ x: A, y: y.y + y.h }];
-    for (const T of l.get(g.id)) k.push({ x: T.up, y: T.y }, { x: T.low, y: T.y });
+    const y = c(g.chain[0]), P = c(g.chain.at(-1)), O = i.get(g.id), w = f.get(g.id), k = [{ x: O, y: y.y + y.h }];
+    for (const F of l.get(g.id)) k.push({ x: F.up, y: F.y }, { x: F.low, y: F.y });
     k.push({ x: w, y: P.y }), d.set(g.id, {
-      points: Gc(k).map((T) => r ? { x: T.y, y: T.x } : T),
-      fromOffset: dn(A - (y.x + y.w / 2)),
+      points: Gc(k).map((F) => r ? { x: F.y, y: F.x } : F),
+      fromOffset: dn(O - (y.x + y.w / 2)),
       toOffset: dn(w - (P.x + P.w / 2))
     });
   }
@@ -4031,16 +4057,16 @@ function $c(t, e, o, n, a, s = si) {
   return r;
 }
 function ii(t, e, o, n, a, s) {
-  const r = t === "right", d = (F) => {
-    const j = n(F);
+  const r = t === "right", d = (T) => {
+    const j = n(T);
     return j && (r ? { x: j.y, y: j.x, w: j.h, h: j.w } : j);
-  }, c = new Map(e.flatMap((F, j) => F.map(($) => [$, j]))), u = o.filter(
-    (F) => F.chain.length >= 2 && d(F.chain[0]) && d(F.chain.at(-1)) && F.chain.slice(1, -1).every((j) => a(j) !== void 0) && F.chain.every((j, $) => $ === 0 || c.get(j) === c.get(F.chain[$ - 1]) + 1)
-  ), i = (F) => {
-    const j = d(F);
-    return j ? j.x + j.w / 2 : a(F);
-  }, f = (F, j, $) => {
-    const v = d(F), S = v.x + Ys, M = v.x + v.w - Ys, x = j.length;
+  }, c = new Map(e.flatMap((T, j) => T.map(($) => [$, j]))), u = o.filter(
+    (T) => T.chain.length >= 2 && d(T.chain[0]) && d(T.chain.at(-1)) && T.chain.slice(1, -1).every((j) => a(j) !== void 0) && T.chain.every((j, $) => $ === 0 || c.get(j) === c.get(T.chain[$ - 1]) + 1)
+  ), i = (T) => {
+    const j = d(T);
+    return j ? j.x + j.w / 2 : a(T);
+  }, f = (T, j, $) => {
+    const v = d(T), S = v.x + Ys, M = v.x + v.w - Ys, x = j.length;
     j.sort((it, ht) => it.want - ht.want || (it.line < ht.line ? -1 : 1));
     const N = x > 1 ? Math.min(s.port, Math.max(0, M - S) / (x - 1)) : 0, z = [];
     for (const [it, ht] of j.entries())
@@ -4054,30 +4080,30 @@ function ii(t, e, o, n, a, s) {
         mt.push(Math.max(S, Math.min(M - (x - 1) * N, it.sum / it.n)) + mt.length * N);
     j.forEach((it, ht) => $.set(it.line, dn(mt[ht])));
   }, h = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
-  for (const F of u) {
-    const [j, $] = F.chain;
-    (h.get(j) ?? h.set(j, []).get(j)).push({ line: F.id, want: i($) });
+  for (const T of u) {
+    const [j, $] = T.chain;
+    (h.get(j) ?? h.set(j, []).get(j)).push({ line: T.id, want: i($) });
   }
   const p = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map();
-  for (const [F, j] of h) f(F, j, p);
-  for (const F of u) {
-    const j = F.chain.at(-1), $ = F.chain.at(-2), v = F.chain.length === 2 ? p.get(F.id) : a($);
-    (l.get(j) ?? l.set(j, []).get(j)).push({ line: F.id, want: v });
-  }
-  for (const [F, j] of l) f(F, j, m);
-  const g = (F, j) => j === 0 ? p.get(F.id) : j === F.chain.length - 1 ? m.get(F.id) : a(F.chain[j]), y = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Map();
-  for (const F of u) {
+  for (const [T, j] of h) f(T, j, p);
+  for (const T of u) {
+    const j = T.chain.at(-1), $ = T.chain.at(-2), v = T.chain.length === 2 ? p.get(T.id) : a($);
+    (l.get(j) ?? l.set(j, []).get(j)).push({ line: T.id, want: v });
+  }
+  for (const [T, j] of l) f(T, j, m);
+  const g = (T, j) => j === 0 ? p.get(T.id) : j === T.chain.length - 1 ? m.get(T.id) : a(T.chain[j]), y = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Map();
+  for (const T of u) {
     const j = [];
-    for (let $ = 0; $ + 1 < F.chain.length; $++) {
-      const v = g(F, $), S = g(F, $ + 1);
+    for (let $ = 0; $ + 1 < T.chain.length; $++) {
+      const v = g(T, $), S = g(T, $ + 1);
       if (Math.abs(v - S) < xo) continue;
-      const M = { line: F.id, up: v, low: S, lo: Math.min(v, S), hi: Math.max(v, S) }, x = c.get(F.chain[$]);
+      const M = { line: T.id, up: v, low: S, lo: Math.min(v, S), hi: Math.max(v, S) }, x = c.get(T.chain[$]);
       (y.get(x) ?? y.set(x, []).get(x)).push(M), j.push(M);
     }
-    P.set(F.id, j);
+    P.set(T.id, j);
   }
-  const A = (F, j) => F > j.lo + xo && F < j.hi - xo, w = (F, j) => (A(F.low, j) ? 1 : 0) + (A(j.up, F) ? 1 : 0), k = (F, j) => F.lo < j.hi + s.track && j.lo < F.hi + s.track, T = /* @__PURE__ */ new Map();
-  for (const [F, j] of y) {
+  const O = (T, j) => T > j.lo + xo && T < j.hi - xo, w = (T, j) => (O(T.low, j) ? 1 : 0) + (O(j.up, T) ? 1 : 0), k = (T, j) => T.lo < j.hi + s.track && j.lo < T.hi + s.track, F = /* @__PURE__ */ new Map();
+  for (const [T, j] of y) {
     const $ = [];
     for (const S of [...j].sort((M, x) => M.lo - x.lo || M.hi - x.hi)) {
       let M = 0, x = 1 / 0;
@@ -4093,9 +4119,9 @@ function ii(t, e, o, n, a, s) {
     for (let S = 0; S < $.length; S++)
       for (let M = 0; M < S; M++)
         k($[S], $[M]) && (v[S] = Math.max(v[S], v[M] + 1));
-    T.set(F, { placed: $, level: v });
+    F.set(T, { placed: $, level: v });
   }
-  return { rectOf: d, usable: u, outPort: p, inPort: m, gaps: T, runs: P };
+  return { rectOf: d, usable: u, outPort: p, inPort: m, gaps: F, runs: P };
 }
 const dn = (t) => Math.round(t * 100) / 100;
 function Gc(t) {
@@ -4117,7 +4143,7 @@ const Pc = ["vscode", "vscode-insiders", "cursor", "windsurf", "zed"], Xs = [
   "open-diamond",
   "circle",
   "cross"
-], Ks = "M1 4.5L7.5 1L14 4.5L7.5 8Z", Tc = {
+], Ks = "M1 4.5L7.5 1L14 4.5L7.5 8Z", Fc = {
   arrow: { w: 8, h: 8, x: 7, d: "M1 1L7 4L1 7", fill: "none", stop: 0 },
   triangle: { w: 10, h: 9, x: 1, d: "M1 1L9 4.5L1 8Z", fill: "ink", stop: 8 },
   "open-triangle": { w: 12, h: 11, x: 1, d: "M1 1L11 5.5L1 10Z", fill: "surface", stop: 10 },
@@ -4133,7 +4159,7 @@ const Pc = ["vscode", "vscode-insiders", "cursor", "windsurf", "zed"], Xs = [
   },
   // Set back from the end, with the line running on through it.
   cross: { w: 9, h: 9, x: 10.5, d: "M1 1L8 8M8 1L1 8", fill: "none", stop: 0 }
-}, jo = (t) => t === "none" ? void 0 : Tc[t], as = (t) => t.directed === !1 ? "none" : t.head ?? "arrow", is = (t) => t.directed === !1 ? "none" : t.tail ?? "none", Fc = (t) => as(t) !== "arrow" || is(t) !== "none";
+}, jo = (t) => t === "none" ? void 0 : Fc[t], as = (t) => t.directed === !1 ? "none" : t.head ?? "arrow", is = (t) => t.directed === !1 ? "none" : t.tail ?? "none", Tc = (t) => as(t) !== "arrow" || is(t) !== "none";
 function Js(t, e, o) {
   const n = Math.hypot(e.x - t.x, e.y - t.y), a = Math.min(o, n - 1);
   return a > 0 ? { x: t.x + (e.x - t.x) * a / n, y: t.y + (e.y - t.y) * a / n } : t;
@@ -4201,30 +4227,30 @@ const No = {
   right: { x: 1, y: 0 },
   top: { x: 0, y: -1 },
   bottom: { x: 0, y: 1 }
-}, Ro = (t, e, o) => Math.max(t.x, e.x) > o.x && Math.min(t.x, e.x) < o.x + o.w && Math.max(t.y, e.y) > o.y && Math.min(t.y, e.y) < o.y + o.h, bn = (t, e) => ({ x: t.x - e, y: t.y - e, w: t.w + 2 * e, h: t.h + 2 * e }), Cc = 8, qc = 10, ri = 2;
+}, Ro = (t, e, o) => Math.max(t.x, e.x) > o.x && Math.min(t.x, e.x) < o.x + o.w && Math.max(t.y, e.y) > o.y && Math.min(t.y, e.y) < o.y + o.h, bn = (t, e) => ({ x: t.x - e, y: t.y - e, w: t.w + 2 * e, h: t.h + 2 * e }), Cc = 8, Bc = 10, ri = 2;
 function ci(t, e, o, n, a) {
-  const { w: s, h: r } = Te(t, n), d = [], c = (p) => ({ x: p.x - s / 2, y: p.y - r / 2, w: s, h: r }), u = e[0], i = (a.routes ?? []).map((p) => ({
+  const { w: s, h: r } = Fe(t, n), d = [], c = (p) => ({ x: p.x - s / 2, y: p.y - r / 2, w: s, h: r }), u = e[0], i = (a.routes ?? []).map((p) => ({
     route: p,
     shared: !!u && !!p[0] && nn(p[0], u) < 1
   })), f = n.annotation.size + (ei(t, n).length - 1) * n.annotation.lineHeight, h = (p) => {
-    const m = c(p), g = { x: m.x + 8, y: p.y - f / 2, w: Math.max(1, s - 16), h: f }, y = bn(m, -1), P = bn(m, 3), A = bn(m, Cc);
+    const m = c(p), g = { x: m.x + 8, y: p.y - f / 2, w: Math.max(1, s - 16), h: f }, y = bn(m, -1), P = bn(m, 3), O = bn(m, Cc);
     let w = 0;
-    for (const { route: k, shared: T } of i) {
-      const F = (j) => k.some(($, v) => v && Ro(k[v - 1], $, j));
-      F(g) ? w += T ? 1 : 5 : F(y) ? w += T ? 1 : 3 : !T && F(P) ? w += 2 : !T && F(A) && (w += 1);
+    for (const { route: k, shared: F } of i) {
+      const T = (j) => k.some(($, v) => v && Ro(k[v - 1], $, j));
+      T(g) ? w += F ? 1 : 5 : T(y) ? w += F ? 1 : 3 : !F && T(P) ? w += 2 : !F && T(O) && (w += 1);
     }
     for (const k of a.borders ?? []) Xe(m, k, 2) && (w += 2);
     for (const k of a.marks ?? []) Xe(m, k, 1) && (w += 5);
-    return a.home && !Nr(bn(a.home, -2), m) && (w += 4), o.some((k) => Xe(m, k, qc)) && (w += 1), w;
+    return a.home && !Nr(bn(a.home, -2), m) && (w += 4), o.some((k) => Xe(m, k, Bc)) && (w += 1), w;
   }, l = (p, m) => {
     const g = Math.min(p.y, m.y) - r, y = Math.max(p.y, m.y) + r, P = [];
-    for (const { route: A } of i)
-      for (let w = 1; w < A.length; w++) {
-        const k = A[w - 1], T = A[w];
-        if (k.x !== T.x || Math.max(k.y, T.y) < g || Math.min(k.y, T.y) > y) continue;
-        const F = k.x - p.x;
-        if (!F || Math.abs(F) > s) continue;
-        const j = F < 0 ? F + 4 + s / 2 : F - 4 - s / 2;
+    for (const { route: O } of i)
+      for (let w = 1; w < O.length; w++) {
+        const k = O[w - 1], F = O[w];
+        if (k.x !== F.x || Math.max(k.y, F.y) < g || Math.min(k.y, F.y) > y) continue;
+        const T = k.x - p.x;
+        if (!T || Math.abs(T) > s) continue;
+        const j = T < 0 ? T + 4 + s / 2 : T - 4 - s / 2;
         Math.abs(j) <= s / 2 - 6 && Math.abs(j) > r - 4 && P.push(j);
       }
     return P;
@@ -4232,9 +4258,9 @@ function ci(t, e, o, n, a) {
   for (let p = 1; p < e.length; p++) {
     const m = e[p - 1], g = e[p], y = nn(m, g);
     if (y < 8) continue;
-    const P = m.y === g.y, A = y + (P ? 50 : 0), w = a.marks?.length ? [-(r / 2 + 7), r / 2 + 7] : [], k = P ? [0, -(r / 2 + 4), r / 2 + 4, ...w] : [0, -(r - 4), r - 4, ...l(m, g)], T = Math.max(2, Math.ceil(y / 6));
-    for (let F = 0; F <= T; F++) {
-      const j = F / T, $ = { x: m.x + (g.x - m.x) * j, y: m.y + (g.y - m.y) * j };
+    const P = m.y === g.y, O = y + (P ? 50 : 0), w = a.marks?.length ? [-(r / 2 + 7), r / 2 + 7] : [], k = P ? [0, -(r / 2 + 4), r / 2 + 4, ...w] : [0, -(r - 4), r - 4, ...l(m, g)], F = Math.max(2, Math.ceil(y / 6));
+    for (let T = 0; T <= F; T++) {
+      const j = T / F, $ = { x: m.x + (g.x - m.x) * j, y: m.y + (g.y - m.y) * j };
       for (const v of k) {
         const S = P ? { x: $.x, y: $.y + v } : { x: $.x + v, y: $.y };
         o.some((M) => Xe(c(S), M, 4)) || d.push({
@@ -4243,40 +4269,40 @@ function ci(t, e, o, n, a) {
           h: r,
           cost: h(S) + (P && v ? ri : 0),
           // Prefer long level segments, the middle of a segment, on the line, then above it.
-          score: A - Math.abs(j - 0.5) * y * 0.5 - Math.abs(v) * 3 + (v < 0 ? 1 : 0)
+          score: O - Math.abs(j - 0.5) * y * 0.5 - Math.abs(v) * 3 + (v < 0 ? 1 : 0)
         });
       }
     }
   }
   return { w: s, h: r, spots: d, cost: h };
 }
-function Bc(t, e, o = Re(), n = []) {
+function qc(t, e, o = Re(), n = []) {
   const a = t.map((i) => ci(i.label, i.points, e, o, i.avoid ?? {})), s = t.map(() => null), r = (i, f) => ({
     x: f.x + (t[i].dx ?? 0) - f.w / 2,
     y: f.y + (t[i].dy ?? 0) - f.h / 2,
     w: f.w,
     h: f.h
   }), d = (i) => {
-    const f = [...n, ...s.flatMap((A, w) => w !== i && A ? [r(w, A)] : [])], { w: h, h: l, spots: p, cost: m } = a[i];
+    const f = [...n, ...s.flatMap((O, w) => w !== i && O ? [r(w, O)] : [])], { w: h, h: l, spots: p, cost: m } = a[i];
     let g = null, y = 1 / 0;
-    for (const A of p) {
-      const w = r(i, A);
-      if (f.some((T) => Xe(w, T, 6))) continue;
-      const k = A.cost + f.filter((T) => Xe(w, T, l)).length * ri;
-      (k < y || k === y && A.score > g.score) && ([g, y] = [A, k]);
+    for (const O of p) {
+      const w = r(i, O);
+      if (f.some((F) => Xe(w, F, 6))) continue;
+      const k = O.cost + f.filter((F) => Xe(w, F, l)).length * ri;
+      (k < y || k === y && O.score > g.score) && ([g, y] = [O, k]);
     }
     if (g) {
-      const { cost: A, ...w } = g;
+      const { cost: O, ...w } = g;
       return w;
     }
-    const P = (A) => ({ x: A.x - h / 2, y: A.y - l / 2, w: h, h: l });
+    const P = (O) => ({ x: O.x - h / 2, y: O.y - l / 2, w: h, h: l });
     return Hc(
       t[i].points,
       h,
       l,
       e,
       f,
-      (A) => e.some((w) => Xe(P(A), w, 4)) || f.some((w) => Xe(P(A), w, 6)),
+      (O) => e.some((w) => Xe(P(O), w, 4)) || f.some((w) => Xe(P(O), w, 6)),
       m,
       t[i].avoid?.home
     );
@@ -4294,12 +4320,12 @@ function Hc(t, e, o, n, a, s, r = () => 0, d) {
   for (let h = 1; h < t.length; h++) {
     const l = t[h - 1], p = t[h], m = nn(l, p);
     if (!m) continue;
-    const g = l.y === p.y ? 0 : l.x === p.x ? 1 : -(p.y - l.y) / m, y = l.y === p.y ? 1 : l.x === p.x ? 0 : (p.x - l.x) / m, P = (e * Math.abs(g) + o * Math.abs(y)) / 2, A = m + (l.y === p.y ? 50 : 0), w = e * Math.abs(y) + o * Math.abs(g), k = Array.from(
+    const g = l.y === p.y ? 0 : l.x === p.x ? 1 : -(p.y - l.y) / m, y = l.y === p.y ? 1 : l.x === p.x ? 0 : (p.x - l.x) / m, P = (e * Math.abs(g) + o * Math.abs(y)) / 2, O = m + (l.y === p.y ? 50 : 0), w = e * Math.abs(y) + o * Math.abs(g), k = Array.from(
       { length: 2 * Math.ceil(w / 6) + 1 },
-      (T, F) => (F - Math.ceil(w / 6)) * 6
+      (F, T) => (T - Math.ceil(w / 6)) * 6
     );
-    for (const T of [0.5, 0.35, 0.65]) {
-      const F = { x: l.x + (p.x - l.x) * T, y: l.y + (p.y - l.y) * T }, j = F.x * g + F.y * y, $ = /* @__PURE__ */ new Set();
+    for (const F of [0.5, 0.35, 0.65]) {
+      const T = { x: l.x + (p.x - l.x) * F, y: l.y + (p.y - l.y) * F }, j = T.x * g + T.y * y, $ = /* @__PURE__ */ new Set();
       for (const [v, S] of [
         [n, 5],
         [a, 7]
@@ -4314,8 +4340,8 @@ function Hc(t, e, o, n, a, s, r = () => 0, d) {
       }
       for (const v of $)
         for (const S of v ? k : []) {
-          const M = { x: F.x + g * v + y * S, y: F.y + y * v - g * S };
-          s(M) || c.push({ ...M, w: e, h: o, score: A - (Math.abs(v) + Math.abs(S)) * 2 });
+          const M = { x: T.x + g * v + y * S, y: T.y + y * v - g * S };
+          s(M) || c.push({ ...M, w: e, h: o, score: O - (Math.abs(v) + Math.abs(S)) * 2 });
         }
     }
   }
@@ -4392,7 +4418,7 @@ function li(t, e, o) {
     ]) {
       const f = o.get(c), h = o.get(ss(t, c)?.parentId ?? ""), l = o.get(u);
       if (i || !f || !h || !l || !Ur(t, c)) continue;
-      const p = (T, F) => Math.abs(T - F) < 0.5, m = [
+      const p = (F, T) => Math.abs(F - T) < 0.5, m = [
         ...p(f.x, h.x) ? ["left"] : [],
         ...p(f.x + f.w, h.x + h.w) ? ["right"] : [],
         ...f.y + f.h > h.y + h.h - 0.5 ? ["bottom"] : []
@@ -4401,16 +4427,16 @@ function li(t, e, o) {
         n.set(s.id, { ...n.get(s.id), [d]: Zs(f, m, Jn(l)) });
         continue;
       }
-      const g = Zs(h, ["left", "right", "top", "bottom"], Jn(l)), y = Jn(f), P = No[g], A = {
+      const g = Zs(h, ["left", "right", "top", "bottom"], Jn(l)), y = Jn(f), P = No[g], O = {
         x: (g === "left" ? h.x : g === "right" ? h.x + h.w : y.x) + P.x * ta,
         y: (g === "top" ? h.y : g === "bottom" ? h.y + h.h : y.y) + P.y * ta
       }, w = {
         x: g === "left" ? f.x : g === "right" ? f.x + f.w : y.x,
         y: g === "top" ? f.y : g === "bottom" ? f.y + f.h : y.y
-      }, k = P.y ? { x: A.x - 16, y: P.y < 0 ? A.y - 2 : A.y, w: 32, h: 2 } : { x: P.x < 0 ? A.x - 2 : A.x, y: A.y - 16, w: 2, h: 32 };
+      }, k = P.y ? { x: O.x - 16, y: P.y < 0 ? O.y - 2 : O.y, w: 32, h: 2 } : { x: P.x < 0 ? O.x - 2 : O.x, y: O.y - 16, w: 2, h: 32 };
       a.set(s.id, {
         ...a.get(s.id),
-        [d]: { side: g, stub: k, cross: [A, w] }
+        [d]: { side: g, stub: k, cross: [O, w] }
       }), n.set(s.id, { ...n.get(s.id), [d]: g });
     }
   }
@@ -4491,12 +4517,12 @@ function Jc(t, e, o, n, a) {
   ), u = c(t);
   let i = null, f = 1 / 0;
   for (let h = 1; h + 2 < t.length; h++) {
-    const [l, p, m, g] = t.slice(h - 1, h + 3), y = s(p, m) ? "y" : "x", P = (s(p, m) ? o : e) + 2 * ea, A = (s(p, m) ? o : e) + 8, w = Math.abs(g[y] - l[y]) - Kc;
-    if (Math.sign(p[y] - l[y]) !== Math.sign(g[y] - m[y]) || w < A) continue;
-    const k = Math.sign(g[y] - l[y]), T = Math.min(P, w);
-    for (const F of [l[y] + k * T, g[y] - k * T]) {
-      const j = t.map((v, S) => S === h || S === h + 1 ? { ...v, [y]: F } : v), $ = j.slice(h - 1, h + 3);
-      Math.abs(F - p[y]) >= f || Math.abs(F - p[y]) < 0.5 || Ze($).some(([v, S]) => n.some((M) => Ro(v, S, M))) || n.some((v) => Ro(j[h], j[h + 1], bn(v, na))) || c(j) > u || (i = j, f = Math.abs(F - p[y]));
+    const [l, p, m, g] = t.slice(h - 1, h + 3), y = s(p, m) ? "y" : "x", P = (s(p, m) ? o : e) + 2 * ea, O = (s(p, m) ? o : e) + 8, w = Math.abs(g[y] - l[y]) - Kc;
+    if (Math.sign(p[y] - l[y]) !== Math.sign(g[y] - m[y]) || w < O) continue;
+    const k = Math.sign(g[y] - l[y]), F = Math.min(P, w);
+    for (const T of [l[y] + k * F, g[y] - k * F]) {
+      const j = t.map((v, S) => S === h || S === h + 1 ? { ...v, [y]: T } : v), $ = j.slice(h - 1, h + 3);
+      Math.abs(T - p[y]) >= f || Math.abs(T - p[y]) < 0.5 || Ze($).some(([v, S]) => n.some((M) => Ro(v, S, M))) || n.some((v) => Ro(j[h], j[h + 1], bn(v, na))) || c(j) > u || (i = j, f = Math.abs(T - p[y]));
     }
   }
   return i ?? t;
@@ -4540,11 +4566,11 @@ function Vc(t, e, o, n) {
   }, n = {
     ...n,
     routes: n.routes.map((w, k) => {
-      const T = c.get(w.id)?.label;
-      if (!T || w.blocked || f(w) || t.layout.edges[w.id]?.waypoints?.length)
+      const F = c.get(w.id)?.label;
+      if (!F || w.blocked || f(w) || t.layout.edges[w.id]?.waypoints?.length)
         return w;
-      const { w: F, h: j } = Te(T, d), $ = n.routes.filter((M, x) => x !== k).map((M) => M.points), v = Jc(w.points, F, j, [...a, ...s], $), S = (M) => Math.min(
-        ...ci(T, M, a, d, { routes: $, borders: s }).spots.map(
+      const { w: T, h: j } = Fe(F, d), $ = n.routes.filter((M, x) => x !== k).map((M) => M.points), v = Jc(w.points, T, j, [...a, ...s], $), S = (M) => Math.min(
+        ...ci(F, M, a, d, { routes: $, borders: s }).spots.map(
           (x) => x.cost
         )
       );
@@ -4553,18 +4579,18 @@ function Vc(t, e, o, n) {
   };
   const h = n.routes.flatMap((w) => {
     const k = go(t, w.id);
-    return k && Fc(k) ? Qs(w.points, k) : [];
+    return k && Tc(k) ? Qs(w.points, k) : [];
   }), l = (w) => {
     const k = new Set(gn(t, w.b));
-    return r.get(gn(t, w.a).find((T) => k.has(T) && r.has(T)) ?? "");
-  }, p = n.routes.filter((w) => c.get(w.id).label && !f(w)), m = Bc(
+    return r.get(gn(t, w.a).find((F) => k.has(F) && r.has(F)) ?? "");
+  }, p = n.routes.filter((w) => c.get(w.id).label && !f(w)), m = qc(
     p.map((w) => {
       const k = t.layout.edges[w.id] || {};
       return {
         label: c.get(w.id).label,
         points: w.points,
         avoid: {
-          routes: n.routes.filter((T) => T !== w).map((T) => T.points),
+          routes: n.routes.filter((F) => F !== w).map((F) => F.points),
           borders: s,
           marks: h,
           home: l(c.get(w.id))
@@ -4579,15 +4605,15 @@ function Vc(t, e, o, n) {
   for (const w of n.routes) {
     const k = c.get(w.id).label;
     if (!k || !f(w)) continue;
-    const { w: T, h: F } = Te(k, d, !0), [j, $] = [w.points[0], w.points[w.points.length - 1]];
+    const { w: F, h: T } = Fe(k, d, !0), [j, $] = [w.points[0], w.points[w.points.length - 1]];
     g.set(
       w,
       w.from === w.to ? {
-        x: w.points[1].x + ve.label + T / 2,
+        x: w.points[1].x + ve.label + F / 2,
         y: (w.points[1].y + w.points[2].y) / 2,
-        w: T,
-        h: F
-      } : { x: (j.x + $.x) / 2, y: j.y - F / 2 - 1, w: T, h: F }
+        w: F,
+        h: T
+      } : { x: (j.x + $.x) / 2, y: j.y - T / 2 - 1, w: F, h: T }
     );
   }
   const y = e.groups.flatMap(
@@ -4597,21 +4623,21 @@ function Vc(t, e, o, n) {
       const k = go(t, w.id);
       return { points: w.points, marks: k ? Qs(w.points, k) : [] };
     })
-  ), A = n.routes.map((w, k) => {
-    const T = i.get(w.id), F = go(t, w.id);
+  ), O = n.routes.map((w, k) => {
+    const F = i.get(w.id), T = go(t, w.id);
     return {
       ...w,
       label: g.get(w) ?? null,
-      path: Rr(F ? _c(w.points, F) : w.points, u),
+      path: Rr(T ? _c(w.points, T) : w.points, u),
       halo: tl(
         w.points,
         n.routes.filter((j, $) => $ !== k && !(P.has(k) && P.has($))).map((j) => j.points),
         y
       ),
-      ...T?.to ? { cross: T.to.cross } : T?.from ? { cross: T.from.cross } : {}
+      ...F?.to ? { cross: F.to.cross } : F?.from ? { cross: F.from.cross } : {}
     };
   });
-  return [...A.filter((w, k) => !P.has(k)), ...A.filter((w, k) => P.has(k))];
+  return [...O.filter((w, k) => !P.has(k)), ...O.filter((w, k) => P.has(k))];
 }
 const Qc = 8, oa = 7, Ze = (t) => t.slice(1).map((e, o) => [t[o], e]), sa = (t) => Math.abs(t[0].y - t[1].y) < 0.5, aa = (t) => Math.abs(t[0].x - t[1].x) < 0.5, ia = (t, e, o) => t > Math.min(e, o) + 0.5 && t < Math.max(e, o) - 0.5;
 function rs(t, e) {
@@ -4635,7 +4661,7 @@ function Zc(t) {
       (d, c) => c !== s && fi(n[s], n[c]) && o[s].some(
         (u) => o[c].some((i) => {
           const f = rs(u, i);
-          return f && a.some((h) => Fo(f, h, Qc / 2));
+          return f && a.some((h) => To(f, h, Qc / 2));
         })
       )
     ) && e.add(s);
@@ -4908,7 +4934,7 @@ function yl(t) {
     }))
   ) : [];
 }
-class Oe extends Error {
+class Ae extends Error {
   constructor(e, o = 0, n = 0) {
     super((o ? `Line ${o}${n ? `, column ${n}` : ""}: ` : "") + e), this.line = o, this.column = n, this.name = "DslError";
   }
@@ -4932,7 +4958,7 @@ function bl(t, e = 0) {
     }
     if (f === '"') {
       if (d && i + 1 < t.length && !/[\s#]/.test(t[i + 1]) && !t.startsWith("//", i + 1))
-        throw new Oe(Ml, e, i + 1);
+        throw new Ae(Ml, e, i + 1);
       d || (r = i), d = !d, a += f;
       continue;
     }
@@ -4941,7 +4967,7 @@ function bl(t, e = 0) {
       return u(), { tokens: o, columns: n, comment: t.slice(i).trim() };
     !d && /\s/.test(f) ? u() : a += f;
   }
-  if (d) throw new Oe("Unclosed quoted string.", e, r + 1);
+  if (d) throw new Ae("Unclosed quoted string.", e, r + 1);
   return u(), { tokens: o, columns: n };
 }
 function ca(t, e, o) {
@@ -4949,7 +4975,7 @@ function ca(t, e, o) {
   try {
     return wl(JSON.parse(t));
   } catch {
-    throw new Oe(
+    throw new Ae(
       'Invalid escape in a quoted string. Use \\" for a quote, \\\\ for a backslash and \\n for a line break.',
       e,
       o
@@ -4957,8 +4983,8 @@ function ca(t, e, o) {
   }
 }
 function vl(t) {
-  if (typeof t != "string") throw new Oe("Source must be text.");
-  if (t.length > 3e5) throw new Oe("Limit: 300,000 source characters.");
+  if (typeof t != "string") throw new Ae("Source must be text.");
+  if (t.length > 3e5) throw new Ae("Limit: 300,000 source characters.");
   return { lines: t.split(/\r?\n/).map((o, n) => {
     const a = n + 1, { tokens: s, columns: r, comment: d } = bl(o, a);
     if (!s.length) return d ? { kind: "comment", text: d } : { kind: "blank" };
@@ -4967,14 +4993,14 @@ function vl(t) {
       const g = p.indexOf("="), y = r[m + 1];
       if (g > 0 && !p.startsWith('"')) {
         const P = p.slice(0, g);
-        if (l.some(([A]) => A === P)) throw new Oe(`Duplicate attribute ${P}.`, a);
+        if (l.some(([O]) => O === P)) throw new Ae(`Duplicate attribute ${P}.`, a);
         l.push([P, ca(p.slice(g + 1), a, y + g + 1)]);
       } else h.push(ca(p, a, y));
     }), { kind: "statement", command: f, ...i ? { mark: i } : {}, args: h, attrs: l, comment: d, line: a };
   }) };
 }
 const ui = { wide: 2, slide: 1.78, square: 1, page: 0.77, tall: 0.6 };
-function qo(t, e, o) {
+function Bo(t, e, o) {
   const n = hn(t, e);
   for (let a = o; a && a !== "root"; a = hn(t, a))
     if (hn(t, a) === n) return a === e ? void 0 : a;
@@ -5003,7 +5029,7 @@ const kl = ["near", "nudge", "stay", "pin"], la = {
   "layered",
   "tree",
   "grid"
-], Bo = {
+], qo = {
   "rank-gap": { key: "rankGap", min: 12, max: 220 },
   "group-gap": { key: "groupGap", min: 12, max: 180 },
   "node-gap": { key: "nodeGap", min: 4, max: 160 },
@@ -5034,10 +5060,10 @@ const kl = ["near", "nudge", "stay", "pin"], la = {
   standoff: { key: "standoff", min: 0, max: 40 }
 };
 function Sl(t, e) {
-  return e && t === "gap" ? "Engine lines space boxes with node-gap= and rank-gap=." : !e && t in Bo ? `${t}= needs an engine: add engine=layered or another engine.` : t === "fit" ? "fit= goes on the layout root line." : "draftably skill print lists the layout settings.";
+  return e && t === "gap" ? "Engine lines space boxes with node-gap= and rank-gap=." : !e && t in qo ? `${t}= needs an engine: add engine=layered or another engine.` : t === "fit" ? "fit= goes on the layout root line." : "draftably skill print lists the layout settings.";
 }
-const El = /^[A-Za-z_][A-Za-z0-9_.-]*$/, wo = /^[A-Za-z_][A-Za-z0-9_-]*$/, pi = ["box", "pill", "circle", "diamond", "text", "marker"], Il = pi.filter((t) => t !== "marker"), ua = ["box", "soft", "none"], Ol = /^[A-Za-z]{1,8}$/, pa = ["auto", "left", "right", "top", "bottom"];
-function Al(t) {
+const El = /^[A-Za-z_][A-Za-z0-9_.-]*$/, wo = /^[A-Za-z_][A-Za-z0-9_-]*$/, pi = ["box", "pill", "circle", "diamond", "text", "marker"], Il = pi.filter((t) => t !== "marker"), ua = ["box", "soft", "none"], Al = /^[A-Za-z]{1,8}$/, pa = ["auto", "left", "right", "top", "bottom"];
+function Ol(t) {
   const e = typeof t == "string" ? vl(t) : t, o = {
     title: "Untitled diagram",
     objects: [],
@@ -5059,7 +5085,7 @@ function Al(t) {
   for (const c of e.lines) {
     if (c.kind !== "statement") continue;
     const u = c.line, { command: i, args: f } = c, h = new Map(c.attrs), l = (M) => {
-      throw new Oe(M, u);
+      throw new Ae(M, u);
     }, p = (M, x) => {
       M || l(x);
     }, m = (M) => {
@@ -5068,7 +5094,7 @@ function Al(t) {
     }, g = (M, x = M) => p(f.length >= M && f.length <= x, `Wrong number of arguments for ${i}.`), y = (M) => (p(
       M && !M.quoted && El.test(M.value),
       "Expected a stable identifier (letters, digits, _, . or -)."
-    ), M.value), P = (M) => M?.value ?? "", A = (M, x, N = -1e5, z = 1e5) => {
+    ), M.value), P = (M) => M?.value ?? "", O = (M, x, N = -1e5, z = 1e5) => {
       const mt = h.get(M);
       if (mt === void 0) return x;
       const it = Number(mt.value);
@@ -5078,20 +5104,20 @@ function Al(t) {
       ), it;
     }, w = (M, x) => {
       const N = h.get(M);
-      return !N.quoted && Ol.test(N.value) ? N.value : A(M, x, x, 1e6);
+      return !N.quoted && Al.test(N.value) ? N.value : O(M, x, x, 1e6);
     }, k = (M, x, N) => {
       const z = h.get(M)?.value ?? x;
       return p(N.includes(z), `Expected ${M}=${N.join("|")}; got ${z}.`), z;
-    }, T = (M) => {
+    }, F = (M) => {
       const x = Number(M.value);
       return p(
         !M.quoted && $o.includes(x),
         `Expected shade=${$o.join("|")}; got ${M.value}.`
       ), x;
-    }, F = (M) => {
+    }, T = (M) => {
       const x = h.get(M);
       return p(
-        x.quoted && Ar.test(x.value),
+        x.quoted && Or.test(x.value),
         `Expected ${M}="#rrggbb" in double quotes; got ${x.value || "nothing"}.`
       ), x.value.toUpperCase();
     }, j = (M) => {
@@ -5112,12 +5138,12 @@ function Al(t) {
     }, S = (M) => {
       const x = {};
       for (const [N, z] of Object.entries(M))
-        h.has(N) && ("min" in z ? x[z.key] = A(N, 0, z.min, z.max) : z.choices.length ? x[z.key] = k(N, z.choices[0], z.choices) : x[z.key] = y(h.get(N)));
+        h.has(N) && ("min" in z ? x[z.key] = O(N, 0, z.min, z.max) : z.choices.length ? x[z.key] = k(N, z.choices[0], z.choices) : x[z.key] = y(h.get(N)));
       return x;
     };
     switch (i) {
       case "diagram":
-        g(1), m(["version", "width"]), p(!d, "Only one diagram declaration is allowed."), d = u, o.title = P(f[0]), A("version", 1, 1, 1), o.title && ((o.appearance.heading ??= {}).title = o.title), h.has("width") && ((o.appearance.heading ??= {}).width = A("width", 0, 160, 8e3));
+        g(1), m(["version", "width"]), p(!d, "Only one diagram declaration is allowed."), d = u, o.title = P(f[0]), O("version", 1, 1, 1), o.title && ((o.appearance.heading ??= {}).title = o.title), h.has("width") && ((o.appearance.heading ??= {}).width = O("width", 0, 160, 8e3));
         break;
       case "compare": {
         g(0, 2), m(["direction", "aspect"]), j("compare");
@@ -5126,7 +5152,7 @@ function Al(t) {
           before: P(f[0]) || "Before",
           after: P(f[1]) || "After",
           ...M !== "auto" ? { direction: M } : {},
-          ...h.has("aspect") ? { aspect: A("aspect", 1.6, 0.25, 8) } : {}
+          ...h.has("aspect") ? { aspect: O("aspect", 1.6, 0.25, 8) } : {}
         };
         break;
       }
@@ -5190,7 +5216,7 @@ function Al(t) {
           !h.get("color")?.quoted && wo.test(x),
           `Expected color=auto, a built-in color (${Go.join(", ")}) or a theme-color name; got ${x}.`
         );
-        const N = h.has("shade") ? T(h.get("shade")) : void 0;
+        const N = h.has("shade") ? F(h.get("shade")) : void 0;
         o.objects.push({
           id: M,
           type: i,
@@ -5206,7 +5232,7 @@ function Al(t) {
           ...i === "group" && k("fold", "auto", ["auto", "never"]) === "never" ? { fold: "never" } : {},
           ...i === "group" && k("frame", "box", ua) !== "box" ? { frame: k("frame", "box", ua) } : {},
           ...h.has("span") ? {
-            span: h.get("span").value === "var" ? "var" : A("span", 1, 1, 4096)
+            span: h.get("span").value === "var" ? "var" : O("span", 1, 1, 4096)
           } : {},
           line: u
         });
@@ -5266,7 +5292,7 @@ function Al(t) {
           g(1), p(
             da.includes(x),
             `Unknown layout engine ${x}; use ${da.join(", ")}.`
-          ), z(["engine", ...mt, ...Object.keys(Bo)]), it = { algorithm: x, params: S(Bo) };
+          ), z(["engine", ...mt, ...Object.keys(qo)]), it = { algorithm: x, params: S(qo) };
         else {
           g(2);
           const Q = f[1]?.value;
@@ -5291,15 +5317,15 @@ function Al(t) {
           direction: k("direction", "auto", ["auto", "right", "down"]),
           fold: x ? "auto" : k("fold", "auto", ["auto", "never"]),
           ...h.has("fit") ? { fit: k("fit", "slide", Object.keys(ui)) } : {},
-          ...h.has("columns") ? { columns: A("columns", 1, 1, 512) } : {},
+          ...h.has("columns") ? { columns: O("columns", 1, 1, 512) } : {},
           ...h.has("unit") ? {
             unit: k("unit", "byte", ["bit", "byte"]),
             ruler: k("ruler", "on", ["on", "off"]) === "on",
-            ...h.has("unit-width") ? { unitWidth: A("unit-width", 24, 8, 200) } : {}
+            ...h.has("unit-width") ? { unitWidth: O("unit-width", 24, 8, 200) } : {}
           } : {},
-          gap: A("gap", 28, 8, 300),
-          minWidth: A("min-width", 0, 0, 1e4),
-          minHeight: A("min-height", 0, 0, 1e4),
+          gap: O("gap", 28, 8, 300),
+          minWidth: O("min-width", 0, 0, 1e4),
+          minHeight: O("min-height", 0, 0, 1e4),
           line: u
         });
         break;
@@ -5310,7 +5336,7 @@ function Al(t) {
         p(Ps.includes(M), `Unknown theme ${M}; use ${Ps.join(", ")}.`), o.appearance.theme = M, o.themeLine = u;
         const x = o.appearance.overrides;
         for (const [N, z] of Object.entries(fa))
-          h.has(N) && (z === "paddingX" || z === "paddingY" || z === "radius" ? x[z] = A(N, 0, Fs[z].min, Fs[z].max) : z === "titleFont" || z === "annotationFont" ? x[z] = k(N, "sans", xr) : x[z] = F(N));
+          h.has(N) && (z === "paddingX" || z === "paddingY" || z === "radius" ? x[z] = O(N, 0, Ts[z].min, Ts[z].max) : z === "titleFont" || z === "annotationFont" ? x[z] = k(N, "sans", xr) : x[z] = T(N));
         break;
       }
       case "theme-color": {
@@ -5320,11 +5346,11 @@ function Al(t) {
           !f[0].quoted && wo.test(M) && M !== "auto",
           "Expected a color family name (letters, digits, _ or -)."
         );
-        const x = h.has("shade") ? T(h.get("shade")) : 500;
+        const x = h.has("shade") ? F(h.get("shade")) : 500;
         j(`theme-color:${M}:${x}`);
         const N = { family: M, shade: x };
         for (const z of ["fill", "stroke", "ink"])
-          h.has(z) && (N[z] = F(z));
+          h.has(z) && (N[z] = T(z));
         p(
           to(M) || N.fill && N.stroke && N.ink,
           `${M} is not a built-in color, so shade ${x} needs fill, stroke and ink.`
@@ -5336,8 +5362,8 @@ function Al(t) {
           g(3), m([]);
           const N = f[1].value;
           p(
-            !f[1].quoted && Ts.includes(N),
-            `Expected legend line ${Ts.join("|")} "meaning".`
+            !f[1].quoted && Fs.includes(N),
+            `Expected legend line ${Fs.join("|")} "meaning".`
           ), j(`legend:line:${N}`), p(P(f[2]).trim(), "A legend entry needs its meaning in quotes."), (o.appearance.legend ??= []).push({ line: N, label: P(f[2]) }), o.legendLines.push(u);
           break;
         }
@@ -5347,7 +5373,7 @@ function Al(t) {
           !f[0].quoted && wo.test(M) && M !== "auto",
           `Expected legend family "meaning", with a built-in color (${Go.join(", ")}) or a theme-color name.`
         ), j(`legend:${M}:${h.get("shade")?.value ?? ""}`);
-        const x = h.has("shade") ? T(h.get("shade")) : void 0;
+        const x = h.has("shade") ? F(h.get("shade")) : void 0;
         p(P(f[1]).trim(), "A legend entry needs its meaning in quotes."), (o.appearance.legend ??= []).push({
           family: M,
           label: P(f[1]),
@@ -5360,7 +5386,7 @@ function Al(t) {
           text: f[0].value,
           ...h.has("near") ? { near: y(h.get("near")) } : {},
           ...h.has("side") ? { side: k("side", "below", pc) } : {},
-          ...h.has("width") ? { width: A("width", ni, 80, 1200) } : {}
+          ...h.has("width") ? { width: O("width", ni, 80, 1200) } : {}
         }), o.noteLines.push(u);
         break;
       }
@@ -5411,25 +5437,25 @@ function Al(t) {
             id: M,
             ref: x,
             side: k("side", "right", ["right", "left", "above", "below"]),
-            gap: A("gap", 28, 0, 2e3),
-            offset: A("offset", 0),
+            gap: O("gap", 28, 0, 2e3),
+            offset: O("offset", 0),
             strength: k("strength", "prefer", ["prefer", "required"]),
             line: u
           });
         } else if (i === "nudge")
-          m(["dx", "dy"]), o.hints.push({ type: "nudge", id: M, dx: A("dx", 0), dy: A("dy", 0), line: u });
+          m(["dx", "dy"]), o.hints.push({ type: "nudge", id: M, dx: O("dx", 0), dy: O("dy", 0), line: u });
         else if (i === "stay")
           m(["x", "y", "weight"]), o.hints.push({
             type: "stay",
             id: M,
             // The root has no frame, so an arrangement can place objects left of or above 0,0.
-            x: A("x", 0),
-            y: A("y", 0),
-            weight: A("weight", 8, 1, 100),
+            x: O("x", 0),
+            y: O("y", 0),
+            weight: O("weight", 8, 1, 100),
             line: u
           });
         else if (i === "pin")
-          m(["x", "y"]), o.hints.push({ type: "pin", id: M, x: A("x", 0, 0), y: A("y", 0, 0), line: u });
+          m(["x", "y"]), o.hints.push({ type: "pin", id: M, x: O("x", 0, 0), y: O("y", 0, 0), line: u });
         else {
           m(["width", "height", "min-height"]);
           const x = h.get("height")?.value === "auto";
@@ -5439,9 +5465,9 @@ function Al(t) {
           ), o.hints.push({
             type: "size",
             id: M,
-            width: A("width", 164, 40, 1200),
-            ...x ? {} : { height: A("height", 56, 24, 1200) },
-            ...h.has("min-height") ? { minHeight: A("min-height", 24, 24, 1200) } : {},
+            width: O("width", 164, 40, 1200),
+            ...x ? {} : { height: O("height", 56, 24, 1200) },
+            ...h.has("min-height") ? { minHeight: O("min-height", 24, 24, 1200) } : {},
             line: u
           });
         }
@@ -5456,8 +5482,8 @@ function Al(t) {
         l(`Unknown statement ${i}.`);
     }
   }
-  if (o.objects.length > 500) throw new Oe("Limit: 500 nodes and groups.");
-  if (o.edges.length > 1200) throw new Oe("Limit: 1,200 edges.");
+  if (o.objects.length > 500) throw new Ae("Limit: 500 nodes and groups.");
+  if (o.edges.length > 1200) throw new Ae("Limit: 1,200 edges.");
   return Ll(o), o;
 }
 function hn(t, e) {
@@ -5471,7 +5497,7 @@ function Ll(t) {
     `${l} is a ${e.get(l)?.frame} group, so it has no ${m} of its own. Use frame=box, or ${m === "layout" ? "set the layout of the container around it" : "place its members"}.`,
     p
   ), n = (l) => hn(e, l), a = (l, p, m) => {
-    if (!l) throw new Oe(p, m);
+    if (!l) throw new Ae(p, m);
   }, s = (l, p) => a(e.has(l), `Unknown node/group ${l}.`, p), r = (l, p) => a(l === "root" || e.get(l)?.type === "group", `Unknown container ${l}.`, p), d = /* @__PURE__ */ new Map();
   for (const l of t.appearance.colors)
     d.has(l.family) || d.set(l.family, /* @__PURE__ */ new Set()), d.get(l.family).add(l.shade);
@@ -5486,7 +5512,7 @@ function Ll(t) {
   });
   for (const l of t.objects) {
     if (l.color !== "auto" && !to(l.color)) {
-      const m = d.get(l.color), g = l.shade ?? (l.type === "group" ? Or(t.appearance.theme) : Qe);
+      const m = d.get(l.color), g = l.shade ?? (l.type === "group" ? Ar(t.appearance.theme) : Qe);
       a(
         m,
         `Unknown color ${l.color}. Define it with theme-color ${l.color} shade=… fill= stroke= ink=.`,
@@ -5636,7 +5662,7 @@ function Ll(t) {
       );
     } else
       s(l.id, l.line), o(l.id, l.line, "position"), l.type === "near" && (s(l.ref, l.line), o(l.ref, l.line, "position"), a(
-        qo(e, l.id, l.ref) !== void 0,
+        Bo(e, l.id, l.ref) !== void 0,
         `Relative placement is between siblings, or with something inside a sibling group. ${l.id} is inside ${n(l.id)}; place ${n(l.id)} relative to ${l.ref} instead.`,
         l.line
       )), l.type === "size" && a(
@@ -5645,12 +5671,12 @@ function Ll(t) {
         l.line
       );
 }
-const sn = { width: 1100, height: 720 }, An = 12, $l = 56, ga = 24, ma = 0, Gl = 56, ya = { w: 260, h: 110 }, xa = (t, e) => Math.max(e.x - t.x - t.w, t.x - e.x - e.w, e.y - t.y - t.h, t.y - e.y - e.h), Wt = (t) => Math.round(t);
+const sn = { width: 1100, height: 720 }, On = 12, $l = 56, ga = 24, ma = 0, Gl = 56, ya = { w: 260, h: 110 }, xa = (t, e) => Math.max(e.x - t.x - t.w, t.x - e.x - e.w, e.y - t.y - t.h, t.y - e.y - e.h), Wt = (t) => Math.round(t);
 async function gi(t) {
-  const e = Al(t), o = e.layouts.find((r) => r.scope === "root" && r.fit);
+  const e = Ol(t), o = e.layouts.find((r) => r.scope === "root" && r.fit);
   if (!o?.fit) return wa(e);
   const n = ui[o.fit], a = [];
-  for (const r of Fl(o)) {
+  for (const r of Tl(o)) {
     const d = await wa({
       ...e,
       layouts: e.layouts.map((c) => c === o ? { ...c, ...r.layout } : c)
@@ -5673,20 +5699,20 @@ async function gi(t) {
   }), s.scene;
 }
 function wa(t) {
-  const e = Bl(t), o = Pl(e);
+  const e = ql(t), o = Pl(e);
   return Kl(o).then(
-    (n) => ql(mi(Ul(Tl(co(o, n), e), t)))
+    (n) => Bl(mi(Ul(Fl(co(o, n), e), t)))
   );
 }
 function Pl(t) {
   if (!t.appearance.compare || !t.edges.some((n) => n.was)) return t;
-  const e = Re(t.appearance), o = (n) => n ? Te(n, e).w : 0;
+  const e = Re(t.appearance), o = (n) => n ? Fe(n, e).w : 0;
   return {
     ...t,
     edges: t.edges.map((n) => n.was && o(n.was) > o(n.label) ? { ...n, label: n.was } : n)
   };
 }
-function Tl(t, e) {
+function Fl(t, e) {
   if (t.model.edges === e.edges) return t;
   const o = new Map(e.edges.map((n) => [n.id, n.label]));
   return {
@@ -5699,7 +5725,7 @@ function Mo(t) {
   const e = t.objects.filter((o) => o.parent === "root");
   return (Math.max(...e.map((o) => o.x + o.w)) - Math.min(...e.map((o) => o.x))) / (Math.max(...e.map((o) => o.y + o.h)) - Math.min(...e.map((o) => o.y)));
 }
-function Fl(t) {
+function Tl(t) {
   const e = (a) => `reading ${a.direction === "auto" ? "as the engine picks" : a.direction}`, o = [
     { label: `as written (${e(t)})`, layout: {} }
   ];
@@ -5738,15 +5764,15 @@ function mi(t) {
       n.filter((W) => W.parent === _).map((W) => W.id)
     )
   ).map((_) => t.byId.get(_)).map((_) => o.has(_.id) ? _ : { ..._, w: Cl(_, e) }), u = new Map(c.map((_, W) => [_.id, W])), i = t.model.phases.length ? Math.max(...t.model.phases.map((_) => ce(_.label, e.annotation))) + 2 * Le : 0, f = a.length ? e.groupHeader : 0, h = (_) => c[_ - 1].parent !== c[_].parent, l = !!t.model.appearance.compare, p = (_) => [_.label, l ? _.was : ""].filter((W) => !!W), m = (_) => {
-    const W = p(_).map((b) => Te(b, e, !0));
+    const W = p(_).map((b) => Fe(b, e, !0));
     return { w: Math.max(0, ...W.map((b) => b.w)), h: Math.max(0, ...W.map((b) => b.h)) };
   }, g = (_) => {
-    const W = p(_).map((b) => Bs(b, e));
+    const W = p(_).map((b) => qs(b, e));
     return W.length ? {
       right: Math.max(...W.map((b) => b.right)),
       above: Math.max(...W.map((b) => b.above)),
       below: Math.max(...W.map((b) => b.below))
-    } : Bs(void 0, e);
+    } : qs(void 0, e);
   }, y = /* @__PURE__ */ new Map(), P = c.map(() => []);
   for (const _ of t.edges) {
     const [W, b] = [u.get(_.source), u.get(_.target)].sort((et, at) => et - at);
@@ -5761,31 +5787,30 @@ function mi(t) {
       room: Y + ba + (h(W + 1) ? 2 * Le + c[W + 1].w / 2 : 0)
     });
   }
-  const A = [];
+  const O = [];
   c.forEach((_, W) => {
-    if (!W) return void A.push(i + Le + _.w / 2);
+    if (!W) return void O.push(i + Le + _.w / 2);
     const b = c[W - 1].w / 2 + Dl + (h(W) ? 2 * Le : 0) + _.w / 2;
-    A.push(Math.max(A[W - 1] + b, ...P[W].map((Y) => A[Y.from] + Y.room)));
+    O.push(Math.max(O[W - 1] + b, ...P[W].map((Y) => O[Y.from] + Y.room)));
   });
   let w = f + Math.max(0, ...c.map((_) => _.h)) - jl, k = 0;
-  const T = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map();
+  const F = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Map();
   for (const _ of t.edges) {
     const W = m(_).h, b = _.source === _.target ? g(_) : void 0, Y = b ? b.above : W && W + 1;
     w = Math.ceil(
       Math.max(w + Math.max(Ma, W ? W + 8 : 0), k + ba + Y)
-    ), T.set(_.id, w), k = b ? w + b.below : 0, F.set(_.id, { from: w - Math.max(W, Ma / 2) - 4, to: Math.max(w, k) + 8 }), b && (w += ve.down);
+    ), F.set(_.id, w), k = b ? w + b.below : 0, T.set(_.id, { from: w - Math.max(W, Ma / 2) - 4, to: Math.max(w, k) + 8 }), b && (w += ve.down);
   }
   const j = Math.max(w, k) + _l, $ = new Map(
     c.map((_) => {
-      const W = Wt(A[u.get(_.id)] - _.w / 2);
+      const W = Wt(O[u.get(_.id)] - _.w / 2);
       return [_.id, { x: W, w: _.w }];
     })
-  ), v = (_) => Math.max($.get(_.id).x + _.w, A[u.get(_.id)] + (y.get(_.id) ?? 0)), S = t.objects.map((_) => {
+  ), v = (_) => Math.max($.get(_.id).x + _.w, O[u.get(_.id)] + (y.get(_.id) ?? 0)), S = t.objects.map((_) => {
     if (_.type === "group") {
       const Y = c.filter((pt) => pt.parent === _.id), et = Wt(Math.min(...Y.map((pt) => $.get(pt.id).x)) - Le), at = Wt(Math.max(...Y.map((pt) => v(pt))) + Le - et);
       return {
         ..._,
-        shade: _.shade ?? 50,
         x: et,
         y: 0,
         w: at,
@@ -5810,18 +5835,18 @@ function mi(t) {
     };
   }), M = Math.min(0, ...S.map((_) => _.x)) - (i ? 0 : Le), x = Math.max(
     ...S.map((_) => _.x + _.w + Le),
-    ...c.map((_) => A[u.get(_.id)] + (y.get(_.id) ?? 0))
+    ...c.map((_) => O[u.get(_.id)] + (y.get(_.id) ?? 0))
   ), N = {
     x: M - an,
     y: -an,
     w: x - M + 2 * an,
     h: j + Le + 2 * an
-  }, z = t.model.appearance.notes ?? [], mt = new Map([...T].filter(([_]) => !t.byId.has(_))), it = xc(e, z, mt, {
+  }, z = t.model.appearance.notes ?? [], mt = new Map([...F].filter(([_]) => !t.byId.has(_))), it = xc(e, z, mt, {
     left: M - (i ? an : va),
     right: x + va,
     top: 0
   }), ht = it.filter((_) => _ !== null), Q = ht.length ? Cs([N, Cs(ht, an)]) : N, H = Q.x < N.x ? N.x : void 0, J = t.model.phases.map((_) => {
-    const W = _.ids.map((b) => F.get(b));
+    const W = _.ids.map((b) => T.get(b));
     return {
       id: _.id,
       label: _.label,
@@ -5838,7 +5863,7 @@ function mi(t) {
     ...t,
     objects: S,
     byId: new Map(S.map((_) => [_.id, _])),
-    edges: t.edges.map((_) => ({ ..._, lane: void 0, row: T.get(_.id) })),
+    edges: t.edges.map((_) => ({ ..._, lane: void 0, row: F.get(_.id) })),
     sequence: {
       panel: Q,
       phases: C,
@@ -5847,7 +5872,7 @@ function mi(t) {
     }
   };
 }
-function ql(t) {
+function Bl(t) {
   const e = t.model.wasOrder?.ids.flatMap((s) => t.edges.filter((r) => r.id === s));
   if (!e || !t.sequence) return t;
   const o = [...e], n = mi({
@@ -5866,7 +5891,7 @@ function ql(t) {
     }
   };
 }
-function Bl(t) {
+function ql(t) {
   if (!t.objects.some((n) => n.frame)) return t;
   const e = new Map(t.objects.map((n) => [n.id, n])), o = (n) => {
     const a = [];
@@ -5890,7 +5915,7 @@ function ls(t, e, o = 0) {
 const Hl = 8;
 function io(t = [], e = [], o) {
   const n = t.filter((s) => !e.includes(s)).length, a = e.filter((s) => !t.includes(s)).length;
-  return !n && !a ? 0 : (n + a) * On + (o && a ? oo : 0) + Hl;
+  return !n && !a ? 0 : (n + a) * An + (o && a ? oo : 0) + Hl;
 }
 function yi(t, e, o, n) {
   const a = new Set(t.flatMap((c) => o(c) ?? [])), s = (c, u) => (o(c) ?? []).filter((i) => !u.has(i)), r = new Set(e.flatMap((c) => o(c) ?? []));
@@ -5899,7 +5924,7 @@ function yi(t, e, o, n) {
     for (const u of e) d = Math.max(d, io(s(c, r), s(u, a), n));
   return d;
 }
-const qn = (t, e) => t.x < e.x + e.w && t.x + t.w > e.x && t.y < e.y + e.h && t.y + t.h > e.y, zl = (t, e) => ({
+const Bn = (t, e) => t.x < e.x + e.w && t.x + t.w > e.x && t.y < e.y + e.h && t.y + t.h > e.y, zl = (t, e) => ({
   x: t.x - e,
   y: t.y - e,
   w: t.w + 2 * e,
@@ -5935,7 +5960,7 @@ function Ul(t, e) {
   for (const f of [...o].sort((h, l) => d(l.id) - d(h.id))) {
     const h = [...a.values()].filter(($) => r($.id, f.id)), l = a.get(hn(n, f.id)), p = l ? Va(l, Kn(t.look, l.titleLines)) : { x: 0, y: 0 }, m = [...a.values()].filter(
       ($) => !$.frame && !r($.id, f.id) && !r(f.id, $.id)
-    ), g = h.flatMap(($) => c($).map((v) => zl(v, On)));
+    ), g = h.flatMap(($) => c($).map((v) => zl(v, An)));
     let y = [], P = 0;
     if (g.length) {
       const $ = g.reduce((it, ht) => ht.y < it.y || ht.y === it.y && ht.x < it.x ? ht : it);
@@ -5946,7 +5971,7 @@ function Ul(t, e) {
         w: Math.max(...y.map((it) => it.x + it.w)) - v,
         h: Math.max(...y.map((it) => it.y + it.h)) - S
       };
-      m.some((it) => qn(it, M)) || (y = [M]);
+      m.some((it) => Bn(it, M)) || (y = [M]);
       const x = (it, ht) => Math.max(ht.x - (it.x + it.w), it.x - (ht.x + ht.w), ht.y - (it.y + it.h), it.y - (ht.y + ht.h), 0), N = [y[0]], z = y.slice(1), mt = [];
       for (; z.length; ) {
         let it = { gap: 1 / 0, a: y[0], i: 0 };
@@ -5956,27 +5981,27 @@ function Ul(t, e) {
             _ < it.gap && (it = { gap: _, a: H, i: C });
           });
         const [ht] = z.splice(it.i, 1);
-        if (N.push(ht), qn(it.a, ht)) continue;
+        if (N.push(ht), Bn(it.a, ht)) continue;
         const Q = Wl(it.a, ht);
-        m.some((H) => qn(H, Q)) ? P++ : mt.push(Q);
+        m.some((H) => Bn(H, Q)) ? P++ : mt.push(Q);
       }
       y.push(...mt);
     }
-    const A = y.length ? Math.min(...y.map(($) => $.x)) : p.x, w = y.length ? Math.min(...y.map(($) => $.y)) : p.y, k = y.length ? Math.max(...y.map(($) => $.x + $.w)) : p.x, T = y.length ? Math.max(...y.map(($) => $.y + $.h)) : p.y, F = { x: A - p.x, y: w - p.y };
+    const O = y.length ? Math.min(...y.map(($) => $.x)) : p.x, w = y.length ? Math.min(...y.map(($) => $.y)) : p.y, k = y.length ? Math.max(...y.map(($) => $.x + $.w)) : p.x, F = y.length ? Math.max(...y.map(($) => $.y + $.h)) : p.y, T = { x: O - p.x, y: w - p.y };
     if (a.set(f.id, {
       ...f,
-      x: A,
+      x: O,
       y: w,
-      w: k - A,
-      h: T - w,
-      localX: F.x,
-      localY: F.y,
-      baseX: F.x,
-      baseY: F.y,
+      w: k - O,
+      h: F - w,
+      localX: T.x,
+      localY: T.y,
+      baseX: T.x,
+      baseY: T.y,
       depth: d(f.id),
-      hull: y.map(($) => ({ x: $.x - A, y: $.y - w, w: $.w, h: $.h }))
+      hull: y.map(($) => ({ x: $.x - O, y: $.y - w, w: $.w, h: $.h }))
     }), f.frame !== "soft") continue;
-    const j = m.filter(($) => y.some((v) => qn($, v)));
+    const j = m.filter(($) => y.some((v) => Bn($, v)));
     j.length && s.push({
       level: "warning",
       code: "soft-overlap",
@@ -6018,7 +6043,7 @@ function $e(t) {
   const { width: e, height: o } = sn;
   return e >= 700 && e / o > 1.12 ? "right" : "down";
 }
-function Bn(t, e) {
+function qn(t, e) {
   const o = new Map(t.objects.map((n) => [n.id, n.parent]));
   for (let n = e; n; n = n === "root" ? void 0 : o.get(n)) {
     const a = t.layouts.find((s) => s.scope === n);
@@ -6117,13 +6142,13 @@ function tf(t, e, o) {
   let a = Math.max(e, Ql);
   if (n <= a * Zl) return { w: n, lines: 1 };
   const s = () => tn(t, a - no, o.groupTitle, !0).length;
-  for (; s() > qs && a < n; ) a += 8;
-  return { w: Math.min(a, n), lines: Math.min(s(), qs) };
+  for (; s() > Bs && a < n; ) a += 8;
+  return { w: Math.min(a, n), lines: Math.min(s(), Bs) };
 }
-const Sa = 16, ef = 1.5, nf = 640, Fe = 14;
+const Sa = 16, ef = 1.5, nf = 640, Te = 14;
 function bo(t, e, o, n) {
-  const a = Te(o, n);
-  return { a: t, b: e, w: a.w + 2 * Fe, h: a.h + 2 * Fe };
+  const a = Fe(o, n);
+  return { a: t, b: e, w: a.w + 2 * Te, h: a.h + 2 * Te };
 }
 function Ho(t, e, o, n, a) {
   let s = n;
@@ -6204,7 +6229,7 @@ function Ln(t, e) {
   for (const h of t) (f[c.get(h)] ||= []).push(h);
   return f.filter(Boolean);
 }
-const xi = 3, Ia = 5, Oa = 1.25, Ve = 20, rf = 3, cf = 2, lf = 1;
+const xi = 3, Ia = 5, Aa = 1.25, Ve = 20, rf = 3, cf = 2, lf = 1;
 function ff(t, e) {
   const o = new Map(t.map((d) => [d, []]));
   for (const [d, c] of e) o.get(d)?.push(c);
@@ -6238,32 +6263,32 @@ function ko(t, e, o, n, a, s = [], r = /* @__PURE__ */ new Set(), d = e, {
   let y = m(d);
   const P = (Q) => Q.map((H) => [...H.ids].sort().join(",")).join("|");
   P(y) !== P(g) && (d = e, y = g);
-  const A = (Q, H) => {
+  const O = (Q, H) => {
     const J = Math.min(...t.map((_) => Q.get(_.id)[H]));
     return Math.max(...t.map((_) => Q.get(_.id)[H] + p(_, H))) - J;
-  }, w = (Q, H, J = 1) => Q <= i * J || Q <= c * H * J, k = (Q) => w(A(Q, h), A(Q, l)), T = (Q) => k(Q) || A(Q, h) <= i * Oa;
-  if (t.length < u || k(d) && T(e)) return { positions: e };
-  const F = new Map(g.flatMap((Q, H) => Q.ids.map((J) => [J, H]))), j = (Q, H, J) => {
-    const [C, _] = [F.get(H), F.get(J)];
+  }, w = (Q, H, J = 1) => Q <= i * J || Q <= c * H * J, k = (Q) => w(O(Q, h), O(Q, l)), F = (Q) => k(Q) || O(Q, h) <= i * Aa;
+  if (t.length < u || k(d) && F(e)) return { positions: e };
+  const T = new Map(g.flatMap((Q, H) => Q.ids.map((J) => [J, H]))), j = (Q, H, J) => {
+    const [C, _] = [T.get(H), T.get(J)];
     return C !== void 0 && _ !== void 0 && Math.min(C, _) < Q && Math.max(C, _) >= Q;
   }, $ = (Q) => a.filter(([H, J]) => j(Q, H, J)).length, v = ff(
     t.map((Q) => Q.id),
     a
   ), S = (Q) => rf * [...r].filter((H) => a.some((J) => J[0] === H && j(Q, ...J))).length + cf * v.filter((H) => H.some((J) => j(Q, H[0], J))).length, M = (Q, H) => {
-    const J = (H ? s : []).filter((C) => j(Q, C.a, C.b)).map((C) => (o === "right" ? C.h : C.w) - 2 * Fe);
+    const J = (H ? s : []).filter((C) => j(Q, C.a, C.b)).map((C) => (o === "right" ? C.h : C.w) - 2 * Te);
     return Math.max(
       n + 40,
       84,
-      J.length ? Math.max(...J) + 2 * Fe : 0,
+      J.length ? Math.max(...J) + 2 * Te : 0,
       ($(Q) + 1) * Ve + J.reduce((C, _) => C + _, 0)
     );
   }, x = (Q, H) => {
     const J = H[H.length - 1].end - H[0].start, C = [], _ = new Map(H.flatMap((W) => W.ids.map((b) => [b, W.start])));
     for (let W = 1; W < Q; W++) {
-      const b = (Mt) => a.filter((xt) => j(Mt, ...xt)).reduce((xt, [O, E]) => {
-        const [L, R] = F.get(O) < F.get(E) ? [O, E] : [E, O];
+      const b = (Mt) => a.filter((xt) => j(Mt, ...xt)).reduce((xt, [A, E]) => {
+        const [L, R] = T.get(A) < T.get(E) ? [A, E] : [E, A];
         return xt + Math.abs(_.get(L) - at - (_.get(R) - H[Mt].start));
-      }, 0) / (J / Q), Y = H[0].start + J * W / Q, et = (Mt) => $(Mt) + S(Mt) + b(Mt) * lf + Math.abs(H[Mt].start - Y) / (J / Q) * 2, at = H[C.at(-1) ?? 0].start, pt = J / Q, ot = (Mt, xt, O) => H[Mt - 1].end - at >= pt * O && H[Mt - 1].end - at <= pt * (1 + xt) && H[H.length - 1].end - H[Mt].start <= pt * (Q - W) * (1 + xt), K = (Mt) => !S(Mt) && ot(Mt, 0.25, 0.5) ? 0 : !S(Mt) && ot(Mt, 0.5, 0) ? 1 : ot(Mt, 0.25, 0.5) ? 2 : 3;
+      }, 0) / (J / Q), Y = H[0].start + J * W / Q, et = (Mt) => $(Mt) + S(Mt) + b(Mt) * lf + Math.abs(H[Mt].start - Y) / (J / Q) * 2, at = H[C.at(-1) ?? 0].start, pt = J / Q, ot = (Mt, xt, A) => H[Mt - 1].end - at >= pt * A && H[Mt - 1].end - at <= pt * (1 + xt) && H[H.length - 1].end - H[Mt].start <= pt * (Q - W) * (1 + xt), K = (Mt) => !S(Mt) && ot(Mt, 0.25, 0.5) ? 0 : !S(Mt) && ot(Mt, 0.5, 0) ? 1 : ot(Mt, 0.25, 0.5) ? 2 : 3;
       let ft = 0;
       for (let Mt = (C.at(-1) ?? 0) + 1; Mt < H.length; Mt++)
         (!ft || K(Mt) < K(ft) || K(Mt) === K(ft) && et(Mt) < et(ft)) && (ft = Mt);
@@ -6284,11 +6309,11 @@ function ko(t, e, o, n, a, s = [], r = /* @__PURE__ */ new Set(), d = e, {
       const et = [];
       for (const at of Y[0].ids) {
         if (r.has(at)) continue;
-        const pt = a.filter(([O, E]) => E === at && O !== at).map(([O]) => O), ot = a.filter(([O, E]) => O === at && E !== at).map(([, O]) => O);
-        if (!pt.length || pt.some((O) => C.get(O) !== b - 1)) continue;
-        const K = (O, E) => _.get(O) - J[E][0].start, ft = (O) => pt.reduce((E, L) => E + Math.abs(K(L, b - 1) - K(at, O)), 0) + ot.reduce((E, L) => E + Math.abs(K(at, O) - K(L, C.get(L))), 0), Mt = (O) => (O === b - 1 ? 0 : pt.length) + ot.filter((E) => C.get(E) !== O).length;
+        const pt = a.filter(([A, E]) => E === at && A !== at).map(([A]) => A), ot = a.filter(([A, E]) => A === at && E !== at).map(([, A]) => A);
+        if (!pt.length || pt.some((A) => C.get(A) !== b - 1)) continue;
+        const K = (A, E) => _.get(A) - J[E][0].start, ft = (A) => pt.reduce((E, L) => E + Math.abs(K(L, b - 1) - K(at, A)), 0) + ot.reduce((E, L) => E + Math.abs(K(at, A) - K(L, C.get(L))), 0), Mt = (A) => (A === b - 1 ? 0 : pt.length) + ot.filter((E) => C.get(E) !== A).length;
         if (Mt(b - 1) > Mt(b) || ft(b - 1) >= ft(b)) continue;
-        const xt = pt.reduce((O, E) => _.get(E) > _.get(O) ? E : O);
+        const xt = pt.reduce((A, E) => _.get(E) > _.get(A) ? E : A);
         et.push({ id: at, source: xt, saves: ft(b) - ft(b - 1) });
       }
       et.sort((at, pt) => pt.saves - at.saves);
@@ -6302,9 +6327,9 @@ function ko(t, e, o, n, a, s = [], r = /* @__PURE__ */ new Set(), d = e, {
       const ot = [];
       for (const [K, ft] of _) {
         const Mt = f.get(K);
-        let O = J.get(ft)[l] + (p(f.get(ft), l) - p(Mt, l)) / 2;
-        for (const E of ot) O < E.hi + n && O + p(Mt, l) > E.lo && (O = E.hi + n);
-        ot.push({ lo: O, hi: O + p(Mt, l) }), J.set(K, { ...J.get(K), [l]: O });
+        let A = J.get(ft)[l] + (p(f.get(ft), l) - p(Mt, l)) / 2;
+        for (const E of ot) A < E.hi + n && A + p(Mt, l) > E.lo && (A = E.hi + n);
+        ot.push({ lo: A, hi: A + p(Mt, l) }), J.set(K, { ...J.get(K), [l]: A });
       }
     }
     const b = /* @__PURE__ */ new Map(), Y = [];
@@ -6313,13 +6338,13 @@ function ko(t, e, o, n, a, s = [], r = /* @__PURE__ */ new Set(), d = e, {
       const ft = W[ot + 1]?.[0].ids ?? [], Mt = [
         ...K.flatMap((V) => V.ids).filter((V) => !_.has(V)),
         ...ft.filter((V) => _.has(V))
-      ], xt = Math.min(...Mt.map((V) => J.get(V)[h])), O = Math.min(...Mt.map((V) => J.get(V)[l])), E = Math.max(...Mt.map((V) => J.get(V)[l] + p(f.get(V), l)));
+      ], xt = Math.min(...Mt.map((V) => J.get(V)[h])), A = Math.min(...Mt.map((V) => J.get(V)[l])), E = Math.max(...Mt.map((V) => J.get(V)[l] + p(f.get(V), l)));
       for (const V of Mt) {
-        const G = J.get(V), X = G[h] - xt, D = G[l] - O + et;
+        const G = J.get(V), X = G[h] - xt, D = G[l] - A + et;
         b.set(V, o === "right" ? { x: X, y: D } : { x: D, y: X });
       }
       const L = ot < Q.length ? M(Q[ot], C) : 0, R = Mt.filter((V) => !N.has(V)), Z = R.length ? R : Mt;
-      et += E - O + L, pt += Math.max(...Z.map((V) => J.get(V)[l] + p(f.get(V), l))) - Math.min(...Z.map((V) => J.get(V)[l])) + L, at = Math.max(
+      et += E - A + L, pt += Math.max(...Z.map((V) => J.get(V)[l] + p(f.get(V), l))) - Math.min(...Z.map((V) => J.get(V)[l])) + L, at = Math.max(
         at,
         Math.max(...Mt.map((V) => J.get(V)[h] + p(f.get(V), h))) - xt
       ), Y.push(Mt);
@@ -6340,7 +6365,7 @@ function ko(t, e, o, n, a, s = [], r = /* @__PURE__ */ new Set(), d = e, {
       H.count === Q && w(H.length, H.depth) && (ht = Q);
     }
   for (let Q = Math.max(2, ht); Q <= g.length; Q++) {
-    const H = x(Q, y), J = it(H, g, e, !0), C = Q === ht ? Oa : 1;
+    const H = x(Q, y), J = it(H, g, e, !0), C = Q === ht ? Aa : 1;
     if (J.count !== Q || !w(J.length, J.depth, C)) continue;
     const _ = mt(H, y), W = _.size ? it(H, g, e, !0, _) : void 0, b = W && w(W.length, W.depth, C) ? W : J;
     return { positions: b.out, fold: { bands: b.bands, axis: o } };
@@ -6350,11 +6375,11 @@ function ko(t, e, o, n, a, s = [], r = /* @__PURE__ */ new Set(), d = e, {
 function df(t, e, o, n, a) {
   const s = /* @__PURE__ */ new Map();
   for (const { scope: r, fold: d } of t) {
-    const c = d.axis === "right", u = (A) => c ? A.y : A.x, i = (A) => c ? A.y + A.h : A.x + A.w, f = (A) => c ? A.x : A.y, h = (A) => c ? A.x + A.w : A.y + A.h, l = (A) => (f(A) + h(A)) / 2, p = (A) => (u(A) + i(A)) / 2, m = (A, w) => f(A) < h(w) && h(A) > f(w), g = new Map(d.bands.flatMap((A, w) => A.map((k) => [k, w]))), y = (A) => g.get(n(A.id, r) ?? ""), P = (A) => [...o.values()].filter((w) => w.type !== "group" && y(w) === A);
-    for (let A = 0; A + 1 < d.bands.length; A++) {
-      const w = d.bands[A].map((ht) => o.get(ht)), k = d.bands[A + 1].map((ht) => o.get(ht)), T = Math.max(...w.map(i)), F = Math.min(...k.map(u)), j = Math.max(...w.map(h)) + Ve, $ = Math.min(...k.map(f)) - Ve, [v, S] = [P(A), P(A + 1)], M = e.flatMap((ht) => {
+    const c = d.axis === "right", u = (O) => c ? O.y : O.x, i = (O) => c ? O.y + O.h : O.x + O.w, f = (O) => c ? O.x : O.y, h = (O) => c ? O.x + O.w : O.y + O.h, l = (O) => (f(O) + h(O)) / 2, p = (O) => (u(O) + i(O)) / 2, m = (O, w) => f(O) < h(w) && h(O) > f(w), g = new Map(d.bands.flatMap((O, w) => O.map((k) => [k, w]))), y = (O) => g.get(n(O.id, r) ?? ""), P = (O) => [...o.values()].filter((w) => w.type !== "group" && y(w) === O);
+    for (let O = 0; O + 1 < d.bands.length; O++) {
+      const w = d.bands[O].map((ht) => o.get(ht)), k = d.bands[O + 1].map((ht) => o.get(ht)), F = Math.max(...w.map(i)), T = Math.min(...k.map(u)), j = Math.max(...w.map(h)) + Ve, $ = Math.min(...k.map(f)) - Ve, [v, S] = [P(O), P(O + 1)], M = e.flatMap((ht) => {
         const Q = o.get(ht.source), H = o.get(ht.target);
-        if (y(Q) !== A || y(H) !== A + 1) return [];
+        if (y(Q) !== O || y(H) !== O + 1) return [];
         if (ht.from !== "auto" || ht.to !== "auto") return [];
         const J = v.some((W) => u(W) > u(Q) && m(W, Q)), C = n(ht.target, r) !== ht.target || S.some((W) => u(W) < u(H) && m(W, H)), _ = (W, b) => u(W) < i(b) && i(W) > u(b);
         return J && v.some((W) => _(W, Q) && f(W) >= h(Q)) ? [] : C && S.some((W) => _(W, H) && h(W) <= f(H)) ? [] : [{ id: ht.id, source: Q, target: H, leave: J, enter: C }];
@@ -6368,12 +6393,12 @@ function df(t, e, o, n, a) {
           x.set(H.id, l(H.source) + _);
         });
       }
-      if (!M.length || F - T < (M.length + 1) * Ve) continue;
+      if (!M.length || T - F < (M.length + 1) * Ve) continue;
       const z = (ht) => {
         const Q = ht.filter((J) => J.leave), H = ht.filter((J) => J.enter);
         return ht.map((J, C) => ({
           w: J,
-          at: Wt(T + (F - T) * (C + 1) / (ht.length + 1)),
+          at: Wt(F + (T - F) * (C + 1) / (ht.length + 1)),
           leave: J.leave ? Wt(j + Ve * Q.indexOf(J)) : void 0,
           enter: J.enter ? Wt($ - Ve * (H.length - 1 - H.indexOf(J))) : void 0
         }));
@@ -6383,7 +6408,7 @@ function df(t, e, o, n, a) {
           { u: J, v: p(Q.source) },
           { u: J, v: H }
         ] : [
-          { u: x.get(Q.id), v: T },
+          { u: x.get(Q.id), v: F },
           { u: x.get(Q.id), v: H }
         ],
         ...C !== void 0 ? [
@@ -6392,7 +6417,7 @@ function df(t, e, o, n, a) {
           { u: f(Q.target), v: p(Q.target) }
         ] : [
           { u: l(Q.target), v: H },
-          { u: l(Q.target), v: F }
+          { u: l(Q.target), v: T }
         ]
       ]), it = uf(
         [...M].sort((ht, Q) => l(Q.source) - l(ht.source)),
@@ -6461,15 +6486,15 @@ function gf(t, e, o) {
     i[n] < u[n] && ([u, i] = [i, u]);
     const f = u[n] + s(u, n), h = i[n];
     if (h <= f) continue;
-    const l = (e === "right" ? c.w : c.h) - 2 * Fe, p = (e === "right" ? c.h : c.w) - 2 * Fe, m = f - l / 2 - ze, g = h + l / 2 + ze, y = u[a] + s(u, a) / 2, P = i[a] + s(i, a) / 2, A = Math.min(y, P) + ze, w = Math.max(y, P) - ze;
-    if (w - A < p) continue;
+    const l = (e === "right" ? c.w : c.h) - 2 * Te, p = (e === "right" ? c.h : c.w) - 2 * Te, m = f - l / 2 - ze, g = h + l / 2 + ze, y = u[a] + s(u, a) / 2, P = i[a] + s(i, a) / 2, O = Math.min(y, P) + ze, w = Math.max(y, P) - ze;
+    if (w - O < p) continue;
     const k = [
       ...[...t.values()].filter(($) => $[n] < g && $[n] + s($, n) > m).map(($) => ({
         lo: $[a] - ze,
         hi: $[a] + s($, a) + ze
       })),
       ...r.filter(($) => $.from < g && $.to > m)
-    ], T = ($) => k.every((v) => $ + p <= v.lo || $ >= v.hi), F = (A + w - p) / 2, j = [A, F, ...k.map(($) => $.hi)].filter(($) => $ >= A && $ + p <= w && T($)).sort(($, v) => Math.abs($ - F) - Math.abs(v - F))[0];
+    ], F = ($) => k.every((v) => $ + p <= v.lo || $ >= v.hi), T = (O + w - p) / 2, j = [O, T, ...k.map(($) => $.hi)].filter(($) => $ >= O && $ + p <= w && F($)).sort(($, v) => Math.abs($ - T) - Math.abs(v - T))[0];
     j !== void 0 && (d.add(c), r.push({ lo: j - ze, hi: j + p + ze, from: m, to: g }));
   }
   return d;
@@ -6496,7 +6521,7 @@ function wf(t, e, o, n, a) {
 }
 function Mf(t, e, o, n, a, s, r = !1, d = [], c = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), i = () => {
 }) {
-  const f = new Map(t.map((H) => [H.id, H])), h = t.map((H) => H.id), l = o === "right", p = (H) => l ? f.get(H).w : f.get(H).h, m = (H) => l ? f.get(H).h : f.get(H).w, g = (H) => f.get(H).type === "group", y = (H) => l ? H.y + H.h / 2 : H.x + H.w / 2, P = new Set(n.flat()), A = (H) => {
+  const f = new Map(t.map((H) => [H.id, H])), h = t.map((H) => H.id), l = o === "right", p = (H) => l ? f.get(H).w : f.get(H).h, m = (H) => l ? f.get(H).h : f.get(H).w, g = (H) => f.get(H).type === "group", y = (H) => l ? H.y + H.h / 2 : H.x + H.w / 2, P = new Set(n.flat()), O = (H) => {
     const J = !P.size || P.has(H) ? [] : (c.get(H) ?? []).flatMap((_) => e.get(_) ?? []);
     if (J.length) return J.reduce((_, W) => _ + y(W), 0) / J.length;
     const C = e.get(H);
@@ -6504,7 +6529,7 @@ function Mf(t, e, o, n, a, s, r = !1, d = [], c = /* @__PURE__ */ new Map(), u =
   }, w = (H, J) => Math.max(
     Ho(a, H, J, g(H) || g(J) ? s.group : s.node, !l),
     io(f.get(H).soft, f.get(J).soft, l)
-  ), k = (H) => H.reduce((J, C, _) => J + m(C) + (_ ? w(H[_ - 1], C) : 0), 0), T = wf(
+  ), k = (H) => H.reduce((J, C, _) => J + m(C) + (_ ? w(H[_ - 1], C) : 0), 0), F = wf(
     Ln(h, n),
     n,
     r ? g : () => !1,
@@ -6512,21 +6537,21 @@ function Mf(t, e, o, n, a, s, r = !1, d = [], c = /* @__PURE__ */ new Map(), u =
     k
   ).map(
     (H) => ls(
-      [...H].sort((J, C) => A(J) - A(C) || h.indexOf(J) - h.indexOf(C)),
+      [...H].sort((J, C) => O(J) - O(C) || h.indexOf(J) - h.indexOf(C)),
       (J) => f.get(J).soft
     )
-  ), F = new Map(T.flatMap((H, J) => H.map((C) => [C, J]))), j = T.map(k), $ = Math.max(...j), v = new Map(h.map((H) => [H, /* @__PURE__ */ new Set()])), S = new Map(h.map((H) => [H, /* @__PURE__ */ new Set()]));
+  ), T = new Map(F.flatMap((H, J) => H.map((C) => [C, J]))), j = F.map(k), $ = Math.max(...j), v = new Map(h.map((H) => [H, /* @__PURE__ */ new Set()])), S = new Map(h.map((H) => [H, /* @__PURE__ */ new Set()]));
   for (const [H, J] of n)
-    F.get(J) > F.get(H) && (v.get(H).add(J), S.get(J).add(H));
+    T.get(J) > T.get(H) && (v.get(H).add(J), S.get(J).add(H));
   const M = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map();
-  for (const [H, J] of T.entries()) {
+  for (const [H, J] of F.entries()) {
     let C = ($ - j[H]) / 2, _ = -1 / 0;
     for (const [W, b] of J.entries()) {
       const [Y] = S.get(b), et = S.get(b).size === 1 && v.get(Y).size === 1, at = et ? i(Y, b) : void 0, pt = at !== void 0 ? M.get(Y) + at : et ? x.get(Y) - m(b) / 2 : C, ot = W ? Math.max(pt, _ + w(J[W - 1], b)) : pt;
       M.set(b, ot), x.set(b, ot + m(b) / 2), _ = ot + m(b), C = Math.max(C + m(b), _) + (J[W + 1] ? w(b, J[W + 1]) : 0);
     }
   }
-  const N = T.length === 1 && z(T[0]);
+  const N = F.length === 1 && z(F[0]);
   function z(H) {
     const J = H.map((b) => u.get(b));
     if (H.length < 2 || J.some((b, Y) => b === void 0 || Y && b < J[Y - 1]))
@@ -6540,14 +6565,14 @@ function Mf(t, e, o, n, a, s, r = !1, d = [], c = /* @__PURE__ */ new Map(), u =
     const W = J.at(-1) - J[0] + (m(H[0]) + m(H.at(-1))) / 2;
     return _ - C[0] > Math.max(j[0] * 1.25, W + 1) ? !1 : (H.forEach((b, Y) => M.set(b, C[Y])), !0);
   }
-  const mt = Math.min(...M.values()), it = zo(T, d, a, o), ht = /* @__PURE__ */ new Map();
+  const mt = Math.min(...M.values()), it = zo(F, d, a, o), ht = /* @__PURE__ */ new Map();
   let Q = 0;
-  for (const [H, J] of T.entries()) {
+  for (const [H, J] of F.entries()) {
     for (const W of J) {
       const b = Wt(M.get(W) - mt);
       ht.set(W, l ? { x: Q, y: b } : { x: b, y: Q });
     }
-    const C = T[H + 1];
+    const C = F[H + 1];
     if (!C) break;
     let _ = Math.max(
       J.some(g) || C.some(g) ? s.group : s.rank,
@@ -6555,7 +6580,7 @@ function Mf(t, e, o, n, a, s, r = !1, d = [], c = /* @__PURE__ */ new Map(), u =
       yi(J, C, (W) => f.get(W).soft, !l)
     );
     for (const W of a)
-      Math.min(F.get(W.a), F.get(W.b)) === H && Math.abs(F.get(W.a) - F.get(W.b)) === 1 && (_ = Math.max(_, l ? W.w : W.h));
+      Math.min(T.get(W.a), T.get(W.b)) === H && Math.abs(T.get(W.a) - T.get(W.b)) === 1 && (_ = Math.max(_, l ? W.w : W.h));
     Q += Math.max(...J.map(p)) + _;
   }
   return { positions: ht, axis: o, followed: N };
@@ -6581,7 +6606,7 @@ function bf(t, e, o, n) {
 }
 const ro = 20;
 function zo(t, e, o, n) {
-  const a = new Map(t.flatMap((d, c) => d.map((u) => [u, c]))), s = (d) => n === "right" ? 2 * Fe : d.h, r = 2 * Fe;
+  const a = new Map(t.flatMap((d, c) => d.map((u) => [u, c]))), s = (d) => n === "right" ? 2 * Te : d.h, r = 2 * Te;
   return t.slice(0, -1).map((d, c) => {
     let u = 0, i = 0;
     const f = [...o], h = [], l = [];
@@ -6589,12 +6614,12 @@ function zo(t, e, o, n) {
       const g = m.a !== void 0 ? a.get(m.a) : void 0, y = m.b !== void 0 ? a.get(m.b) : void 0;
       let P;
       if (g !== void 0 && y !== void 0) {
-        const A = Math.min(g, y), w = Math.max(g, y);
-        if (P = A <= c && w > c && (A === c || w === c + 1), !P) continue;
+        const O = Math.min(g, y), w = Math.max(g, y);
+        if (P = O <= c && w > c && (O === c || w === c + 1), !P) continue;
         const k = f.findIndex(
-          (T) => T.a === m.a && T.b === m.b || T.a === m.b && T.b === m.a
+          (F) => F.a === m.a && F.b === m.b || F.a === m.b && F.b === m.a
         );
-        k >= 0 && (i += s(f.splice(k, 1)[0]) - r, A === c && w === c + 1 && l.push(m));
+        k >= 0 && (i += s(f.splice(k, 1)[0]) - r, O === c && w === c + 1 && l.push(m));
       } else {
         if (P = g !== void 0 ? g === c : y === c + 1, !P) continue;
         m.label && o.length && (i += s(m.label) - (n === "right" ? r : 0));
@@ -6620,13 +6645,13 @@ function vf(t, e, o, n, a) {
     for (const [y, P] of i.entries())
       h.push(y ? h[y - 1] + n.get(P) - n.get(i[y - 1]) : 0);
     const l = i.map((y, P) => {
-      const A = (f.get(y) ?? []).map(d).sort((k, T) => k - T);
-      return (A.length ? A[A.length - 1 >> 1] : d(y)) - a(y) / 2 - h[P];
+      const O = (f.get(y) ?? []).map(d).sort((k, F) => k - F);
+      return (O.length ? O[O.length - 1 >> 1] : d(y)) - a(y) / 2 - h[P];
     }), p = [], m = (y) => y[y.length >> 1];
     for (const y of l)
       for (p.push([y]); p.length > 1 && m(p.at(-2)) > m(p.at(-1)); ) {
         const P = p.pop();
-        p.push([...p.pop(), ...P].sort((A, w) => A - w));
+        p.push([...p.pop(), ...P].sort((O, w) => O - w));
       }
     let g = 0;
     for (const y of p)
@@ -6679,40 +6704,40 @@ function Sf(t, e, o, n = [], a = [], s) {
       );
     }
   } else {
-    const f = t.map(($) => $.id), h = ($) => i.get($).soft, l = o.length ? If(Ln(f, o), o, ($) => ls($, h)) : null, p = l ? l.layers : f.map(($) => [$]), m = !!l && l.chains.size >= Of && l.crossings <= 2 * l.chains.size && !t.some(($) => $.soft?.length), g = m ? l.order : p, y = m ? o.flatMap(([$, v], S) => {
+    const f = t.map(($) => $.id), h = ($) => i.get($).soft, l = o.length ? If(Ln(f, o), o, ($) => ls($, h)) : null, p = l ? l.layers : f.map(($) => [$]), m = !!l && l.chains.size >= Af && l.crossings <= 2 * l.chains.size && !t.some(($) => $.soft?.length), g = m ? l.order : p, y = m ? o.flatMap(([$, v], S) => {
       const M = [$, ...l.chains.get(S) ?? [], v];
       return M.slice(1).map((x, N) => [M[N], x]);
-    }) : o, P = ($) => _e($) ? 0 : c === "right" ? i.get($).w : i.get($).h, A = ($) => _e($) ? 0 : c === "right" ? i.get($).h : i.get($).w, w = new Map(g.flatMap(($, v) => $.map((S) => [S, v]))), k = zo(p, a, n, c), T = /* @__PURE__ */ new Map();
+    }) : o, P = ($) => _e($) ? 0 : c === "right" ? i.get($).w : i.get($).h, O = ($) => _e($) ? 0 : c === "right" ? i.get($).h : i.get($).w, w = new Map(g.flatMap(($, v) => $.map((S) => [S, v]))), k = zo(p, a, n, c), F = /* @__PURE__ */ new Map();
     for (const $ of g) {
       let v = 0, S;
       for (const [M, x] of $.entries()) {
         const N = $[M - 1];
         N !== void 0 && _e(N) ? v += _e(x) ? wi : ro : N !== void 0 && _e(x) && (v += ro), !_e(x) && S !== void 0 && (v = Math.max(
           v,
-          T.get(S) + A(S) + Math.max(
+          F.get(S) + O(S) + Math.max(
             Ho(n, S, x, d, c !== "right"),
             io(h(S), h(x), c === "right")
           )
-        )), T.set(x, v), v += A(x), _e(x) || (S = x);
+        )), F.set(x, v), v += O(x), _e(x) || (S = x);
       }
     }
-    o.length && vf(g, y, w, T, A);
-    const F = kf(g.length, y, w, ($) => T.get($) + A($) / 2);
+    o.length && vf(g, y, w, F, O);
+    const T = kf(g.length, y, w, ($) => F.get($) + O($) / 2);
     m && $c(
       c,
       g,
       o.flatMap(
         ([v, S], M) => w.get(v) < w.get(S) ? [{ id: String(M), chain: [v, ...l.chains.get(M) ?? [], S] }] : []
       ),
-      (v) => _e(v) ? void 0 : c === "right" ? { x: 0, y: T.get(v), w: P(v), h: A(v) } : { x: T.get(v), y: 0, w: A(v), h: P(v) },
-      (v) => T.get(v),
+      (v) => _e(v) ? void 0 : c === "right" ? { x: 0, y: F.get(v), w: P(v), h: O(v) } : { x: F.get(v), y: 0, w: O(v), h: P(v) },
+      (v) => F.get(v),
       s
-    ).forEach((v, S) => F[S] = Math.max(F[S] ?? 0, v));
+    ).forEach((v, S) => T[S] = Math.max(T[S] ?? 0, v));
     let j = 0;
     for (const [$, v] of p.entries()) {
-      let S = Math.max(d, k[$] ?? 0, F[$] ?? 0);
+      let S = Math.max(d, k[$] ?? 0, T[$] ?? 0);
       for (const M of v) {
-        const x = T.get(M);
+        const x = F.get(M);
         r.set(M, c === "right" ? { x: j, y: x } : { x, y: j });
       }
       p[$ + 1] && (S = Math.max(S, yi(v, p[$ + 1], h, c === "down")));
@@ -6723,7 +6748,7 @@ function Sf(t, e, o, n = [], a = [], s) {
     m && (u = {
       order: g,
       chains: l.chains,
-      across: new Map(g.flat().flatMap(($) => _e($) ? [[$, T.get($)]] : []))
+      across: new Map(g.flat().flatMap(($) => _e($) ? [[$, F.get($)]] : []))
     });
   }
   return { positions: r, axis: c, corridors: u };
@@ -6745,13 +6770,13 @@ function Mi(t, e, o = (n) => n) {
 }
 const Ef = 8;
 function If(t, e, o = (n) => n) {
-  const n = Mi(t, e, o), a = new Map(n.flatMap((k, T) => k.map((F) => [F, T]))), s = n.map((k) => [...k]), r = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), c = (k, T) => {
-    d.set(k, [...d.get(k) ?? [], T]), r.set(T, [...r.get(T) ?? [], k]);
+  const n = Mi(t, e, o), a = new Map(n.flatMap((k, F) => k.map((T) => [T, F]))), s = n.map((k) => [...k]), r = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), c = (k, F) => {
+    d.set(k, [...d.get(k) ?? [], F]), r.set(F, [...r.get(F) ?? [], k]);
   }, u = new Set(a.keys()), i = /* @__PURE__ */ new Map();
-  for (const [k, [T, F]] of e.entries()) {
-    const j = a.get(T), $ = a.get(F);
+  for (const [k, [F, T]] of e.entries()) {
+    const j = a.get(F), $ = a.get(T);
     if (j === void 0 || $ === void 0 || j >= $) continue;
-    let v = T;
+    let v = F;
     i.set(k, []);
     for (let S = j + 1; S < $; S++) {
       const M = `\0${k}:${S}`;
@@ -6759,67 +6784,67 @@ function If(t, e, o = (n) => n) {
       const x = s[S].indexOf(v);
       s[S].splice(x < 0 ? s[S].length : x + 1, 0, M), c(v, M), v = M;
     }
-    c(v, F);
+    c(v, T);
   }
   if (s.length < 2) return { layers: n, order: n, chains: i, crossings: 0 };
-  const f = (k) => o(k.filter((T) => u.has(T))), h = (k) => {
-    const T = f(k);
-    let F = 0;
-    return k.map((j) => u.has(j) ? T[F++] : j);
+  const f = (k) => o(k.filter((F) => u.has(F))), h = (k) => {
+    const F = f(k);
+    let T = 0;
+    return k.map((j) => u.has(j) ? F[T++] : j);
   }, l = (k) => {
-    const T = new Map(s[k + 1].map(($, v) => [$, v])), F = s[k].flatMap(
-      ($) => (d.get($) ?? []).map((v) => T.get(v)).sort((v, S) => v - S)
+    const F = new Map(s[k + 1].map(($, v) => [$, v])), T = s[k].flatMap(
+      ($) => (d.get($) ?? []).map((v) => F.get(v)).sort((v, S) => v - S)
     );
     let j = 0;
-    for (let $ = 0; $ < F.length; $++)
-      for (let v = $ + 1; v < F.length; v++) F[$] > F[v] && j++;
+    for (let $ = 0; $ < T.length; $++)
+      for (let v = $ + 1; v < T.length; v++) T[$] > T[v] && j++;
     return j;
-  }, p = () => s.slice(1).reduce((k, T, F) => k + l(F), 0), m = (k, T, F, j) => {
+  }, p = () => s.slice(1).reduce((k, F, T) => k + l(T), 0), m = (k, F, T, j) => {
     let $ = 0;
-    for (const v of F.get(k) ?? [])
-      for (const S of F.get(T) ?? []) j.get(v) > j.get(S) && $++;
+    for (const v of T.get(k) ?? [])
+      for (const S of T.get(F) ?? []) j.get(v) > j.get(S) && $++;
     return $;
-  }, g = (k) => new Map((s[k] ?? []).map((T, F) => [T, F])), y = (k) => {
-    const T = s[k], F = g(k - 1), j = g(k + 1), $ = (v, S) => m(v, S, r, F) + m(v, S, d, j);
-    for (let v = !0, S = 0; v && S < T.length; S++) {
+  }, g = (k) => new Map((s[k] ?? []).map((F, T) => [F, T])), y = (k) => {
+    const F = s[k], T = g(k - 1), j = g(k + 1), $ = (v, S) => m(v, S, r, T) + m(v, S, d, j);
+    for (let v = !0, S = 0; v && S < F.length; S++) {
       v = !1;
-      for (let M = 0; M + 1 < T.length; M++) {
-        const x = T[M], N = T[M + 1];
+      for (let M = 0; M + 1 < F.length; M++) {
+        const x = F[M], N = F[M + 1];
         if (!($(N, x) >= $(x, N))) {
-          if ([T[M], T[M + 1]] = [N, x], f(T).join(`
-`) !== T.filter((z) => u.has(z)).join(`
+          if ([F[M], F[M + 1]] = [N, x], f(F).join(`
+`) !== F.filter((z) => u.has(z)).join(`
 `)) {
-            [T[M], T[M + 1]] = [x, N];
+            [F[M], F[M + 1]] = [x, N];
             continue;
           }
           v = !0;
         }
       }
     }
-  }, P = (k, T, F) => {
+  }, P = (k, F, T) => {
     const $ = s[k].map((M, x) => {
-      const N = (T.get(M) ?? []).map((z) => F.get(z));
+      const N = (F.get(M) ?? []).map((z) => T.get(z));
       return { id: M, k: x, key: N.length ? N.reduce((z, mt) => z + mt, 0) / N.length : null };
     }).filter((M) => M.key !== null), v = $.map((M) => M.k), S = [...s[k]];
     [...$].sort((M, x) => M.key - x.key || M.k - x.k).forEach((M, x) => S[v[x]] = M.id), s[k] = h(S);
   };
-  let A = s.map((k) => [...k]), w = p();
-  for (let k = 0, T = 0; k < Ef && w && T < 2; k++) {
-    const F = k % 2 === 0, j = F ? s.map((v, S) => S).slice(1) : s.map((v, S) => S).reverse().slice(1);
+  let O = s.map((k) => [...k]), w = p();
+  for (let k = 0, F = 0; k < Ef && w && F < 2; k++) {
+    const T = k % 2 === 0, j = T ? s.map((v, S) => S).slice(1) : s.map((v, S) => S).reverse().slice(1);
     for (const v of j)
-      P(v, F ? r : d, g(F ? v - 1 : v + 1)), y(v);
+      P(v, T ? r : d, g(T ? v - 1 : v + 1)), y(v);
     const $ = p();
-    $ < w ? [A, w, T] = [s.map((v) => [...v]), $, 0] : T++;
+    $ < w ? [O, w, F] = [s.map((v) => [...v]), $, 0] : F++;
   }
   return {
-    layers: A.map((k) => k.filter((T) => u.has(T))),
-    order: A,
+    layers: O.map((k) => k.filter((F) => u.has(F))),
+    order: O,
     chains: i,
     crossings: w
   };
 }
-const Of = 40, _e = (t) => t.charCodeAt(0) === 0;
-class Aa {
+const Af = 40, _e = (t) => t.charCodeAt(0) === 0;
+class Oa {
   parent;
   constructor(e) {
     this.parent = new Map(e.map((o) => [o, o]));
@@ -6833,7 +6858,7 @@ class Aa {
     e = this.find(e), o = this.find(o), e !== o && this.parent.set(o, e);
   }
 }
-function Af(t, e, o, n) {
+function Of(t, e, o, n) {
   const a = o.filter((f) => f.type === "stay");
   if (!a.length) return [];
   const s = new Map(a.map((f) => [f.id, { x: f.x, y: f.y }])), r = /* @__PURE__ */ new Set(), d = n === "right" ? "x" : "y", c = n === "right" ? "y" : "x", u = (f, h) => h === "x" ? f.w : f.h, i = (f, h, l, p, m) => Math.min(h[m] + u(f, m), p[m] + u(l, m)) - Math.max(h[m], p[m]);
@@ -6847,7 +6872,7 @@ function Af(t, e, o, n) {
 function Lf(t, e, o, n, a, s) {
   const r = t.map((v) => v.id), d = new Map(t.map((v) => [v.id, v])), c = new Map(t.map((v) => [v.id, { ...e.get(v.id) }])), u = new Map(r.map((v) => [v, 1])), i = o.filter(
     (v) => "ids" in v ? v.type === "align" && v.ids.every((S) => d.has(S)) : "id" in v && d.has(v.id)
-  ), f = /* @__PURE__ */ new Map(), h = Af(t, e, i, s);
+  ), f = /* @__PURE__ */ new Map(), h = Of(t, e, i, s);
   h.length && a.push({
     level: "info",
     code: "stale-stay",
@@ -6868,7 +6893,7 @@ function Lf(t, e, o, n, a, s) {
     const S = l.get(v);
     if (p.has(v) || !S) return;
     if (m.has(v))
-      throw new Oe(
+      throw new Ae(
         `Relative placement cycle in ${n}. Replace one near with nudge.`,
         S.line
       );
@@ -6885,30 +6910,30 @@ function Lf(t, e, o, n, a, s) {
     }
   const y = new Map(i.flatMap((v) => v.type === "pin" ? [[v.id, v]] : []));
   for (const [v, S] of y) c.set(v, { x: S.x, y: S.y });
-  const P = (v, S) => (v === "x" ? d.get(S).w : d.get(S).h) / 2, A = { x: new Aa(r), y: new Aa(r) };
+  const P = (v, S) => (v === "x" ? d.get(S).w : d.get(S).h) / 2, O = { x: new Oa(r), y: new Oa(r) };
   for (const v of i)
     if (v.type === "align" && v.strength === "required")
       for (const S of v.ids.slice(1)) {
-        const M = /* @__PURE__ */ new Set([A[v.axis].find(v.ids[0]), A[v.axis].find(S)]), x = r.filter((N) => y.has(N) && M.has(A[v.axis].find(N))).map((N) => c.get(N)[v.axis] + P(v.axis, N));
+        const M = /* @__PURE__ */ new Set([O[v.axis].find(v.ids[0]), O[v.axis].find(S)]), x = r.filter((N) => y.has(N) && M.has(O[v.axis].find(N))).map((N) => c.get(N)[v.axis] + P(v.axis, N));
         x.length > 1 && Math.max(...x) - Math.min(...x) > 0.01 ? a.push({
           level: "error",
           code: "pin-align-conflict",
           message: `Pins conflict with required ${v.axis} alignment in ${n}. The pins were kept.`,
           line: v.line,
           ids: v.ids
-        }) : A[v.axis].join(v.ids[0], S);
+        }) : O[v.axis].join(v.ids[0], S);
       }
   const w = { x: /* @__PURE__ */ new Map(), y: /* @__PURE__ */ new Map() };
   for (const v of ["x", "y"])
     for (const S of r) {
-      const M = A[v].find(S), x = c.get(S)[v] + P(v, S);
+      const M = O[v].find(S), x = c.get(S)[v] + P(v, S);
       w[v].has(M) || w[v].set(M, { sum: 0, weight: 0, value: 0, fixed: null, members: [] });
       const N = w[v].get(M);
       N.sum += x * u.get(S), N.weight += u.get(S), N.members.push(S), y.has(S) && (N.fixed = x);
     }
   for (const v of ["x", "y"])
     for (const S of w[v].values()) S.value = S.fixed ?? S.sum / S.weight;
-  const k = (v, S) => w[v].get(A[v].find(S)), T = (v, S) => k(v, S).value, F = (v, S, M, x) => {
+  const k = (v, S) => w[v].get(O[v].find(S)), F = (v, S) => k(v, S).value, T = (v, S, M, x) => {
     const N = k(v, S), z = k(v, M), mt = x - (N.value - z.value);
     if (mt <= 5e-3 || N === z || N.fixed !== null && z.fixed !== null) return 0;
     if (N.fixed !== null) z.value -= mt;
@@ -6925,7 +6950,7 @@ function Lf(t, e, o, n, a, s) {
     let S = 0;
     for (const M of j) {
       const x = M.side === "right" || M.side === "left" ? "x" : "y", N = M.side === "right" || M.side === "below";
-      S += F(
+      S += T(
         x,
         N ? M.id : M.ref,
         N ? M.ref : M.id,
@@ -6934,18 +6959,18 @@ function Lf(t, e, o, n, a, s) {
     }
     for (let M = 0; M < t.length; M++)
       for (let x = M + 1; x < t.length; x++) {
-        const N = t[M], z = t[x], mt = T("x", z.id) - T("x", N.id), it = T("y", z.id) - T("y", N.id), ht = (N.w + z.w) / 2 + An - Math.abs(mt), Q = (N.h + z.h) / 2 + An - Math.abs(it);
+        const N = t[M], z = t[x], mt = F("x", z.id) - F("x", N.id), it = F("y", z.id) - F("y", N.id), ht = (N.w + z.w) / 2 + On - Math.abs(mt), Q = (N.h + z.h) / 2 + On - Math.abs(it);
         if (ht <= 5e-3 || Q <= 5e-3) continue;
         const H = ["x", "y"].filter(
           (W) => k(W, N.id) !== k(W, z.id) && !(k(W, N.id).fixed !== null && k(W, z.id).fixed !== null)
         );
         if (!H.length) continue;
         const J = (W) => (W === "x" ? ht : Q) + (W === $ ? 0 : 3), C = [...H].sort((W, b) => J(W) - J(b))[0], _ = C === "x" ? mt : it;
-        S += F(
+        S += T(
           C,
           _ >= 0 ? z.id : N.id,
           _ >= 0 ? N.id : z.id,
-          (C === "x" ? N.w + z.w : N.h + z.h) / 2 + An
+          (C === "x" ? N.w + z.w : N.h + z.h) / 2 + On
         );
       }
     if (n !== "root")
@@ -6958,8 +6983,8 @@ function Lf(t, e, o, n, a, s) {
   }
   for (const v of t)
     c.set(v.id, {
-      x: Wt(T("x", v.id) - v.w / 2),
-      y: Wt(T("y", v.id) - v.h / 2)
+      x: Wt(F("x", v.id) - v.w / 2),
+      y: Wt(F("y", v.id) - v.h / 2)
     });
   for (let v = 0; v < t.length; v++)
     for (let S = v + 1; S < t.length; S++) {
@@ -6998,7 +7023,7 @@ const $f = 0.5, Gf = 16, zn = (t) => Math.min(t * $f, Math.max(0, t - Gf));
 function co(t, e, o = !1) {
   if (o) return Wn(t, e, !0);
   const n = new Map(t.objects.map((f) => [f.id, f])), a = t.hints.filter(
-    (f) => f.type === "near" && qo(n, f.id, f.ref) !== f.ref
+    (f) => f.type === "near" && Bo(n, f.id, f.ref) !== f.ref
   );
   if (a.length) {
     const f = co(
@@ -7009,7 +7034,7 @@ function co(t, e, o = !1) {
       return m === "x" ? g.x + g.w / 2 : g.y + g.h / 2;
     }, l = t.hints.map((p) => {
       if (!a.includes(p) || p.type !== "near") return p;
-      const m = qo(n, p.id, p.ref), g = p.side === "left" || p.side === "right" ? "y" : "x";
+      const m = Bo(n, p.id, p.ref), g = p.side === "left" || p.side === "right" ? "y" : "x";
       return { ...p, ref: m, offset: p.offset + h(p.ref, g) - h(m, g) };
     });
     return co({ ...t, hints: l }, e);
@@ -7023,67 +7048,67 @@ function co(t, e, o = !1) {
 }
 const bi = /* @__PURE__ */ new WeakMap();
 function Wn(t, e, o = !1, n, a) {
-  const s = t.edges.filter((O) => O.constraint !== !1 && O.directed !== !1), r = new Set(s.filter((O) => !O.dashed).map((O) => O.target)), d = s.filter((O) => !O.dashed || !r.has(O.target)), c = {
+  const s = t.edges.filter((A) => A.constraint !== !1 && A.directed !== !1), r = new Set(s.filter((A) => !A.dashed).map((A) => A.target)), d = s.filter((A) => !A.dashed || !r.has(A.target)), c = {
     port: Math.max(t.routing.portGap ?? 16, t.routing.edgeGap ?? 16),
     track: t.routing.edgeGap ?? 16
   }, u = [], i = /* @__PURE__ */ new Map([["root", []]]);
-  for (const O of t.objects)
-    i.has(O.parent) || i.set(O.parent, []), i.get(O.parent).push(O);
-  const f = Re(t.appearance), h = f.groupHeader, l = /* @__PURE__ */ new Map(), p = f.theme === Zn ? f : Re({ ...t.appearance, theme: Zn }), m = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Map(), A = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map(), k = new Map(t.objects.map((O) => [O.id, O])), T = /* @__PURE__ */ new Map(), F = (O, E) => {
-    let L = k.get(O);
+  for (const A of t.objects)
+    i.has(A.parent) || i.set(A.parent, []), i.get(A.parent).push(A);
+  const f = Re(t.appearance), h = f.groupHeader, l = /* @__PURE__ */ new Map(), p = f.theme === Zn ? f : Re({ ...t.appearance, theme: Zn }), m = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map(), k = new Map(t.objects.map((A) => [A.id, A])), F = /* @__PURE__ */ new Map(), T = (A, E) => {
+    let L = k.get(A);
     for (; L && L.parent !== E; ) L = k.get(L.parent);
     return L?.id;
   }, j = [], $ = [], v = /* @__PURE__ */ new Map(), S = new Set(a?.groups);
   let M = a?.wrap ?? !1;
-  const x = (O) => {
+  const x = (A) => {
     const E = /* @__PURE__ */ new Map();
     for (const L of d) {
-      const R = F(L.source, O);
-      R && F(L.target, O) !== R && E.set(R, [...E.get(R) ?? [], L]);
+      const R = T(L.source, A);
+      R && T(L.target, A) !== R && E.set(R, [...E.get(R) ?? [], L]);
     }
     return new Set(
       [...E].filter(
         ([L, R]) => R.length > 1 && (k.get(L).shape === "diamond" || R.filter((Z) => Z.label).length > 1)
       ).map(([L]) => L)
     );
-  }, N = (O) => d.map((E) => [F(E.source, O), F(E.target, O)]).filter((E) => !!E[0] && !!E[1] && E[0] !== E[1]), z = (O, E, L) => {
-    const R = (D) => F(D, O) !== void 0, Z = t.objects.filter((D) => R(D.id)).map((D) => D.id), V = new Map(
+  }, N = (A) => d.map((E) => [T(E.source, A), T(E.target, A)]).filter((E) => !!E[0] && !!E[1] && E[0] !== E[1]), z = (A, E, L) => {
+    const R = (D) => T(D, A) !== void 0, Z = t.objects.filter((D) => R(D.id)).map((D) => D.id), V = new Map(
       Ln(
         Z,
         d.filter((D) => R(D.source) && R(D.target)).map((D) => [D.source, D.target])
-      ).flatMap((D, ct) => D.map((B) => [B, ct]))
+      ).flatMap((D, ct) => D.map((q) => [q, ct]))
     ), G = new Map(E.map((D) => [D, 1 / 0]));
     for (const D of Z) {
-      const ct = F(D, O);
+      const ct = T(D, A);
       G.set(ct, Math.min(G.get(ct), V.get(D)));
     }
     const X = (D, ct) => {
-      const B = /* @__PURE__ */ new Set([D]), rt = [D];
+      const q = /* @__PURE__ */ new Set([D]), rt = [D];
       for (; rt.length; ) {
         const lt = rt.pop();
         if (lt === ct) return !0;
         for (const [kt, vt] of L)
-          kt === lt && !B.has(vt) && (B.add(vt), rt.push(vt));
+          kt === lt && !q.has(vt) && (q.add(vt), rt.push(vt));
       }
       return !1;
     };
     return L.filter(([D, ct]) => !(G.get(ct) < G.get(D) && X(ct, D)));
-  }, mt = (O) => {
-    const E = e && Bn(t, O), L = i.get(O) ?? [];
-    if (!(!E?.engine || !mf.has(E.engine.algorithm)) && !(O === "root" && !L.some((R) => R.type === "group" || R.soft?.length)) && L.every((R) => e.has(R.id)))
+  }, mt = (A) => {
+    const E = e && qn(t, A), L = i.get(A) ?? [];
+    if (!(!E?.engine || !mf.has(E.engine.algorithm)) && !(A === "root" && !L.some((R) => R.type === "group" || R.soft?.length)) && L.every((R) => e.has(R.id)))
       return xe.settings({
         algorithm: E.engine.algorithm,
         ...E.engine.params
       });
   };
   let it = 0, ht = 0;
-  for (const O of i.keys()) {
-    const E = mt(O);
+  for (const A of i.keys()) {
+    const E = mt(A);
     if (!E) continue;
     it = Math.max(it, E.groupGap);
-    const L = N(O), R = new Map(
+    const L = N(A), R = new Map(
       Ln(
-        (i.get(O) ?? []).map((V) => V.id),
+        (i.get(A) ?? []).map((V) => V.id),
         L
       ).flatMap((V, G) => V.map((X) => [X, G]))
     ), Z = Math.max(0, ...R.values());
@@ -7096,23 +7121,23 @@ function Wn(t, e, o = !1, n, a) {
       );
   }
   it = Math.min(yf, Math.max(it, (ht + 1) * (t.routing.edgeGap ?? 16)));
-  function Q(O) {
-    const E = e && Bn(t, O);
+  function Q(A) {
+    const E = e && qn(t, A);
     if (E?.engine) return $e(E);
-    const L = vo(t, O);
+    const L = vo(t, A);
     return L.algorithm === "row" ? "right" : L.algorithm === "column" ? "down" : $e(L);
   }
-  function H(O, E) {
+  function H(A, E) {
     const L = $e(E) === "right", R = Math.max(E.gap, $l), Z = /* @__PURE__ */ new Map();
-    for (const Gt of O) for (const Yt of i.get(Gt.id) ?? []) Z.set(Yt.id, Gt.id);
+    for (const Gt of A) for (const Yt of i.get(Gt.id) ?? []) Z.set(Yt.id, Gt.id);
     const V = [...Z.keys()], G = (Gt) => m.get(Gt) ?? P.get(Gt), X = (Gt) => L ? G(Gt).w : G(Gt).h, D = (Gt) => L ? G(Gt).h : G(Gt).w, ct = (Gt) => {
       let Yt = k.get(Gt);
       for (; Yt && !Z.has(Yt.id); ) Yt = k.get(Yt.parent);
       return Yt?.id;
-    }, B = d.map((Gt) => [ct(Gt.source), ct(Gt.target)]).filter((Gt) => !!Gt[0] && !!Gt[1] && Gt[0] !== Gt[1]), rt = V.length ? Mi(Ln(V, B), B) : [], lt = new Map(rt.flatMap((Gt, Yt) => Gt.map((Kt) => [Kt, Yt]))), kt = rt.map((Gt) => Math.max(...Gt.map(X))), vt = [];
-    let Ot = 0;
+    }, q = d.map((Gt) => [ct(Gt.source), ct(Gt.target)]).filter((Gt) => !!Gt[0] && !!Gt[1] && Gt[0] !== Gt[1]), rt = V.length ? Mi(Ln(V, q), q) : [], lt = new Map(rt.flatMap((Gt, Yt) => Gt.map((Kt) => [Kt, Yt]))), kt = rt.map((Gt) => Math.max(...Gt.map(X))), vt = [];
+    let At = 0;
     for (const [Gt, Yt] of rt.entries()) {
-      vt.push(Ot);
+      vt.push(At);
       let Kt = R;
       for (const ae of t.edges) {
         const Rt = lt.get(ct(ae.source) ?? ""), Xt = lt.get(ct(ae.target) ?? "");
@@ -7121,32 +7146,32 @@ function Wn(t, e, o = !1, n, a) {
           Kt = Math.max(Kt, L ? te.w : te.h);
         }
       }
-      Ot += kt[Gt] + (Yt === rt.at(-1) ? 0 : Kt);
+      At += kt[Gt] + (Yt === rt.at(-1) ? 0 : Kt);
     }
-    const Et = Ot, Ft = /* @__PURE__ */ new Map();
-    for (const Gt of O) {
+    const Et = At, Tt = /* @__PURE__ */ new Map();
+    for (const Gt of A) {
       const Yt = rt.map((Rt) => Rt.filter((Xt) => Z.get(Xt) === Gt.id)), Kt = (Rt) => Rt.reduce((Xt, te, Ht) => Xt + D(te) + (Ht ? ga : 0), 0), ae = Math.max(Gl, ...Yt.map(Kt));
-      Ft.set(Gt.id, ae), Yt.forEach((Rt, Xt) => {
+      Tt.set(Gt.id, ae), Yt.forEach((Rt, Xt) => {
         let te = (ae - Kt(Rt)) / 2;
         for (const Ht of Rt) {
-          const oe = vt[Xt] + (kt[Xt] - X(Ht)) / 2, Bt = L ? { x: oe, y: te } : { x: te, y: oe };
-          A.set(Ht, { x: Wt(Bt.x), y: Wt(Bt.y) }), w.set(Ht, Bt), te += D(Ht) + ga;
+          const oe = vt[Xt] + (kt[Xt] - X(Ht)) / 2, qt = L ? { x: oe, y: te } : { x: te, y: oe };
+          O.set(Ht, { x: Wt(qt.x), y: Wt(qt.y) }), w.set(Ht, qt), te += D(Ht) + ga;
         }
       });
     }
-    const St = (Gt) => Math.ceil(ce(Gt.label, f.groupTitle)) + no, Qt = Math.max(Et + 2 * ye, ...O.map(St));
+    const St = (Gt) => Math.ceil(ce(Gt.label, f.groupTitle)) + no, Qt = Math.max(Et + 2 * ye, ...A.map(St));
     let Dt = 0;
-    for (const Gt of O) {
-      const Yt = Ft.get(Gt.id);
+    for (const Gt of A) {
+      const Yt = Tt.get(Gt.id);
       Gt.w = L ? Qt : Math.max(Yt + 2 * ye, St(Gt)), Gt.h = h + (L ? Yt : Et) + ye;
       const Kt = L ? { x: 0, y: Dt } : { x: Dt, y: 0 };
-      A.set(Gt.id, Kt), w.set(Gt.id, Kt), Dt += (L ? Gt.h : Gt.w) + ma;
+      O.set(Gt.id, Kt), w.set(Gt.id, Kt), Dt += (L ? Gt.h : Gt.w) + ma;
     }
     const ne = Math.max(0, Dt - ma);
-    return L ? { w: O.length ? Qt : 0, h: ne } : { w: ne, h: O.length ? h + Et + ye : 0 };
+    return L ? { w: A.length ? Qt : 0, h: ne } : { w: ne, h: A.length ? h + Et + ye : 0 };
   }
-  function J(O, E) {
-    const L = O.filter((G) => G.type === "node" && (G.shape === "box" || G.shape === "pill"));
+  function J(A, E) {
+    const L = A.filter((G) => G.type === "node" && (G.shape === "box" || G.shape === "pill"));
     if (L.length < 2) return;
     const R = (G) => t.hints.some((X) => X.type === "size" && X.id === G.id), Z = Math.max(...L.map((G) => G.w)), V = Math.max(...L.map((G) => E.get(G.id)?.ref.w ?? G.w));
     for (const G of L) {
@@ -7160,42 +7185,42 @@ function Wn(t, e, o = !1, n, a) {
       });
     }
   }
-  function C(O) {
-    const E = vo(t, O), L = t.hints.find((I) => I.type === "order" && I.scope === O);
-    let R = i.get(O) ?? [];
-    if (L?.type === "order" && (R = [...L.ids.flatMap((U) => R.filter((nt) => nt.id === U)), ...R.filter((U) => !L.ids.includes(U.id))]), E.algorithm === "cells") return _(O, R, E);
+  function C(A) {
+    const E = vo(t, A), L = t.hints.find((I) => I.type === "order" && I.scope === A);
+    let R = i.get(A) ?? [];
+    if (L?.type === "order" && (R = [...L.ids.flatMap((U) => R.filter((nt) => nt.id === U)), ...R.filter((U) => !L.ids.includes(U.id))]), E.algorithm === "cells") return _(A, R, E);
     const Z = /* @__PURE__ */ new Map(), V = R.map((I) => {
       let U;
       if (I.type === "group") {
-        const q = C(I.id), st = vo(t, I.id), dt = !i.get(I.id)?.length, gt = g.get(I.id);
+        const B = C(I.id), st = vo(t, I.id), dt = !i.get(I.id)?.length, gt = g.get(I.id);
         U = gt !== void 0 ? {
-          w: Math.max(q.w, st.minWidth),
-          h: Math.max(q.h + gt, st.minHeight)
+          w: Math.max(B.w, st.minWidth),
+          h: Math.max(B.h + gt, st.minHeight)
         } : (() => {
           const bt = Math.max(
             dt ? ya.w : 0,
-            q.w + ye + (n?.get(I.id)?.right ?? ye),
+            B.w + ye + (n?.get(I.id)?.right ?? ye),
             st.minWidth
           ), It = tf(I.label, bt, f);
           return It.lines > 1 && l.set(I.id, It.lines), {
             w: Math.max(bt, It.w),
             h: Math.max(
               dt ? ya.h : 0,
-              q.h + Kn(f, It.lines) + (n?.get(I.id)?.bottom ?? ye),
+              B.h + Kn(f, It.lines) + (n?.get(I.id)?.bottom ?? ye),
               st.minHeight
             )
           };
         })();
       } else {
-        const q = t.hints.find((dt) => dt.type === "size" && dt.id === I.id), st = Hn(I, q?.type === "size" ? q : void 0, f);
+        const B = t.hints.find((dt) => dt.type === "size" && dt.id === I.id), st = Hn(I, B?.type === "size" ? B : void 0, f);
         if (U = st, p !== f) {
-          const dt = Hn(I, q?.type === "size" ? q : void 0, p);
+          const dt = Hn(I, B?.type === "size" ? B : void 0, p);
           Z.set(I.id, {
             look: { w: Wt(st.w), h: Wt(st.h) },
             ref: { w: Wt(dt.w), h: Wt(dt.h) }
           });
         }
-        I.shape === "diamond" && !q && st.w > Qa("diamond").w * af && u.push({
+        I.shape === "diamond" && !B && st.w > Qa("diamond").w * af && u.push({
           level: "info",
           code: "big-diamond",
           message: `${I.id}'s question makes its diamond ${Wt(st.w)}px square, much larger than the shapes around it. Shorten the question, or move the detail onto its edges' labels.`,
@@ -7205,48 +7230,48 @@ function Wn(t, e, o = !1, n, a) {
           level: "warning",
           code: "text-overflow",
           message: `${I.id}'s title does not fit in its requested size. Make it larger or remove the size line.`,
-          line: q?.line,
+          line: B?.line,
           ids: [I.id]
         });
       }
       const nt = { ...I, w: Wt(U.w), h: Wt(U.h) };
       return P.set(I.id, nt), nt;
     });
-    if (E.algorithm === "column" && J(V, Z), O === "root" && E.algorithm === "lanes") return H(V, E);
-    const G = N(O), X = k.get(O)?.parent, D = X !== void 0 && Q(X) === Q(O), ct = (O === "root" ? [] : t.edges).flatMap((I) => {
-      const U = F(I.source, O), nt = F(I.target, O);
-      return !U && !nt || U === nt || !(U && nt) && !D ? [] : [{ a: U, b: nt, label: I.label && !(U && nt) ? Te(I.label, f) : void 0 }];
-    }), B = /* @__PURE__ */ new Map();
+    if (E.algorithm === "column" && J(V, Z), A === "root" && E.algorithm === "lanes") return H(V, E);
+    const G = N(A), X = k.get(A)?.parent, D = X !== void 0 && Q(X) === Q(A), ct = (A === "root" ? [] : t.edges).flatMap((I) => {
+      const U = T(I.source, A), nt = T(I.target, A);
+      return !U && !nt || U === nt || !(U && nt) && !D ? [] : [{ a: U, b: nt, label: I.label && !(U && nt) ? Fe(I.label, f) : void 0 }];
+    }), q = /* @__PURE__ */ new Map();
     for (const I of d) {
-      const U = F(I.source, O), nt = F(I.target, O);
-      U && !nt && B.set(U, [...B.get(U) ?? [], I.target]), nt && !U && B.set(nt, [...B.get(nt) ?? [], I.source]);
+      const U = T(I.source, A), nt = T(I.target, A);
+      U && !nt && q.set(U, [...q.get(U) ?? [], I.target]), nt && !U && q.set(nt, [...q.get(nt) ?? [], I.source]);
     }
     const rt = (I, U) => {
-      const nt = A.get(I), q = m.get(I) ?? P.get(I);
-      return U ? nt.y + q.h / 2 : nt.x + q.w / 2;
-    }, lt = /* @__PURE__ */ new Map(), kt = k.get(O)?.parent, vt = kt !== void 0 && i.get(kt) || [], Ot = V.map((I) => B.get(I.id) ?? []), Et = Ot[0]?.length === 1 ? k.get(Ot[0][0])?.parent : void 0, Ft = vt.findIndex((I) => I.id === Et) < vt.findIndex((I) => I.id === O);
-    if (Et !== void 0 && Et !== O && vt.some((I) => I.id === Et) && Ft && Ot.every((I) => I.length === 1 && k.get(I[0])?.parent === Et && A.has(I[0])))
+      const nt = O.get(I), B = m.get(I) ?? P.get(I);
+      return U ? nt.y + B.h / 2 : nt.x + B.w / 2;
+    }, lt = /* @__PURE__ */ new Map(), kt = k.get(A)?.parent, vt = kt !== void 0 && i.get(kt) || [], At = V.map((I) => q.get(I.id) ?? []), Et = At[0]?.length === 1 ? k.get(At[0][0])?.parent : void 0, Tt = vt.findIndex((I) => I.id === Et) < vt.findIndex((I) => I.id === A);
+    if (Et !== void 0 && Et !== A && vt.some((I) => I.id === Et) && Tt && At.every((I) => I.length === 1 && k.get(I[0])?.parent === Et && O.has(I[0])))
       for (const [I, U] of V.entries())
-        lt.set(U.id, rt(Ot[I][0], Q(Et) === "right"));
+        lt.set(U.id, rt(At[I][0], Q(Et) === "right"));
     const St = (I, U) => {
-      if (T.get(U) !== I) return;
-      const nt = Q(O) === "right", q = (gt) => nt ? Kn(f, l.get(gt)) : ye, dt = t.edges.filter(
+      if (F.get(U) !== I) return;
+      const nt = Q(A) === "right", B = (gt) => nt ? Kn(f, l.get(gt)) : ye, dt = t.edges.filter(
         (gt) => k.get(gt.source)?.parent === I && k.get(gt.target)?.parent === U
       ).sort((gt, bt) => rt(gt.target, nt) - rt(bt.target, nt))[0];
-      return dt ? q(I) + rt(dt.source, nt) - q(U) - rt(dt.target, nt) : void 0;
+      return dt ? B(I) + rt(dt.source, nt) - B(U) - rt(dt.target, nt) : void 0;
     }, Qt = t.edges.flatMap((I) => {
-      const U = F(I.source, O), nt = F(I.target, O);
+      const U = T(I.source, A), nt = T(I.target, A);
       if (!I.label || !U || !nt || U === nt) return [];
-      const q = bo(U, nt, I.label, f);
-      if (p === f) return [q];
+      const B = bo(U, nt, I.label, f);
+      if (p === f) return [B];
       const st = bo(U, nt, I.label, p);
-      return [{ a: U, b: nt, w: Math.max(st.w, q.w - Fe), h: Math.max(st.h, q.h - Fe) }];
-    }), Dt = e && Bn(t, O), ne = mt(O), Gt = ne ? { node: ne.nodeGap, rank: ne.rankGap, group: it } : void 0, Yt = ne ? z(
-      O,
+      return [{ a: U, b: nt, w: Math.max(st.w, B.w - Te), h: Math.max(st.h, B.h - Te) }];
+    }), Dt = e && qn(t, A), ne = mt(A), Gt = ne ? { node: ne.nodeGap, rank: ne.rankGap, group: it } : void 0, Yt = ne ? z(
+      A,
       V.map((I) => I.id),
       G
-    ) : void 0, Kt = Dt?.engine && Dt.scope === O ? Dt.engine : void 0, ae = (I, U) => {
-      const nt = E.algorithm === "row" ? "right" : E.algorithm === "column" ? "down" : I, q = {
+    ) : void 0, Kt = Dt?.engine && Dt.scope === A ? Dt.engine : void 0, ae = (I, U) => {
+      const nt = E.algorithm === "row" ? "right" : E.algorithm === "column" ? "down" : I, B = {
         x: !!Dt?.engine || nt === "right",
         y: !!Dt?.engine || nt === "down"
       }, st = (gt) => o ? gt : Z.get(gt.id)?.look ?? gt, dt = /* @__PURE__ */ new Map();
@@ -7263,8 +7288,8 @@ function Wn(t, e, o = !1, n, a) {
           return [
             gt.id,
             {
-              x: q.x ? (gt.w - bt.w) / 2 : 0,
-              y: dt.get(gt.id) ?? (q.y ? (gt.h - bt.h) / 2 : 0),
+              x: B.x ? (gt.w - bt.w) / 2 : 0,
+              y: dt.get(gt.id) ?? (B.y ? (gt.h - bt.h) / 2 : 0),
               w: bt.w,
               h: bt.h
             }
@@ -7283,21 +7308,21 @@ function Wn(t, e, o = !1, n, a) {
         Yt,
         tt,
         Gt,
-        O === "root",
+        A === "root",
         ct,
-        B,
+        q,
         lt,
         St
-      ) : Dt?.engine && V.every((yt) => e.has(yt.id)) ? pf(V, e, $e(Dt), tt) : Sf(V, E, G, tt, ct, c), nt = Qt.length ? U([]) : void 0, q = nt ? gf(
+      ) : Dt?.engine && V.every((yt) => e.has(yt.id)) ? pf(V, e, $e(Dt), tt) : Sf(V, E, G, tt, ct, c), nt = Qt.length ? U([]) : void 0, B = nt ? gf(
         new Map(
           V.map((tt) => {
-            const yt = nt.positions.get(tt.id), At = ae(nt.axis, nt.positions).get(tt.id);
-            return [tt.id, { x: yt.x + At.x, y: yt.y + At.y, w: At.w, h: At.h }];
+            const yt = nt.positions.get(tt.id), Ot = ae(nt.axis, nt.positions).get(tt.id);
+            return [tt.id, { x: yt.x + Ot.x, y: yt.y + Ot.y, w: Ot.w, h: Ot.h }];
           })
         ),
         nt.axis,
         Qt
-      ) : /* @__PURE__ */ new Set(), st = U(Qt.filter((tt) => !q.has(tt)));
+      ) : /* @__PURE__ */ new Set(), st = U(Qt.filter((tt) => !B.has(tt)));
       let dt;
       if (Kt ? !ne && Kt.algorithm === "layered" && Kt.params.fold !== "never" : !Dt?.engine && E.algorithm === "flow" && E.fold === "auto") {
         const tt = ko(
@@ -7307,13 +7332,13 @@ function Wn(t, e, o = !1, n, a) {
           E.gap,
           G,
           Qt,
-          x(O),
+          x(A),
           (nt ?? st).positions
         );
         st.positions = tt.positions, dt = tt.fold;
       }
       const gt = !dt && ne && Dt?.engine?.params.fold !== "never";
-      if (gt && S.has(O)) {
+      if (gt && S.has(A)) {
         const tt = ko(
           V,
           st.positions,
@@ -7321,13 +7346,13 @@ function Wn(t, e, o = !1, n, a) {
           Gt.rank,
           G,
           Qt,
-          x(O),
+          x(A),
           (nt ?? st).positions,
           { fewest: 2, room: 0 }
         );
         st.positions = tt.positions, dt = tt.fold;
       }
-      if (gt && O === "root" && M) {
+      if (gt && A === "root" && M) {
         const tt = ko(
           V,
           st.positions,
@@ -7335,23 +7360,23 @@ function Wn(t, e, o = !1, n, a) {
           Gt.rank,
           G,
           Qt,
-          x(O),
+          x(A),
           (nt ?? st).positions,
           { aspect: Ia, fewest: 2 }
         );
         st.positions = tt.positions, dt = tt.fold;
       }
-      const bt = n?.get(O);
+      const bt = n?.get(A);
       if (bt && (bt.left > ye || bt.top))
         for (const [tt, yt] of st.positions)
           st.positions.set(tt, { x: yt.x + bt.left - ye, y: yt.y + bt.top });
       const It = ae(st.axis, st.positions), Ct = Z.size ? t.hints.map(
         (tt) => (tt.type === "stay" || tt.type === "pin") && It.has(tt.id) ? { ...tt, x: tt.x - It.get(tt.id).x, y: tt.y - It.get(tt.id).y } : tt
-      ) : t.hints, ut = Lf(V, st.positions, Ct, O, u, st.axis);
-      return "followed" in st && st.followed ? T.set(O, Et) : T.delete(O), { base: st, fold: dt, pos: ut, off: It };
+      ) : t.hints, ut = Lf(V, st.positions, Ct, A, u, st.axis);
+      return "followed" in st && st.followed ? F.set(A, Et) : F.delete(A), { base: st, fold: dt, pos: ut, off: It };
     }, Xt = (I, U) => {
-      const nt = U.pos.get(I.id), q = U.off.get(I.id);
-      return { x: nt.x + q.x, y: nt.y + q.y, w: q.w, h: q.h };
+      const nt = U.pos.get(I.id), B = U.off.get(I.id);
+      return { x: nt.x + B.x, y: nt.y + B.y, w: B.w, h: B.h };
     }, te = (I, U) => ({
       ...U.pos.get(I.id),
       w: I.w,
@@ -7360,35 +7385,35 @@ function Wn(t, e, o = !1, n, a) {
       const I = zn(Dt.engine.params.rankGap ?? 52), U = zn(Dt.engine.params.nodeGap ?? 24);
       return $e(Dt) === "right" ? { w: I, h: U } : { w: U, h: I };
     })() : { w: zn(E.gap), h: zn(E.gap) } : { w: 0, h: 0 }, oe = u.length;
-    let Bt = Rt(Ht);
+    let qt = Rt(Ht);
     !o && (Ht.w || Ht.h) && V.some(
       (I, U) => V.slice(U + 1).some(
-        (nt) => xa(te(I, Bt), te(nt, Bt)) >= An - 0.5 && xa(Xt(I, Bt), Xt(nt, Bt)) < An - 0.5
+        (nt) => xa(te(I, qt), te(nt, qt)) >= On - 0.5 && xa(Xt(I, qt), Xt(nt, qt)) < On - 0.5
       )
-    ) && (u.length = oe, Bt = Rt({ w: 0, h: 0 })), Bt.fold && j.push({ scope: O, fold: Bt.fold });
-    const le = Bt.base.corridors;
-    le && O === "root" && !Bt.fold && !n?.get(O) && V.every((I) => {
-      const U = Bt.pos.get(I.id), nt = Bt.base.positions.get(I.id);
+    ) && (u.length = oe, qt = Rt({ w: 0, h: 0 })), qt.fold && j.push({ scope: A, fold: qt.fold });
+    const le = qt.base.corridors;
+    le && A === "root" && !qt.fold && !n?.get(A) && V.every((I) => {
+      const U = qt.pos.get(I.id), nt = qt.base.positions.get(I.id);
       return U && nt && Math.abs(U.x - nt.x) < 0.01 && Math.abs(U.y - nt.y) < 0.01;
-    }) && v.set(O, { axis: Bt.base.axis, corridors: le }), (Kt ? Kt.algorithm === "layered" : !Dt?.engine && E.algorithm === "flow") && $.push({ scope: O, axis: Bt.base.axis });
-    const fe = V.map((I) => Xt(I, Bt)), de = O === "root" ? 0 : Math.max(0, ...V.map((I) => I.soft?.length ?? 0)), he = O === "root" || !V.length ? { x: 0, y: 0 } : {
-      x: Math.max(0, -Math.min(...fe.map((I) => I.x))) + de * On,
-      y: Math.max(0, -Math.min(...fe.map((I) => I.y))) + de * (On + oo)
+    }) && v.set(A, { axis: qt.base.axis, corridors: le }), (Kt ? Kt.algorithm === "layered" : !Dt?.engine && E.algorithm === "flow") && $.push({ scope: A, axis: qt.base.axis });
+    const fe = V.map((I) => Xt(I, qt)), de = A === "root" ? 0 : Math.max(0, ...V.map((I) => I.soft?.length ?? 0)), he = A === "root" || !V.length ? { x: 0, y: 0 } : {
+      x: Math.max(0, -Math.min(...fe.map((I) => I.x))) + de * An,
+      y: Math.max(0, -Math.min(...fe.map((I) => I.y))) + de * (An + oo)
     };
     for (const [I, U] of V.entries()) {
-      const nt = fe[I], q = Bt.off.get(U.id), st = Bt.base.positions.get(U.id);
-      A.set(U.id, { x: Wt(nt.x + he.x), y: Wt(nt.y + he.y) }), w.set(U.id, { x: st.x + q.x + he.x, y: st.y + q.y + he.y }), Z.has(U.id) && m.set(U.id, { w: Wt(nt.w), h: Wt(nt.h) });
+      const nt = fe[I], B = qt.off.get(U.id), st = qt.base.positions.get(U.id);
+      O.set(U.id, { x: Wt(nt.x + he.x), y: Wt(nt.y + he.y) }), w.set(U.id, { x: st.x + B.x + he.x, y: st.y + B.y + he.y }), Z.has(U.id) && m.set(U.id, { w: Wt(nt.w), h: Wt(nt.h) });
     }
     const we = (I, U) => V.length ? Math.max(
       ...V.map(
-        (nt, q) => Math.max(Bt.pos.get(nt.id)[I] + nt[U], fe[q][I] + fe[q][U])
+        (nt, B) => Math.max(qt.pos.get(nt.id)[I] + nt[U], fe[B][I] + fe[B][U])
       )
-    ) + he[I] + de * On : 0;
+    ) + he[I] + de * An : 0;
     return { w: we("x", "w"), h: we("y", "h") };
   }
-  function _(O, E, L) {
-    if (L.unit) return W(O, E, L);
-    const R = Math.ceil(ce(k.get(O).label, f.groupTitle)) + qr, Z = (G) => t.hints.find((X) => X.type === "size" && X.id === G), V = cc(
+  function _(A, E, L) {
+    if (L.unit) return W(A, E, L);
+    const R = Math.ceil(ce(k.get(A).label, f.groupTitle)) + Br, Z = (G) => t.hints.find((X) => X.type === "size" && X.id === G), V = cc(
       E.map((G) => {
         const X = Z(G.id);
         return {
@@ -7406,9 +7431,9 @@ function Wn(t, e, o = !1, n, a) {
       f,
       R
     );
-    return b(O, E, V.boxes), g.set(O, ao(f.groupTitle.lineHeight)), { w: Math.max(V.w, R), h: V.h };
+    return b(A, E, V.boxes), g.set(A, ao(f.groupTitle.lineHeight)), { w: Math.max(V.w, R), h: V.h };
   }
-  function W(O, E, L) {
+  function W(A, E, L) {
     const R = dc(
       E.map((G) => ({
         id: G.id,
@@ -7425,7 +7450,7 @@ function Wn(t, e, o = !1, n, a) {
       },
       f
     ), Z = ao(f.groupTitle.lineHeight), V = Z + (R.ruler?.h ?? 0);
-    return b(O, E, R.boxes), g.set(O, V), y.set(O, {
+    return b(A, E, R.boxes), g.set(A, V), y.set(A, {
       ...R.ruler ? { ruler: { y: Z, ...R.ruler } } : {},
       ...R.pieces.size ? {
         pieces: Object.fromEntries(
@@ -7435,41 +7460,41 @@ function Wn(t, e, o = !1, n, a) {
       ...R.open.length ? { open: R.open } : {}
     }), { w: R.w, h: R.h };
   }
-  function b(O, E, L) {
+  function b(A, E, L) {
     for (const R of E) {
       const Z = L.get(R.id);
-      P.set(R.id, { ...R, w: Wt(Z.w), h: Wt(Z.h) }), A.set(R.id, { x: Wt(Z.x), y: Wt(Z.y) }), w.set(R.id, { x: Z.x, y: Z.y });
+      P.set(R.id, { ...R, w: Wt(Z.w), h: Wt(Z.h) }), O.set(R.id, { x: Wt(Z.x), y: Wt(Z.y) }), w.set(R.id, { x: Z.x, y: Z.y });
       const V = t.hints.find(
         (G) => kl.includes(G.type) && "id" in G && G.id === R.id
       );
       V && u.push({
         level: "warning",
         code: "cell-position",
-        message: `${R.id} is a cell of ${O}, so it stays in its place. Move ${O} instead, or reorder its cells with order.`,
+        message: `${R.id} is a cell of ${A}, so it stays in its place. Move ${A} instead, or reorder its cells with order.`,
         line: V.line,
         ids: [R.id]
       });
     }
   }
-  const Y = u.length, et = mt("root") && Bn(t, "root");
+  const Y = u.length, et = mt("root") && qn(t, "root");
   let at = C("root");
   if (!a && et && et.engine?.params.fold !== "never") {
-    let O = function(G) {
+    let A = function(G) {
       return L(G) > xi * R(G);
     };
     const E = $e(et) === "right", L = (G) => E ? G.w : G.h, R = (G) => E ? G.h : G.w, Z = E ? sn.width : sn.height, V = (G) => L(G) > Z && L(G) > Ia * R(G);
     for (; V(at) && !M; ) {
       const G = [...P.values()].filter(
-        (X) => X.type === "group" && !S.has(X.id) && mt(X.id) && O(X)
+        (X) => X.type === "group" && !S.has(X.id) && mt(X.id) && A(X)
       ).sort((X, D) => L(D) - L(X))[0];
       G ? S.add(G.id) : M = !0, u.length = Y, j.length = $.length = 0, m.clear(), at = C("root");
     }
   }
   if (!a && et && $e(et) === "down" && et.engine?.params.fold !== "never") {
-    const O = (L) => L.h, E = (L) => L.w * L.h;
+    const A = (L) => L.h, E = (L) => L.w * L.h;
     for (; ; ) {
-      const L = (i.get("root") ?? []).map((G) => P.get(G.id)).filter(Boolean).sort((G, X) => O(X) - O(G)), [R, Z] = L;
-      if (!R || !Z || R.type !== "group" || R.fold === "never" || S.has(R.id) || !mt(R.id) || O(R) < ef * O(Z))
+      const L = (i.get("root") ?? []).map((G) => P.get(G.id)).filter(Boolean).sort((G, X) => A(X) - A(G)), [R, Z] = L;
+      if (!R || !Z || R.type !== "group" || R.fold === "never" || S.has(R.id) || !mt(R.id) || A(R) < ef * A(Z))
         break;
       const V = at;
       if (S.add(R.id), u.length = Y, j.length = $.length = 0, m.clear(), at = C("root"), !(E(at) < E(V))) {
@@ -7478,9 +7503,9 @@ function Wn(t, e, o = !1, n, a) {
       }
     }
   }
-  const pt = [], ot = (O, E, L) => {
-    for (const R of i.get(O) ?? []) {
-      const Z = m.get(R.id) ?? P.get(R.id), V = A.get(R.id), G = w.get(R.id), X = {
+  const pt = [], ot = (A, E, L) => {
+    for (const R of i.get(A) ?? []) {
+      const Z = m.get(R.id) ?? P.get(R.id), V = O.get(R.id), G = w.get(R.id), X = {
         ...R,
         x: E.x + V.x,
         y: E.y + V.y,
@@ -7501,43 +7526,43 @@ function Wn(t, e, o = !1, n, a) {
     }
   };
   ot("root", { x: 0, y: 0 }, 0);
-  const K = Pf(v, pt, d, F, c), ft = df(
+  const K = Pf(v, pt, d, T, c), ft = df(
     j,
     t.edges,
-    new Map(pt.map((O) => [O.id, O])),
-    F,
+    new Map(pt.map((A) => [A.id, A])),
+    T,
     Math.max(t.routing.portGap ?? 16, t.routing.edgeGap ?? 16)
   );
-  for (const [O, E] of Ic(
+  for (const [A, E] of Ic(
     $.map((L) => ({ ...L, bands: j.find((R) => R.scope === L.scope)?.fold.bands })),
     t.edges,
     new Map(pt.map((L) => [L.id, L])),
     new Set(ft.keys()),
-    (L) => Te(L, f)
+    (L) => Fe(L, f)
   ))
-    ft.set(O, E);
-  for (const O of t.layouts) {
-    const E = pt.find((L) => L.id === O.scope);
-    !E || !O.minWidth && !O.minHeight || (O.minWidth && E.w > O.minWidth + 0.5 || O.minHeight && E.h > O.minHeight + 0.5) && u.push({
+    ft.set(A, E);
+  for (const A of t.layouts) {
+    const E = pt.find((L) => L.id === A.scope);
+    !E || !A.minWidth && !A.minHeight || (A.minWidth && E.w > A.minWidth + 0.5 || A.minHeight && E.h > A.minHeight + 0.5) && u.push({
       level: "info",
       code: "group-grew",
       message: `${E.id} needs at least ${E.w}×${E.h} for its contents.`,
-      line: O.line,
+      line: A.line,
       ids: [E.id]
     });
   }
   pl(t), u.push(...Xl(t), ...fl(t));
-  for (const O of t.warnings) u.push({ level: "warning", ...O, ids: [] });
-  const Mt = new Map(t.objects.map((O, E) => [O.id, E]));
-  pt.sort((O, E) => Mt.get(O.id) - Mt.get(E.id));
+  for (const A of t.warnings) u.push({ level: "warning", ...A, ids: [] });
+  const Mt = new Map(t.objects.map((A, E) => [A.id, E]));
+  pt.sort((A, E) => Mt.get(A.id) - Mt.get(E.id));
   const xt = {
     model: t,
     title: t.title,
     objects: pt,
-    byId: new Map(pt.map((O) => [O.id, O])),
-    edges: t.edges.map((O) => {
-      const E = ft.get(O.id), L = E ? void 0 : K.get(O.id);
-      return E ? { ...O, lane: E } : L ? { ...O, plan: L } : O;
+    byId: new Map(pt.map((A) => [A.id, A])),
+    edges: t.edges.map((A) => {
+      const E = ft.get(A.id), L = E ? void 0 : K.get(A.id);
+      return E ? { ...A, lane: E } : L ? { ...A, plan: L } : A;
     }),
     diagnostics: u,
     look: f,
@@ -7571,10 +7596,10 @@ function Pf(t, e, o, n, a) {
   }
   return s;
 }
-function Tf(t) {
-  return t.kind === "scene" ? _f(t.source, t.view) : t.kind === "compile" ? vi(t.source) : t.kind === "layout" ? xe.compute(t.doc, t.options) : t.kind === "route" ? Promise.resolve(pn.compute(t.input, t.options)) : t.kind === "candidate" ? Na.candidate(t.baseline, t.spec, t.config) : t.kind === "source" ? Ff(t.source, t.spec) : mr.journey(t.doc, t.options);
+function Ff(t) {
+  return t.kind === "scene" ? _f(t.source, t.view) : t.kind === "compile" ? vi(t.source) : t.kind === "layout" ? xe.compute(t.doc, t.options) : t.kind === "route" ? Promise.resolve(pn.compute(t.input, t.options)) : t.kind === "candidate" ? Na.candidate(t.baseline, t.spec, t.config) : t.kind === "source" ? Tf(t.source, t.spec) : mr.journey(t.doc, t.options);
 }
-async function Ff(t, e) {
+async function Tf(t, e) {
   const o = cs(await gi(t)), n = pn.compute(Na.sceneInput(o), {
     ...o.settings.routing,
     previous: []
@@ -7598,7 +7623,7 @@ async function _f(t, e) {
 self.onmessage = async ({ data: t }) => {
   const e = "id" in t ? t.id : void 0, o = "id" in t ? t.task : t;
   try {
-    self.postMessage({ id: e, ok: !0, result: await Tf(o) });
+    self.postMessage({ id: e, ok: !0, result: await Ff(o) });
   } catch (n) {
     self.postMessage({
       id: e,